<activity android:allowTaskReparenting=["true" | "false"] android:alwaysRetainTaskState=["true" | "false"] android:clearTaskOnLaunch=["true" | "false"] android:configChanges=["mcc", "mnc", "locale", "touchscreen", "keyboard", "keyboardHidden", "navigation", "orientation", "screenLayout", "fontScale", "uiMode"] android:enabled=["true" | "false"] android:excludeFromRecents=["true" | "false"] android:exported=["true" | "false"] android:finishOnTaskLaunch=["true" | "false"] android:icon="drawable resource" android:label="string resource" android:launchMode=["multiple" | "singleTop" | "singleTask" | "singleInstance"] android:multiprocess=["true" | "false"] android:name="string" android:noHistory=["true" | "false"] android:permission="string" android:process="string" android:screenOrientation=["unspecified" | "user" | "behind" | "landscape" | "portrait" | "sensor" | "nosensor"] android:stateNotNeeded=["true" | "false"] android:taskAffinity="string" android:theme="resource or theme" android:windowSoftInputMode=["stateUnspecified", "stateUnchanged", "stateHidden", "stateAlwaysHidden", "stateVisible", "stateAlwaysVisible", "adjustUnspecified", "adjustResize", "adjustPan"] > . . . </activity>
<application>
<intent-filter>
<meta-data>
Activity
subclass) that
implements part of the application's visual user interface. All activities
must be represented by <activity>
elements in the manifest file. Any that are not declared there will not be seen
by the system and will never be run.
android:allowTaskReparenting
true
" if it can move, and "false
" if it
must remain with the task where it started.
If this attribute is not set, the value set by the corresponding
allowTaskReparenting
attribute of the <application>
element
applies to the activity. The default value is "false
".
Normally when an activity is started, it's associated with the task of the activity that started it and it stays there for its entire lifetime. You can use this attribute to force it to be re-parented to the task it has an affinity for when its current task is no longer displayed. Typically, it's used to cause the activities of an application to move to the main task associated with that application.
For example, if an e-mail message contains a link to a web page, clicking the link brings up an activity that can display the page. That activity is defined by the browser application, but is launched as part of the e-mail task. If it's reparented to the browser task, it will be shown when the browser next comes to the front, and will be absent when the e-mail task again comes forward.
The affinity of an activity is defined by the
taskAffinity
attribute. The affinity
of a task is determined by reading the affinity of its root activity.
Therefore, by definition, a root activity is always in a task with the
same affinity. Since activities with "singleTask
" or
"singleInstance
" launch modes can only be at the root of a task,
re-parenting is limited to the "standard
" and "singleTop
"
modes. (See also the launchMode
attribute.)
android:alwaysRetainTaskState
true
" if it will be, and
"false
" if the system is allowed to reset the task to its initial
state in certain situations. The default value is "false
". This
attribute is meaningful only for the root activity of a task; it's ignored
for all other activities.
Normally, the system clears a task (removes all activities from the stack above the root activity) in certain situations when the user re-selects that task from the home screen. Typically, this is done if the user hasn't visited the task for a certain amount of time, such as 30 minutes.
However, when this attribute is "true
", users will always return
to the task in its last state, regardless of how they get there. This is
useful, for example, in an application like the web browser where there is
a lot of state (such as multiple open tabs) that users would not like to lose.
android:clearTaskOnLaunch
true
" if the task is always stripped down to its root activity, and
"false
" if not. The default value is "false
". This attribute
is meaningful only for activities that start a new task (the root activity);
it's ignored for all other activities in the task.
When the value is "true
", every time users start the task again, they
are brought to its root activity, regardless of what they were last doing in
the task and regardless of whether they used BACK or HOME to last leave it.
When the value is "false
", the task may be cleared of activities in
some situations (see the
alwaysRetainTaskState
attribute), but not always.
Suppose, for example, that someone launches activity P from the home screen,
and from there goes to activity Q. The user next presses HOME, and then returns
to activity P. Normally, the user would see activity Q, since that is what they
were last doing in P's task. However, if P set this flag to "true
", all
of the activities on top of it (Q in this case) were removed when the user pressed
HOME and the task went to the background. So the user sees only P when returning
to the task.
If this attribute and allowTaskReparenting
are both "true
", any activities that can be re-parented are moved to
the task they share an affinity with; the remaining activities are then dropped,
as described above.
android:configChanges
onConfigurationChanged()
method is called.
Note: Using this attribute should be avoided and used only as a last-resort. Please read Handling Runtime Changes for more information about how to properly handle a restart due to a configuration change.
Any or all of the following strings are valid values for this attribute. Multiple values are
separated by '|
' — for example, "locale|navigation|orientation
".
Value | Description |
---|---|
"mcc " |
The IMSI mobile country code (MCC) has changed — a SIM has been detected and updated the MCC. |
"mnc " |
The IMSI mobile network code (MNC) has changed — a SIM has been detected and updated the MNC. |
"locale " |
The locale has changed — the user has selected a new language that text should be displayed in. |
"touchscreen " |
The touchscreen has changed. (This should never normally happen.) |
"keyboard " |
The keyboard type has changed — for example, the user has plugged in an external keyboard. |
"keyboardHidden " |
The keyboard accessibility has changed — for example, the user has revealed the hardware keyboard. |
"navigation " |
The navigation type (trackball/dpad) has changed. (This should never normally happen.) |
"orientation " |
The screen orientation has changed — the user has rotated the device. |
"screenLayout " |
The screen layout has changed — this might be caused by a different display being activated. |
"fontScale " |
The font scaling factor has changed — the user has selected a new global font size. |
"uiMode " |
The user interface mode has changed — this can be caused when the user places the
device into a desk/car dock or when the the night mode changes. See UiModeManager . Introduced in API Level 8. |
All of these configuration changes can impact the resource values seen by the
application. Therefore, when
is called, it will generally be necessary to again
retrieve all resources (including view layouts, drawables, and so on) to correctly
handle the change.
onConfigurationChanged()
android:enabled
true
" if it can be, and "false
" if not. The default value
is "true
".
The <application>
element has its own
enabled
attribute that applies to all application components, including activities. The
<application>
and <activity>
attributes must both be "true
" (as they both
are by default) for the system to be able to instantiate the activity. If either
is "false
", it cannot be instantiated.
android:excludeFromRecents
true
" if
it should be excluded, and "false
" if it should be included.
The default value is "false
".
android:exported
true
" if it can be, and "false
" if not.
If "false
", the activity can be launched only by components of the
same application or applications with the same user ID.
The default value depends on whether the activity contains intent filters. The
absence of any filters means that the activity can be invoked only by specifying
its exact class name. This implies that the activity is intended only for
application-internal use (since others would not know the class name). So in
this case, the default value is "false
".
On the other hand, the presence of at least one filter implies that the activity
is intended for external use, so the default value is "true
".
This attribute is not the only way to limit an activity's exposure to other
applications. You can also use a permission to limit the external entities that
can invoke the activity (see the
permission
attribute).
android:finishOnTaskLaunch
true
" if it should be shut down, and "false
"
if not. The default value is "false
".
If this attribute and
allowTaskReparenting
are both "true
", this attribute trumps the other. The affinity of the
activity is ignored. The activity is not re-parented, but destroyed.
android:icon
label
attribute).
This attribute must be set as a reference to a drawable resource containing
the image definition. If it is not set, the icon specified for the application
as a whole is used instead (see the
<application>
element's icon
attribute).
The activity's icon — whether set here or by the
<application>
element — is also the default icon for all the activity's intent filters (see the
<intent-filter>
element's
icon
attribute).
android:label
If this attribute is not set, the label set for the application as a whole is
used instead (see the <application>
element's
label
attribute).
The activity's label — whether set here or by the
<application>
element — is also the
default label for all the activity's intent filters (see the
<intent-filter>
element's
label
attribute).
The label should be set as a reference to a string resource, so that it can be localized like other strings in the user interface. However, as a convenience while you're developing the application, it can also be set as a raw string.
android:launchMode
FLAG_ACTIVITY_*
constants)
in Intent
objects to determine what should happen when
the activity is called upon to handle an intent. They are:
"standard
"
"singleTop
"
"singleTask
"
"singleInstance
"
The default mode is "standard
".
As shown in the table below, the modes fall into two main groups, with
"standard
" and "singleTop
" activities on one side, and
"singleTask
" and "singleInstance
" activities on the other.
An activity with the "standard
" or "singleTop
" launch mode
can be instantiated multiple times. The instances can belong to any task
and can be located anywhere in the activity stack. Typically, they're
launched into the task that called
(unless the Intent object contains a
startActivity()
instruction, in which case a different task is chosen — see the
taskAffinity attribute).
FLAG_ACTIVITY_NEW_TASK
In contrast, "singleTask
" and "singleInstance
" activities
can only begin a task. They are always at the root of the activity stack.
Moreover, the device can hold only one instance of the activity at a time
— only one such task.
The "standard
" and "singleTop
" modes differ from each other
in just one respect: Every time there's a new intent for a "standard
"
activity, a new instance of the class is created to respond to that intent.
Each instance handles a single intent.
Similarly, a new instance of a "singleTop
" activity may also be
created to handle a new intent. However, if the target task already has an
existing instance of the activity at the top of its stack, that instance
will receive the new intent (in an
call);
a new instance is not created.
In other circumstances — for example, if an existing instance of the
"onNewIntent()
singleTop
" activity is in the target task, but not at the top of
the stack, or if it's at the top of a stack, but not in the target task
— a new instance would be created and pushed on the stack.
The "singleTask
" and "singleInstance
" modes also differ from
each other in only one respect: A "singleTask
" activity allows other
activities to be part of its task. It's always at the root of its task, but
other activities (necessarily "standard
" and "singleTop
"
activities) can be launched into that task. A "singleInstance
"
activity, on the other hand, permits no other activities to be part of its task.
It's the only activity in the task. If it starts another activity, that
activity is assigned to a different task — as if FLAG_ACTIVITY_NEW_TASK
was in the intent.
Use Cases | Launch Mode | Multiple Instances? | Comments |
---|---|---|---|
Normal launches for most activities | "standard " |
Yes | Default. The system always creates a new instance of the activity in the target task and routes the intent to it. |
"singleTop " |
Conditionally | If an instance of the activity already exists at the top of the target task,
the system routes the intent to that instance through a call to its onNewIntent() method, rather than creating a
new instance of the activity. |
|
Specialized launches (not recommended for general use) |
"singleTask " |
No | The system creates the activity at the root of a new task and routes the
intent to it. However, if an instance of the activity already exists, the system
routes the intent to existing instance through a call to its onNewIntent() method, rather than creating a
new one. |
"singleInstance " |
No | Same as "singleTask" , except that the system doesn't launch any
other activities into the task holding the instance. The activity is always the
single and only member of its task. |
As shown in the table above, standard
is the default mode and is
appropriate for most types of activities. SingleTop
is also a
common and useful launch mode for many types of activities. The other modes
— singleTask
and singleInstance
— are
not appropriate for most applications,
since they result in an interaction model that is likely to be unfamiliar to
users and is very different from most other applications.
Regardless of the launch mode that you choose, make sure to test the usability of the activity during launch and when navigating back to it from other activities and tasks using the BACK key.
For more information on launch modes and their interaction with Intent flags, see the Activities and Tasks section of the Application Fundamentals document.
android:multiprocess
true
" if it can be, and "false
" if not.
The default value is "false
".
Normally, a new instance of an activity is launched into the process of the
application that defined it, so all instances of the activity run in the same
process. However, if this flag is set to "true
", instances of the
activity can run in multiple processes, allowing the system to create instances
wherever they are used (provided permissions allow it), something that is almost
never necessary or desirable.
android:name
Activity
. The attribute value should be a fully qualified
class name (such as, "com.example.project.ExtracurricularActivity
").
However, as a shorthand, if the first character of the name is a period
(for example, ".ExtracurricularActivity
"), it is appended to the
package name specified in the
<manifest>
element.
There is no default. The name must be specified.
android:noHistory
finish()
method called) when the user navigates away from it and it's no longer
visible on screen — "true
" if it should be finished, and
"false
" if not. The default value is "false
".
A value of "true
" means that the activity will not leave a
historical trace. It will not remain in the activity stack for the task,
so the user will not be able to return to it.
This attribute was introduced in API Level 3.
android:permission
startActivity()
or
startActivityForResult()
has not been granted the specified permission, its intent will not be
delivered to the activity.
If this attribute is not set, the permission set by the
<application>
element's
permission
attribute applies to the activity. If neither attribute is set, the activity is
not protected by a permission.
For more information on permissions, see the Permissions section in the introduction and another document, Security and Permissions.
android:process
<application>
element's
process
attribute can set a different default for all components. But each component
can override the default, allowing you to spread your application across
multiple processes.
If the name assigned to this attribute begins with a colon (':'), a new process, private to the application, is created when it's needed and the activity runs in that process. If the process name begins with a lowercase character, the activity will run in a global process of that name, provided that it has permission to do so. This allows components in different applications to share a process, reducing resource usage.
android:screenOrientation
"unspecified " |
The default value. The system chooses the orientation. The policy it uses, and therefore the choices made in specific contexts, may differ from device to device. |
"landscape " |
Landscape orientation (the display is wider than it is tall). |
"portrait " |
Portrait orientation (the display is taller than it is wide). |
"user " |
The user's current preferred orientation. |
"behind " |
The same orientation as the activity that's immediately beneath it in the activity stack. |
"sensor " |
The orientation determined by a physical orientation sensor. The orientation of the display depends on how the user is holding the device; it changes when the user rotates the device. |
"nosensor " |
An orientation determined without reference to a physical orientation sensor.
The sensor is ignored, so the display will not rotate based on how the user
moves the device. Except for this distinction, the system chooses the
orientation using the same policy as for the "unspecified " setting. |
android:stateNotNeeded
true
" if it can be restarted
without reference to its previous state, and "false
" if its previous
state is required. The default value is "false
".
Normally, before an activity is temporarily shut down to save resources, its
method is called. This method stores the current state of the activity in a
onSaveInstanceState()
Bundle
object, which is then passed to
when the activity
is restarted. If this attribute is set to "onCreate()
true
",
onSaveInstanceState()
may not be called and onCreate()
will
be passed null
instead of the Bundle — just as it was when the
activity started for the first time.
A "true
" setting ensures that the activity can be restarted in the
absence of retained state. For example, the activity that displays the
home screen uses this setting to make sure that it does not get removed if it
crashes for some reason.
android:taskAffinity
The affinity determines two things — the task that the activity is re-parented
to (see the allowTaskReparenting
attribute) and the task that will house the activity when it is launched
with the
flag.
FLAG_ACTIVITY_NEW_TASK
By default, all activities in an application have the same affinity. You can set this attribute to group them differently, and even place activities defined in different applications within the same task. To specify that the activity does not have an affinity for any task, set it to an empty string.
If this attribute is not set, the activity inherits the affinity set
for the application (see the
<application>
element's
taskAffinity
attribute). The name of the default affinity for an application is
the package name set by the
<manifest>
element.
android:theme
setTheme()
, and may also
cause "starting" animations prior to the activity being launched (to better
match what the activity actually looks like).
If this attribute is not set, the activity inherits the theme set for the
application as a whole — see the
<application>
element's
theme
attribute. If that attribute is also not set, the default system theme is used.
android:windowSoftInputMode
The setting must be one of the values listed in the following table, or a
combination of one "state...
" value plus one "adjust...
"
value. Setting multiple values in either group — multiple
"state...
" values, for example &mdash has undefined results.
Individual values are separated by a vertical bar (|
). For example:
<activity android:windowSoftInputMode="stateVisible|adjustResize" . . . >
Values set here (other than "stateUnspecified
" and
"adjustUnspecified
") override values set in the theme.
Value | Description |
---|---|
"stateUnspecified " |
The state of the soft keyboard (whether it is hidden or visible)
is not specified. The system will choose an appropriate state or
rely on the setting in the theme.
This is the default setting for the behavior of the soft keyboard. |
"stateUnchanged " |
The soft keyboard is kept in whatever state it was last in, whether visible or hidden, when the activity comes to the fore. | "stateHidden " |
The soft keyboard is hidden when the user chooses the activity — that is, when the user affirmatively navigates forward to the activity, rather than backs into it because of leaving another activity. | "stateAlwaysHidden " |
The soft keyboard is always hidden when the activity's main window has input focus. | "stateVisible " |
The soft keyboard is visible when that's normally appropriate (when the user is navigating forward to the activity's main window). | "stateAlwaysVisible " |
The soft keyboard is made visible when the user chooses the activity — that is, when the user affirmatively navigates forward to the activity, rather than backs into it because of leaving another activity. | "adjustUnspecified " |
It is unspecified whether the activity's main window resizes
to make room for the soft keyboard, or whether the contents
of the window pan to make the currentfocus visible on-screen.
The system will automatically select one of these modes depending
on whether the content of the window has any layout views that
can scroll their contents. If there is such a view, the window
will be resized, on the assumption that scrolling can make all
of the window's contents visible within a smaller area.
This is the default setting for the behavior of the main window. |
"adjustResize " |
The activity's main window is always resized to make room for the soft keyboard on screen. | "adjustPan " |
The activity's main window is not resized to make room for the soft keyboard. Rather, the contents of the window are automatically panned so that the current focus is never obscured by the keyboard and users can always see what they are typing. This is generally less desirable than resizing, because the user may need to close the soft keyboard to get at and interact with obscured parts of the window. |
This attribute was introduced in API Level 3.
noHistory
and
windowSoftInputMode
, which were added in API
Level 3.<application>
<activity-alias>