AD

AndroidManifest.xml - activity details




<Activity android: allowTaskReparenting = ["true" | "false"]
android: alwaysRetainTaskState = ["true" | "false"]
android: clearTaskOnLaunch = ["true" "|" false "]
android: configChanges = [one or more of: "mcc" "mnc" "locale"
"Touchscreen" "keyboard" "keyboardHidden"
"Navigation" "orientation" "fontScale"]
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" | "nonsensor"]
android: stateNotNeeded = ["true" | "false"]
android: taskAffinity = "string"
android: theme = "resource or theme"
android: windowSoftInputMode = [one or more of: "stateUnspecified"
"StateUnchanged" "stateHidden"
"StateAlwaysHidden" "stateVisible"
"StateAlwaysVisible" "adjustUnspecified"
"AdjustResize" "adjustPan"]>
...
</ Activity>

contained in: under:
<application>

can contain: may contain:
<intent-filter>
<meta-data>

description: Description:
Declares an activity (an 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.
Declare a activity (a subclass of Activity), which implements the application part of the visual interface. All activity must use the manifest file <activity> element declaration. System will not see any statement is not activity, will not be able to run the.

attributes: attribute:

android: allowTaskReparenting
Whether or not the activity can move from the task that started it to the task it has an affinity for when that task is next brought to the front - "true" if it can move, and "false" if it must remain with the task where it started.
activity if the task from the start it was taken after moving to the front it is saying there is affinity of the task in - "true" that it can be moved, "false" that it must stay where you start its task.

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".
If the property is not set, <application> element corresponding allowTaskReparenting property values will apply 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.
Usually when an activity started, it started its activity in the task associated with, and remain there throughout the life cycle. You can use this attribute in the current task is no longer being displayed, it will force the re-positioning it to where it is saying there is affinity of the task. Usually, it is used to promote an application of activity moved to the application associated with the main task go.

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.
For example, if an e-mail message contains a link to a page, click on the link will display the page generates an activity. The activity defined by the browser application, but was an e-mail task as part of load coming. If it be relocated to the browser task, in that browser, it will be after the show to prospects, and when the e-mail task back to front no longer be displayed.

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.)
activity of the affinity defined by the taskAffinity property. The affinity of a task depends on its root activity of the affinity. So, naturally, is always a root activity in a task with the same affinity. Because "singleTask" or "singleInstance" loading mode activity in a task can only be the root, re-set the parent only apply to "standard" and "singleTop" mode. (Refer to launchMode property.)
android: alwaysRetainTaskState always maintain the task status
Whether or not the state of the task that the activity is in will always be maintained by the system - "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.
Whether the system will always maintain the activity where the task of the state - "true" that will be it, "false" that allows the system in some cases, re-set the task to its initial state. The default value is "false". The property value is only meaningful to the task of root activity; for the other activity will be ignored.

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.
Typically, the system in the main screen when the user re-election to the task of the particular case of a clear task (remove all stack Reagan activity above activity). Typically, this occurs when the user exceeds a specific time interval still does not have access to the task, 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.
However, when the property is "true", the user will always return the latest status of the task, no matter how they last. This is useful, for example, in a similar web browser application programs, and here there are many users do not want to lose the state (such as plural tabs open).
android: clearTaskOnLaunch loaded empty task
Whether or not all activities will be removed from the task, except for the root activity, whenever it is re-launched from the home screen - "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.
From the Home screen at any time when re-loading, whether the task to remove the root activity in addition to all the activity - "true" indicates that the task is always to split the root activity, "false" that it is not. The default is "false". This property is only the beginning of a new task of the activity (root activity) makes sense; the task in the other activity will be ignored.

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.
A value of "true", whenever the user restarted the task, they will be taken to its root activity, regardless of their final performance of the task in what action, and regardless of whether they use when finally leaving BACK or HOME key. When the value is "false" when the task in some cases it may be empty activity (reference alwaysRetainTaskState property), but not always so.

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 a person from the home screen loading activity P, and from there reach the activity Q. Users then press the HOME button, and then return to the activity P. Typically, the user will see the activity Q, as he was in P's task in operating areas. However, if the P flag set to the "true", when users press the HOME key, the task into the background to the time of its all of the activity (Q also belongs to this case) will be removed. So, back to the task later when I saw only P.

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.
If the property and allowTaskReparenting are "true", any parent can be re-set the activity will move to have the same affinity that it is saying the task go; then as mentioned above, the remaining activity will be discarded.
android: configChanges configuration changes
Lists configuration changes that the activity will handle itself. When changes that are not listed occur, the activity is shut down and restarted. When a listed change occurs, the activity remains running and its onConfigurationChanged () method is called.
List of activity he will deal with the configuration changes. When changes occur has not been listed, the activity will be shut down and restart. When changes occur cited, the activity will continue to run and call it onConfigurationChanged () method.

Any or all of the following strings can be used to set this attribute. Values are separated by '|' - for example, "locale | navigation | orientation".
The following list of any or all of the strings can be used to set the property. Value with the '|' separated - for example, "locale | navigation | orientation".

Value Description Value Description
"Mcc" The IMSI mobile country code (MCC) has changed - that is, a SIM has been detected and updated the MCC.
International Mobile Subscriber Identity code of the mobile country code (MCC) to change - that is, to detect a SIM and update MCC.
"Mnc" The IMSI mobile network code (MNC) has changed - that is, a SIM has been detected and updated the MNC.
International Mobile Subscriber Identity code of the mobile network code (MNC) to change - that is, to detect a SIM and update MNC.
"Locale" The locale has changed - for example, the user has selected a new language that text should be displayed in.
locale change - for example, the user selects a new language used to display text.
"Touchscreen" The touchscreen has changed. (This should never normally happen.)
Touch screen to change. (This usually does not occur.)
"Keyboard" The keyboard type has changed - for example, the user has plugged in an external keyboard.
Change the keyboard model - for example, a user plugged an extended keyboard.
"KeyboardHidden" The keyboard accessibility has changed - for example, the user has slid the keyboard out to expose it.
Keyboard accessibility changes - for example, the user can not unplug the keyboard to use it.
"Navigation" The navigation type has changed. (This should never normally happen.)
Navigation species change. (This usually does not occur.)
"Orientation" The screen orientation has changed - that is, the user has rotated the device.
Change the screen orientation - that is, users rotation of the device.
"FontScale" The font scaling factor has changed - that is, the user has selected a new global font size.
Change font scaling factor - that is, the user selects a new font size overall.

* International Mobile Subscriber Identifier (IMSI) International Mobile Subscriber Identity

International recognition for the unique distribution of a number of mobile users.

Technically, IMSI can completely solve the international roaming. However, due to North America there are still a lot of AMPS system uses the MIN number, and North America use the same MDN and MIN numbers, the system has not changed, so the current international roaming is still being dominated by MIN. Of which begins with the letter O and 1 MIN resource called IRM (International Roaming MIN), by the IFAST (International Forum on ANSI-41 Standards Technology) unified management. IRM resources currently applied to China Unicom starts with 09. Can be seen, with the growth of the user, for international roaming MIN resources would soon run out, the global unified user identity using IMSI is imperative.

IMSI total of 15, its structure is as follows:
MCC + MNC + MIN
MCC: Mobile Country Code, Mobile Country Code, a total of three, China has 460;
MNC: Mobile Network Code, Mobile Network Code, 2-bit, Unicom's CDMA system uses the 03, a typical IMSI number 460030912121001;

MIN total of 10, its structure is as follows:
09 + M0M1M2M3 + ABCD
Which M0M1M2M3 and MDN numbers can exist in H0H1H2H3 correspondence, ABCD 4 for free distribution.

IMSI can be seen in the MIN number before the MCC, you can distinguish each user from the state, it can achieve international roaming. In the same country, if there are multiple CDMA carriers, carried out by different MNC.

International Mobile Station Identity - International Mobile Station Identity

All of these configuration changes can impact the resource values seen by the application. Therefore, when onConfigurationChanged () is called, it will generally be necessary to again retrieve all resources (including view layouts, drawables, and so on) to correctly handle the change .
All of these configuration changes can affect the resources an application can see the value. Therefore, when onConfigurationChanged () is called, it will usually resume once all the resources (including the view of the layout, display elements, Deng Deng) to correctly correspond to these changes.
android: enabled permit
Whether or not the activity can be instantiated by the system - "true" if it can be, and "false" if not. The default value is "true".
activity whether the system can be instantiated - "true" that can be, "false" that can 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.
<application> enabled element has its own properties, providing all the components to the application, including the activity. <application> and <activity> the property must have the "true" (such as they are the default), the system can instantiate the activity. If any party is a "false", it can not be instantiated.
android: excludeFromRecents out of the current outside
Whether or not the activity should be excluded from the list of recently launched activities that can be displayed to users - "true" if it should be excluded, and "false" if it should be included. The default value is "false".
The activity will be excluded from the currently loaded can be displayed to the user's activity beyond the list - "true" that would be excluded, "false" that will be included. The default is "false".

android: exported outside
Whether or not the activity can be launched by components of other applications - "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.
activity is to be included in other components of the application - "true" that can be, "false" that can not. If it is "false", the activity value can be the same application or have the same user ID of components included in the application.

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".
The default value depends on whether the activity with intent filter. No filter means that the activity can only be invoked explicitly specify the class name. This means that the activity is intended to be an application - for internal use (because the other will not know the class name). So in this case, the default value is "false". On the other hand, if at least one filter means that the activity can be used outside, 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).
The only limitation of this attribute is not exposed to the activity the only way to other applications. You can also use permissions to restrict access control on the activity of external calls (see permission attributes).
android: finishOnTaskLaunch ends when the task load
Whether or not an existing instance of the activity should be shut down (finished) whenever the user again launches its task (chooses the task on the home screen) - "true" if it should be shut down, and "false" if not. The default value is "false".
When the user when re-loading the task (in the Home screen, select the task), a pre-existing activity instance should be closed (the end) - "true" that will be shut down, "false" that it is not. The default 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.
If the properties and allowTaskReparenting are set to "true", the attribute priority over other. The activity of the affinity be ignored. The activity will not be re-set the parent, but destroyed.
android: icon icon
An icon representing the activity. The icon is displayed to users when a representation of the activity is required on-screen. For example, icons for activities that initiate tasks are displayed in the launcher window. The icon is often accompanied by a label (see the label attribute).
An icon representing the activity. When the activity of the signs need to appear on the screen, the icon will be displayed to the user. For example, the display window at the start of the activity used to initialize the task icon. The icon is usually concurrent with a label (see 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 property must be set to an image definition that contains a reference resource can be drawn. If not set, assigned to the application's icon will be brought to replace it to use (see <application> icon element attributes).

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).
activity of the icon - whether here or set elements from <application> - and equally intent filter in the activity of all the default icon (the icon reference <intent-filter> element attributes).
android: label tag
A user-readable label for the activity. The label is displayed on-screen when the activity must be represented to the user. It's often displayed along with the activity icon.
The activity of the user read the label. When the activity must be displayed to the user, the label will be displayed on the screen. It usually appears in conjunction with the activity's icon.

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).
If this attribute is not set, set to the application of the label will be used to replace it (see <application> element 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 activity of the label - whether here or set <application> elements come from - also the activity of all intent filter in the default label (see <intent-filter> element 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.
Tag must be set to a string of reference resources, like user interface so that it can be the same as the other strings been localized. However, when you develop your application, it can be easily set to a raw string.
android: launchMode loading mode
An instruction on how the activity should be launched. There are four modes that work in conjunction with activity flags (FLAG_ACTIVITY_ * constants) in Intent objects to determine what should happen when the activity is called upon to handle an intent. They are:
activity to be included in the instructions. Here are four models, with the Intent identifies the object in the activity of mutual cooperation (FLAG_ACTIVITY_ * constants) to determine when the activity is called to deal with what should happen when an intent. They are:

"Standard"
"SingleTop"
"SingleTask"
"SingleInstance"

The default mode is "standard".
The default mode is "standard".

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 startActivity () (unless the Intent object contains a FLAG_ACTIVITY_NEW_TASK instruction, in which case a different task is chosen - see the taskAffinity attribute).
Model is divided into two groups, "standard" and "singleTop" activity as a group, "singleTask" and "singleInstance" activity for the other group. With a "standard" or "singleTop" loading mode activity can be instantiated several times. Instance can belong to any task, can be placed anywhere in the activity stack. Usually, by calling startActivity () to load them in task (unless Intent object contains FLAG_ACTIVITY_NEW_TASK instructions, this case will choose a different task - the light taskAffinity property).

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.
On the contrary, "singleTask" and "singleInstance" activity can only start a task. They are always at the root of activity stack. And equipment at the same time only one of the strength of activity there - only one such task.

The "standard" and "singleTop" modes differ from each other in just one respect: Every time there's 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 onNewIntent () call); a new instance is not created. In other circumstances - for example, if an existing instance of the "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.
"Standard" and "singleTop" only a little different modes: When the intent here to have a new request for a "standard" activity, it will generate a new instance of the class to respond to that intent. Each instance of the holders of a single intent. Similarly, will generate a "singleTop" activity to hold a new instance of a new intent. However, if the target task already has a existing instance of the activity at the top of its stack, the strength of will receive this new intent (by calling onNewIntent ()); and will not generate a new instance. In other cases - for example, if a target task in an existing "singleTop" activity instance, but not at the top of the stack, or it although at the top of the stack, but not target task in - will generate a new instance into the stack and press go.

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 at the root of the activity stack, but other activities (necessarily "standard "and" singleTop "activities) can be launched into the same 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.
"SingleTask" and "singleInstance" mode is only one aspect of the different: a "singleTask" activity allows the activity of other years as part of its task. It is located in the root activity stack, but other activity (must be a "standard" or "singleTop" activity) can be loaded into the same task in. A "singleInstance" activity, on the other hand, does not allow other activity where in its task. It is the only remaining task in the activity. If it starts another activity, that activity will be assigned to other task go - where, as intent as set FLAG_ACTIVITY_NEW_TASK.

For more information on launch modes and their interaction with Intent flags, see the Activities and Tasks section of the Application Fundamentals document.
Loading patterns and their identification with the intent of collaboration between more information, refer to Application Fundamentals document Activities and Tasks sections.
android: multiprocess multiple processes
Whether an instance of the activity can be launched into the process of the component that started it - "true" if it can be, and "false" if not. The default value is "false".
activity of the instance is started it can be loaded into the process where the components inside - "true" that can be, "false" that impossible. 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.
Typically, a new instance of the activity is loaded into the definition of its application process, the way, all instances of the activity to run in the same process in. However, if the ID set to "true", then, activity instances can run in multiple processes, the permit system to use it as long as the instance when generated (provided permissions allow it), some almost do not need or do not appropriate.
android: name name
The name of the class that implements the activity, a subclass of 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.
Realized the name of the class activity, Activity of a sub-class. The property value should be a complete class name (for example, "com.example.project.ExtracurricularActivity"). However, as an acronym for the first character if the name is a period (for example, ". ExtracurricularActivity"), it will be an additional element in the <manifest> to specify the package name.

There is no default. The name must be specified.
No default, the name must be specified.
android: noHistory not resume
Whether or not the activity should be removed from the activity stack and finished (its 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".
When the user leaves it and it no longer appears on the screen, activity should be removed from the activity stack and end in fall (call it the finish () method) - "true" that should end, "false" that do 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.
Value "true" means that the activity will not leave resume. It will not stay in the task of the activity stack, the user will not be able to return to it.

This attribute was introduced in API Level 3.
The property in the API Level 3 in import.
android: permission permission
The name of a permission that clients must have to launch the activity or otherwise get it to respond to an intent. If a caller of startActivity () or startActivityForResult () has not been granted the specified permission, its intent will not be delivered to the activity.
Client load activity, or else to respond to an intent by the name must have permission. If a startActivity () or startActivityForResult () calls are not given permission to specify its intent will not be sent 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.
If this attribute is not set, <application> element of permission attributes set permission will apply to the activity. If both sides of the property have not been set, the activity will not be permitted to protect.

For more information on permissions, see the Permissions section in the introduction and another document, Security and Permissions.
More information about licensing, refer to Introduction to the Permissions section, and other documents, Security and Permissions.
android: process process
The name of the process in which the activity should run. Normally, all components of an application run in the default process created for the application. It has the same name as the application package. The <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.
activity should run the process name. Typically, all the components of an application running in the application process in the default generated. It is with the application package with the same name. <application> element of the process attributes to all of the components can set a different default value. But each component can override the default values, allowing you to extend your application to multiple processes in.

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.
If this attribute specifies the name to start (':'), colon when needed will be generated when the application of a new proprietary process, activity will run in that process in. If the process name by a lower case letter, activity will run in the name of a global process where, if it has the license to say. This allows different application components share the same process, thereby reducing the consumption of resources.
android: screenOrientation
The orientation of the activity's display on the device. The value can be any one of the following strings:
activity appears on the device's location. Can be set to any of the following strings:
"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.
Default. Select location by the system. It uses the program, as well as the different context in which choices, devices can be different.
"Landscape" Landscape orientation (the display is wider than it is tall).
Horizontal orientation (horizontal than vertical display).
"Portrait" Portrait orientation (the display is taller than it is wide).
Vertical orientation (vertical than horizontal display).
"User" The user's current preferred orientation.
Users preferred the current location.
"Behind" The same orientation as the activity that's immediately beneath it in the activity stack.
And the activity stack it tight in the same position the following activity.
"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.
By a physical position sensors determine position. Direction depends on how users hold the device; if the user rotate the device would change direction.
"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.
Not by a physical position sensors determine position. Sensor is ignored, so show no change following the user equipment. Apart from this difference, the system uses the "unspecified" to set the same options selected position.

android: stateNotNeeded
Whether or not the activity can be killed and successfully restarted without having saved its state - "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" .
whether the activity does not save its state to be killed after the successful re-launch - "true" that can not follow the state's case before the restart, "false", said the state before it is needed. The default is "false".

Normally, before an activity is temporarily shut down to save resources, its onSaveInstanceState () method is called. This method stores the current state of the activity in a Bundle object, which is then passed to onCreate () when the activity is restarted. If this attribute is set to "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.
Typically, when a temporary closure of activity in order to save resources, call it onSaveInstanceState () method. The method of storing the current state of the activity to a Bundle object where the activity after the restart when the pass onCreate () method. If this property is set to "true", onSaveInstanceState () will not be called, and pass a null onCreate (), rather than Bundle - as the activity was started as the first.

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.
Set to "true" to ensure the activity can be restarted without the state case. For example, the display screen of the activity on the home page using this setting to ensure that after the collapse if for some reason it will not be removed.
android: windowSoftInputMode
How the main window of the activity interacts with the window containing the on-screen soft keyboard. The setting for this attribute affects two things:
how the activity live window contains the window-screen soft keyboard interaction. This property setting affects two things:

* The state of the soft keyboard - whether it is hidden or visible - when the activity becomes the focus of user attention.
Soft keyboard state - Hide or show - when the activity became the focus of attention when the user.
* The adjustment made to the activity's main window - whether it is resized smaller to make room for the soft keyboard or whether its contents pan to make the current focus visible when part of the window is covered by the soft keyboard.
Regulation of the main window for the activity - whether the window smaller by leaving out the space for the soft keyboard, or Dangyibufen Chuangkou Pi when the soft keyboard Fugai, whether Ta's catalog Yidongconger so that the current of Jiaodian Visual .

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 - has undefined results. Individual values are separated by a vertical bar (|). For example:
The following table set to be one of the values listed, or a certain "state ..." value plus a "adjust ..." a combination of values. Set multiple values in any of the groups in the - more than "state ..." value, for example - the results are undefined. Between each value separated with a vertical bar (|). For example:

<activity android:windowSoftInputMode="stateVisible|adjustResize"...>

Values set here (other than "stateUnspecified" and "adjustUnspecified") override values set in the theme.
Setting the value here (except "stateUnspecified" and "adjustUnspecified" outside) will cover the subject in the value set.
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.
Soft keyboard status (whether visible or hidden) is not specified. The system will select an appropriate state or dependent on the theme in the settings.
This is the default 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.
When the activity came to front desk, the soft keyboard will keep it before the end of the state, either visible or hidden.
"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.
When the user selects the activity, the soft keyboard is hidden - that is, when users take the initiative to navigate to the activity, rather than from another activity to return to it.
"StateAlwaysHidden" The soft keyboard is always hidden when the activity's main window has input focus.
When the activity of the main window gets the focus, the soft keyboard is always hidden.
"StateVisible" The soft keyboard is visible when that's normally appropriate (when the user is navigating forward to the activity's main window).
Soft keyboard video, which is normally applicable (when the user browses to the activity of the 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.
When the user selects the activity, the soft keyboard, video - that is, when users actively navigate to the activity, rather than from the other activity to return to it.
"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.
Whether the change in activity is not specified, the main window size to make room for the soft keyboard, or whether the contents of the sliding window so that the current focus on the screen visible. The system will automatically select one of the model depends on whether the window can scroll the contents of their content in any layout. If there is such a way here, the window size to be changed, assuming that the window can scroll all the content in a smaller area where visible.
This is the default behavior of the main window.
"AdjustResize" The activity's main window is always resized to make room for the soft keyboard on screen.
activity of the main window is always resized to the soft keyboard on the screen to make room.
"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 desireable than resizing, because the user may need to close the soft keyboard to get at and interact with obscured parts of the window.
activity of the main window will not change the size to make room for the soft keyboard. Instead, the content will be dynamically scroll the window, this way, the current keyboard focus will not be covered, the user can always see what they are entered. This is usually better to change the size, because the user may need to close the soft keyboard window to be covered with some interactions.
标签: lt, orientation, quot quot, keyboard, meta data, description description, android, landscape, mcc, mnc, touchscreen, string resource, xml activity, activity details
分类: Mobile
时间: 2010-07-18

相关文章

  1. AndroidManifest.xml package to add more

    We all know that if the number of Activity in the same package, can be so up in the Mainfest <?xml version= ...
  2. activity AndroidManifest.xml file in the android: windowSoftInputMode properties using

    <activity> AndroidManifest.xml file in the android: windowSoftInputMode properties using android input 2 ...
  3. Comprehensive Xiangjie AndroidManifest.xml file

    First, the importance of AndroidManifest.xml Android application is the most important documents. It is the gl ...
  4. Comprehensive Detailed AndroidManifest.xml file

    First, the importance of the AndroidManifest.xml Android application is the most important one of the document ...
  5. AndroidManifest.xml小结

    AndroidManifest.xml的作用 1. 命名应用的java包名,该包名将作为应用程序的唯一标识. 2. 声明定义各种组件(例如activity,services,broadcast services和cont ...
  6. AndroidManifest.xml Summary

    AndroidManifest.xml need statement reads as follows: 1. The application of Java package name 2. The applicatio ...
  7. AndroidManifest.xml resolution (translation)

    AndroidManifest.xml is that each program must file android. It is located in the root directory of application ...
  8. AndroidManifest.xml resolution (more detailed)

    Android Study Notes 3: AndroidManifest.xml - application translation <application> syntax: Syntax: <A ...
  9. Launcher study AndroidManifest.xml [transfer]

    Launcher's AndroidManifest.xml documents of many special, analyze the whole program will probably understand t ...
  10. Android study notes the AndroidManifest.xml file parsing

    AndroidManifest.xml is that each program must file android. It is located in the root directory of application ...
  11. AndroidManifest.xml配置文件解析

    AndroidManifest.xml配置文件对于Android应用开发来说是非常重要的基础知识,本文将详细介绍,需要了解的朋友可以参考下 AndroidManifest.xml配置文件对于Android应用开发来说是非 ...
  12. 深入AndroidManifest.xml文件解析详解

    AndroidManifest.xml是每个android程序中必须的文件.它位于整个项目的根目录,描述了package中暴露的组件(activities,services,等等),他们各自的实现类,各种能被处理的数据和 ...
  13. AndroidManifest.xml配置文件选项详解

    AndroidManifest.xml下的一些属性定义和用法: ------------------------------------------------------------------------------ ...
  14. android 读取 AndroidManifest.xml 中的数据:版本号.应用名称.自定...

    Android开发中我们常常需要知道,当前应用的版本信息.可以进行自动升级判断.扩展自定义数据 meta-data, 这些数据都在AndroidManifest.xml .我们如何获取这些信息呢? 下来示例如何读取这些数 ...
  15. 在AndroidManifest.xml文件中的android:windowSoftInput...

    <!-- 调拨出库 --> <activity android:name="ouc.sei.wuzi.DiaoBoChuKu" android:launchMode="si ...
  16. Android中如何获取系统应用程序列表与AndroidManifest.xml信息

    摘要 Android系统为我们提供了很多服务管理的类,包括ActivityManager.PowerManager(电源管理).AudioManager(音频管理) 等.除此之外,还提供了一个PackageManger管 ...
  17. Android:AndroidManifest.xml

    一.关于AndroidManifest.xml AndroidManifest.xml 是每个android程序中必须的文件.它位于整个项目的根目录,描述了package中暴露的组件(activities, servic ...
  18. AndroidManifest.xml文件综合详解

    一,重要性AndroidManifest.xml是Android应用程序中最重要的文件之一.它是Android程序的全局配置文件,是每个 android程序中必须的文件.它位于我们开发的应用程序的根目录下,描述了pack ...
  19. androidManifest.xml问题

    对于调试运行报异常退出问题(新手常遇到这样的问题) 调试运行异常,很新手都是从网上拿来的代码,点运行调试. 常遇到一个问题,就是不能正常运行. 其中之一,就是 R 文件丢失没有自动生成, 这个问题以网上很多解决办法,在这 ...