| <?xml version="1.0" encoding="utf-8"?> |
| <!-- |
| /* Copyright 2006, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| --> |
| <resources> |
| <!-- **************************************************************** --> |
| <!-- These are the attributes used in AndroidManifest.xml. --> |
| <!-- **************************************************************** --> |
| <eat-comment /> |
| |
| <!-- The overall theme to use for an activity. Use with either the |
| application tag (to supply a default theme for all activities) or |
| the activity tag (to supply a specific theme for that activity). |
| |
| <p>This automatically sets |
| your activity's Context to use this theme, and may also be used |
| for "starting" animations prior to the activity being launched (to |
| better match what the activity actually looks like). It is a reference |
| to a style resource defining the theme. If not set, the default |
| system theme will be used. --> |
| <attr name="theme" format="reference" /> |
| |
| <!-- A user-legible name for the given item. Use with the |
| application tag (to supply a default label for all application |
| components), or with the activity, receiver, service, or instrumentation |
| tag (to supply a specific label for that component). It may also be |
| used with the intent-filter tag to supply a label to show to the |
| user when an activity is being selected based on a particular Intent. |
| |
| <p>The given label will be used wherever the user sees information |
| about its associated component; for example, as the name of a |
| main activity that is displayed in the launcher. You should |
| generally set this to a reference to a string resource, so that |
| it can be localized, however it is also allowed to supply a plain |
| string for quick and dirty programming. --> |
| <attr name="label" format="reference|string" /> |
| |
| <!-- A Drawable resource providing a graphical representation of its |
| associated item. Use with the |
| application tag (to supply a default icon for all application |
| components), or with the activity, receiver, service, or instrumentation |
| tag (to supply a specific icon for that component). It may also be |
| used with the intent-filter tag to supply an icon to show to the |
| user when an activity is being selected based on a particular Intent. |
| |
| <p>The given icon will be used to display to the user a graphical |
| representation of its associated component; for example, as the icon |
| for main activity that is displayed in the launcher. This must be |
| a reference to a Drawable resource containing the image definition. --> |
| <attr name="icon" format="reference" /> |
| |
| <!-- A Drawable resource providing a graphical representation of its |
| associated item. Use with the |
| application tag (to supply a default round icon for all application |
| components), or with the activity, receiver, service, or instrumentation |
| tag (to supply a specific round icon for that component). It may also be |
| used with the intent-filter tag to supply a round icon to show to the |
| user when an activity is being selected based on a particular Intent. |
| |
| <p>The given round icon will be used to display to the user a graphical |
| representation of its associated component; for example, as the round icon |
| for main activity that is displayed in the launcher. This must be |
| a reference to a Drawable resource containing the image definition. --> |
| <attr name="roundIcon" format="reference" /> |
| |
| <!-- A Drawable resource providing an extended graphical banner for its |
| associated item. Use with the application tag (to supply a default |
| banner for all application activities), or with the activity, tag to |
| supply a banner for a specific activity. |
| |
| <p>The given banner will be used to display to the user a graphical |
| representation of an activity in the Leanback application launcher. |
| Since banners are displayed only in the Leanback launcher, they should |
| only be used with activities (and applications) that support Leanback |
| mode. These are activities that handle Intents of category |
| {@link android.content.Intent#CATEGORY_LEANBACK_LAUNCHER |
| Intent.CATEGORY_LEANBACK_LAUNCHER}. |
| <p>This must be a reference to a Drawable resource containing the image definition. --> |
| <attr name="banner" format="reference" /> |
| |
| <!-- A Drawable resource providing an extended graphical logo for its |
| associated item. Use with the application tag (to supply a default |
| logo for all application components), or with the activity, receiver, |
| service, or instrumentation tag (to supply a specific logo for that |
| component). It may also be used with the intent-filter tag to supply |
| a logo to show to the user when an activity is being selected based |
| on a particular Intent. |
| |
| <p>The given logo will be used to display to the user a graphical |
| representation of its associated component; for example as the |
| header in the Action Bar. The primary differences between an icon |
| and a logo are that logos are often wider and more detailed, and are |
| used without an accompanying text caption. This must be a reference |
| to a Drawable resource containing the image definition. --> |
| <attr name="logo" format="reference" /> |
| |
| <!-- Name of the activity to be launched to manage application's space on |
| device. The specified activity gets automatically launched when the |
| application's space needs to be managed and is usually invoked |
| through user actions. Applications can thus provide their own custom |
| behavior for managing space for various scenarios like out of memory |
| conditions. This is an optional attribute and |
| applications can choose not to specify a default activity to |
| manage space. --> |
| <attr name="manageSpaceActivity" format="string" /> |
| |
| <!-- Option to let applications specify that user data can/cannot be |
| cleared by the user in Settings. This flag is turned on by default. |
| <em>This attribute is usable only by applications |
| included in the system image. Third-party apps cannot use it.</em> --> |
| <attr name="allowClearUserData" format="boolean" /> |
| |
| <!-- Option to indicate this application is only for testing purposes. |
| For example, it may expose functionality or data outside of itself |
| that would cause a security hole, but is useful for testing. This |
| kind of application can not be installed without the |
| INSTALL_ALLOW_TEST flag, which means only through adb install. --> |
| <attr name="testOnly" format="boolean" /> |
| |
| <!-- A unique name for the given item. This must use a Java-style naming |
| convention to ensure the name is unique, for example |
| "com.mycompany.MyName". --> |
| <attr name="name" format="string" /> |
| |
| <!-- Specify a permission that a client is required to have in order to |
| use the associated object. If the client does not hold the named |
| permission, its request will fail. See the |
| <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> |
| document for more information on permissions. --> |
| <attr name="permission" format="string" /> |
| |
| <!-- A specific {@link android.R.attr#permission} name for read-only |
| access to a {@link android.content.ContentProvider}. See the |
| <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> |
| document for more information on permissions. --> |
| <attr name="readPermission" format="string" /> |
| |
| <!-- A specific {@link android.R.attr#permission} name for write |
| access to a {@link android.content.ContentProvider}. See the |
| <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> |
| document for more information on permissions. --> |
| <attr name="writePermission" format="string" /> |
| |
| <!-- If true, the {@link android.content.Context#grantUriPermission |
| Context.grantUriPermission} or corresponding Intent flags can |
| be used to allow others to access specific URIs in the content |
| provider, even if they do not have an explicit read or write |
| permission. If you are supporting this feature, you must be |
| sure to call {@link android.content.Context#revokeUriPermission |
| Context.revokeUriPermission} when URIs are deleted from your |
| provider.--> |
| <attr name="grantUriPermissions" format="boolean" /> |
| |
| <!-- If true, the system will always create URI permission grants |
| in the cases where {@link android.content.Intent#FLAG_GRANT_READ_URI_PERMISSION} |
| or {@link android.content.Intent#FLAG_GRANT_WRITE_URI_PERMISSION} would apply. |
| This is useful for a content provider that dynamically enforces permissions |
| on calls in to the provider, instead of through the manifest: the system |
| needs to know that it should always apply permission grants, even if it |
| looks like the target of the grant would already have access to the URI. --> |
| <attr name="forceUriPermissions" format="boolean" /> |
| |
| <!-- Characterizes the potential risk implied in a permission and |
| indicates the procedure the system should follow when determining |
| whether to grant the permission to an application requesting it. {@link |
| android.Manifest.permission Standard permissions} have a predefined and |
| permanent protectionLevel. If you are creating a custom permission in an |
| application, you can define a protectionLevel attribute with one of the |
| values listed below. If no protectionLevel is defined for a custom |
| permission, the system assigns the default ("normal"). |
| <p>Each protection level consists of a base permission type and zero or |
| more flags. Use the following functions to extract those. |
| <pre> |
| int basePermissionType = permissionInfo.getProtection(); |
| int permissionFlags = permissionInfo.getProtectionFlags(); |
| </pre> |
| --> |
| <attr name="protectionLevel"> |
| <!-- <strong>Base permission type</strong>: a lower-risk permission that gives |
| an application access to isolated application-level features, with minimal |
| risk to other applications, the system, or the user. The system |
| automatically grants this type of permission to a requesting application at |
| installation, without asking for the user's explicit approval (though the |
| user always has the option to review these permissions before installing). --> |
| <flag name="normal" value="0" /> |
| <!-- <strong>Base permission type</strong>: a higher-risk permission that |
| would give a requesting application access to private user data or |
| control over the device that can negatively impact the user. Because |
| this type of permission introduces potential risk, the system may |
| not automatically grant it to the requesting application. For example, |
| any dangerous permissions requested by an application may be displayed |
| to the user and require confirmation before proceeding, or some other |
| approach may be taken to avoid the user automatically allowing |
| the use of such facilities. --> |
| <flag name="dangerous" value="1" /> |
| <!-- <strong>Base permission type</strong>: a permission that the system is |
| to grant only if the requesting application is signed with the same |
| certificate as the application that declared the permission. If the |
| certificates match, the system automatically grants the permission |
| without notifying the user or asking for the user's explicit approval. --> |
| <flag name="signature" value="2" /> |
| <!-- Old synonym for "signature|privileged". Deprecated in API level 23. |
| Base permission type: a permission that the system is to grant only |
| to packages in the Android system image <em>or</em> that are signed |
| with the same certificates. Please avoid using this option, as the |
| signature protection level should be sufficient for most needs and |
| works regardless of exactly where applications are installed. This |
| permission is used for certain special situations where multiple |
| vendors have applications built in to a system image which need |
| to share specific features explicitly because they are being built |
| together. --> |
| <flag name="signatureOrSystem" value="3" /> |
| <!-- Additional flag from base permission type: this permission can also |
| be granted to any applications installed as privileged apps on the system image. |
| Please avoid using this option, as the |
| signature protection level should be sufficient for most needs and |
| works regardless of exactly where applications are installed. This |
| permission flag is used for certain special situations where multiple |
| vendors have applications built in to a system image which need |
| to share specific features explicitly because they are being built |
| together. --> |
| <flag name="privileged" value="0x10" /> |
| <!-- Old synonym for "privileged". Deprecated in API level 23. --> |
| <flag name="system" value="0x10" /> |
| <!-- Additional flag from base permission type: this permission can also |
| (optionally) be granted to development applications. --> |
| <flag name="development" value="0x20" /> |
| <!-- Additional flag from base permission type: this permission is closely |
| associated with an app op for controlling access. --> |
| <flag name="appop" value="0x40" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to apps that target API levels below |
| {@link android.os.Build.VERSION_CODES#M} (before runtime permissions |
| were introduced). --> |
| <flag name="pre23" value="0x80" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to system apps that install packages. --> |
| <flag name="installer" value="0x100" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to system apps that verify packages. --> |
| <flag name="verifier" value="0x200" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted any application pre-installed on the system image (not just privileged |
| apps). --> |
| <flag name="preinstalled" value="0x400" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to the setup wizard app --> |
| <flag name="setup" value="0x800" /> |
| <!-- Additional flag from base permission type: this permission can be granted to instant |
| apps --> |
| <flag name="instant" value="0x1000" /> |
| <!-- Additional flag from base permission type: this permission can only be granted to apps |
| that target runtime permissions ({@link android.os.Build.VERSION_CODES#M} and above) |
| --> |
| <flag name="runtime" value="0x2000" /> |
| <!-- Additional flag from base permission type: this permission can be granted only |
| if its protection level is signature, the requesting app resides on the OEM partition, |
| and the OEM has white-listed the app to receive this permission by the OEM. |
| --> |
| <flag name="oem" value="0x4000" /> |
| <!-- Additional flag from base permission type: this permission can be granted to |
| privileged apps in vendor partition. --> |
| <flag name="vendorPrivileged" value="0x8000" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to the system default text classifier --> |
| <flag name="textClassifier" value="0x10000" /> |
| <!-- Additional flag from base permission type: this permission will be granted to the |
| wellbeing app, as defined by the OEM. --> |
| <flag name="wellbeing" value="0x20000" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to the document manager --> |
| <flag name="documenter" value="0x40000" /> |
| <!-- Additional flag from base permission type: this permission automatically |
| granted to device configurator --> |
| <flag name="configurator" value="0x80000" /> |
| <!-- Additional flag from base permission type: this permission designates the app |
| that will approve the sharing of incident reports. --> |
| <flag name="incidentReportApprover" value="0x100000" /> |
| <!-- Additional flag from base permission type: this permission can be automatically |
| granted to the system app predictor --> |
| <flag name="appPredictor" value="0x200000" /> |
| </attr> |
| |
| <!-- Flags indicating more context for a permission group. --> |
| <attr name="permissionGroupFlags"> |
| <!-- Set to indicate that this permission group contains permissions |
| protecting access to some information that is considered |
| personal to the user (such as contacts, e-mails, etc). --> |
| <flag name="personalInfo" value="0x0001" /> |
| </attr> |
| |
| <!-- Flags indicating more context for a permission. --> |
| <attr name="permissionFlags"> |
| <!-- Set to indicate that this permission allows an operation that |
| may cost the user money. Such permissions may be highlighted |
| when shown to the user with this additional information. --> |
| <flag name="costsMoney" value="0x0001" /> |
| <!-- Additional flag from base permission type: this permission has been |
| removed and it is no longer enforced. It shouldn't be shown in the |
| UI. Removed permissions are kept as normal permissions for backwards |
| compatibility as apps may be checking them before calling an API. |
| --> |
| <flag name="removed" value="0x2" /> |
| </attr> |
| |
| <!-- Specified the name of a group that this permission is associated |
| with. The group must have been defined with the |
| {@link android.R.styleable#AndroidManifestPermissionGroup permission-group} tag. --> |
| <attr name="permissionGroup" format="string" /> |
| |
| <!-- Specify the name of a user ID that will be shared between multiple |
| packages. By default, each package gets its own unique user-id. |
| By setting this value on two or more packages, each of these packages |
| will be given a single shared user ID, so they can for example run |
| in the same process. Note that for them to actually get the same |
| user ID, they must also be signed with the same signature. --> |
| <attr name="sharedUserId" format="string" /> |
| |
| <!-- Specify a label for the shared user UID of this package. This is |
| only used if you have also used android:sharedUserId. This must |
| be a reference to a string resource; it can not be an explicit |
| string. --> |
| <attr name="sharedUserLabel" format="reference" /> |
| |
| <!-- Internal version code. This is the number used to determine whether |
| one version is more recent than another: it has no other meaning than |
| that higher numbers are more recent. You could use this number to |
| encode a "x.y" in the lower and upper 16 bits, make it a build |
| number, simply increase it by one each time a new version is |
| released, or define it however else you want, as long as each |
| successive version has a higher number. This is not a version |
| number generally shown to the user, that is usually supplied |
| with {@link android.R.attr#versionName}. When an app is delivered |
| as multiple split APKs, each APK must have the exact same versionCode. --> |
| <attr name="versionCode" format="integer" /> |
| |
| <!-- Internal major version code. This is essentially additional high bits |
| for the base version code; it has no other meaning than |
| that higher numbers are more recent. This is not a version |
| number generally shown to the user, that is usually supplied |
| with {@link android.R.attr#versionName}. --> |
| <attr name="versionCodeMajor" format="integer" /> |
| |
| <!-- Internal revision code. This number is the number used to determine |
| whether one APK is more recent than another: it has no other meaning |
| than that higher numbers are more recent. This value is only meaningful |
| when the two {@link android.R.attr#versionCode} values are already |
| identical. When an app is delivered as multiple split APKs, each |
| APK may have a different revisionCode value. --> |
| <attr name="revisionCode" format="integer" /> |
| |
| <!-- The text shown to the user to indicate the version they have. This |
| is used for no other purpose than display to the user; the actual |
| significant version number is given by {@link android.R.attr#versionCode}. --> |
| <attr name="versionName" format="string" /> |
| |
| <!-- Flag to control special persistent mode of an application. This should |
| not normally be used by applications; it requires that the system keep |
| your application running at all times. --> |
| <attr name="persistent" format="boolean" /> |
| |
| <!-- If set, the "persistent" attribute will only be honored if the feature |
| specified here is present on the device. --> |
| <attr name="persistentWhenFeatureAvailable" format="string" /> |
| |
| <!-- Flag to specify if this application needs to be present for all users. Only pre-installed |
| applications can request this feature. Default value is false. --> |
| <attr name="requiredForAllUsers" format="boolean" /> |
| |
| <!-- Flag indicating whether the application can be debugged, even when |
| running on a device that is running in user mode. --> |
| <attr name="debuggable" format="boolean" /> |
| |
| <!-- Flag indicating whether the application requests the VM to operate in |
| the safe mode. --> |
| <attr name="vmSafeMode" format="boolean" /> |
| |
| <!-- <p>Flag indicating whether the application's rendering should be hardware |
| accelerated if possible. This flag is turned on by default for applications |
| that are targeting {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH} |
| or later.</p> |
| <p>This flag can be set on the application and any activity declared |
| in the manifest. When enabled for the application, each activity is |
| automatically assumed to be hardware accelerated. This flag can be |
| overridden in the activity tags, either turning it off (if on for the |
| application) or on (if off for the application.)</p> |
| <p>When this flag is turned on for an activity (either directly or via |
| the application tag), every window created from the activity, including |
| the activity's own window, will be hardware accelerated, if possible.</p> |
| <p>Please refer to the documentation of |
| {@link android.view.WindowManager.LayoutParams#FLAG_HARDWARE_ACCELERATED} |
| for more information on how to control this flag programmatically.</p> --> |
| <attr name="hardwareAccelerated" format="boolean" /> |
| |
| <!-- Flag indicating whether the given application component is available |
| to other applications. If false, it can only be accessed by |
| applications with its same user id (which usually means only by |
| code in its own package). If true, it can be invoked by external |
| entities, though which ones can do so may be controlled through |
| permissions. The default value is false for activity, receiver, |
| and service components that do not specify any intent filters; it |
| is true for activity, receiver, and service components that do |
| have intent filters (implying they expect to be invoked by others |
| who do not know their particular component name) and for all |
| content providers. --> |
| <attr name="exported" format="boolean" /> |
| |
| <!-- A boolean flag used to indicate if an application is a Game or not. |
| <p>This information can be used by the system to group together |
| applications that are classified as games, and display them separately |
| from the other applications. --> |
| <attr name="isGame" format="boolean" /> |
| |
| <!-- If set to true, a single instance of this component will run for |
| all users. That instance will run as user 0, the default/primary |
| user. When the app running is in processes for other users and interacts |
| with this component (by binding to a service for example) those processes will |
| always interact with the instance running for user 0. Enabling |
| single user mode forces "exported" of the component to be false, to |
| help avoid introducing multi-user security bugs. This feature is only |
| available to applications built in to the system image; you must hold the |
| permission INTERACT_ACROSS_USERS in order |
| to use this feature. This flag can only be used with services, |
| receivers, and providers; it can not be used with activities. --> |
| <attr name="singleUser" format="boolean" /> |
| |
| <!-- Specify a specific process that the associated code is to run in. |
| Use with the application tag (to supply a default process for all |
| application components), or with the activity, receiver, service, |
| or provider tag (to supply a specific icon for that component). |
| |
| <p>Application components are normally run in a single process that |
| is created for the entire application. You can use this tag to modify |
| where they run. If the process name begins with a ':' character, |
| a new process private to that application will be created when needed |
| to run that component (allowing you to spread your application across |
| multiple processes). If the process name begins with a lower-case |
| character, the component will be run in a global process of that name, |
| provided that you have permission to do so, allowing multiple |
| applications to share one process to reduce resource usage. --> |
| <attr name="process" format="string" /> |
| |
| <!-- Specify a task name that activities have an "affinity" to. |
| Use with the application tag (to supply a default affinity for all |
| activities in the application), or with the activity tag (to supply |
| a specific affinity for that component). |
| |
| <p>The default value for this attribute is the same as the package |
| name, indicating that all activities in the manifest should generally |
| be considered a single "application" to the user. You can use this |
| attribute to modify that behavior: either giving them an affinity |
| for another task, if the activities are intended to be part of that |
| task from the user's perspective, or using an empty string for |
| activities that have no affinity to a task. --> |
| <attr name="taskAffinity" format="string" /> |
| |
| <!-- Specify that an activity can be moved out of a task it is in to |
| the task it has an affinity for when appropriate. Use with the |
| application tag (to supply a default for all activities in the |
| application), or with an activity tag (to supply a specific |
| setting for that component). |
| |
| <p>Normally when an application is started, it is associated with |
| the task of the activity that started it and stays there for its |
| entire lifetime. You can use the allowTaskReparenting feature to force an |
| activity to be re-parented to a different task when the task it is |
| in goes to the background. Typically this is used to cause the |
| activities of an application to move back to the main task associated |
| with that application. The activity is re-parented to the task |
| with the same {@link android.R.attr#taskAffinity} as it has. --> |
| <attr name="allowTaskReparenting" format="boolean" /> |
| |
| <!-- Declare that this application may use cleartext traffic, such as HTTP rather than HTTPS; |
| WebSockets rather than WebSockets Secure; XMPP, IMAP, STMP without STARTTLS or TLS. |
| Defaults to true. If set to false {@code false}, the application declares that it does not |
| intend to use cleartext network traffic, in which case platform components (e.g. HTTP |
| stacks, {@code DownloadManager}, {@code MediaPlayer}) will refuse applications's requests |
| to use cleartext traffic. Third-party libraries are encouraged to honor this flag as well. |
| --> |
| <attr name="usesCleartextTraffic" format="boolean" /> |
| |
| <!-- Declare that code from this application will need to be loaded into other |
| applications' processes. On devices that support multiple instruction sets, |
| this implies the code might be loaded into a process that's using any of the devices |
| supported instruction sets. |
| |
| <p> The system might treat such applications specially, for eg., by |
| extracting the application's native libraries for all supported instruction |
| sets or by compiling the application's dex code for all supported instruction |
| sets. --> |
| <attr name="multiArch" format ="boolean" /> |
| |
| <!-- Specify whether the 32 bit version of the ABI should be used in a |
| multiArch application. If both abioverride flag (i.e. using abi option of abd install) |
| and use32bitAbi are used, then use32bit is ignored.--> |
| <attr name="use32bitAbi" /> |
| |
| <!-- Specify whether a component is allowed to have multiple instances |
| of itself running in different processes. Use with the activity |
| and provider tags. |
| |
| <p>Normally the system will ensure that all instances of a particular |
| component are only running in a single process. You can use this |
| attribute to disable that behavior, allowing the system to create |
| instances wherever they are used (provided permissions allow it). |
| This is most often used with content providers, so that instances |
| of a provider can be created in each client process, allowing them |
| to be used without performing IPC. --> |
| <attr name="multiprocess" format="boolean" /> |
| |
| <!-- Specify whether an activity should be finished when its task is |
| brought to the foreground by relaunching from the home screen. |
| |
| <p>If both this option and {@link android.R.attr#allowTaskReparenting} are |
| specified, the finish trumps the affinity: the affinity will be |
| ignored and the activity simply finished. --> |
| <attr name="finishOnTaskLaunch" format="boolean" /> |
| |
| <!-- Specify whether an activity should be finished when a "close system |
| windows" request has been made. This happens, for example, when |
| the home key is pressed, when the device is locked, when a system |
| dialog showing recent applications is displayed, etc. --> |
| <attr name="finishOnCloseSystemDialogs" format="boolean" /> |
| |
| <!-- Specify whether an activity's task should be cleared when it |
| is re-launched from the home screen. As a result, every time the |
| user starts the task, they will be brought to its root activity, |
| regardless of whether they used BACK or HOME to last leave it. |
| This flag only applies to activities that |
| are used to start the root of a new task. |
| |
| <p>An example of the use of this flag would be for the case where |
| a user launches activity A from home, and from there goes to |
| activity B. They now press home, and then return to activity A. |
| Normally they would see activity B, since that is what they were |
| last doing in A's task. However, if A has set this flag to true, |
| then upon going to the background all of the tasks on top of it (B |
| in this case) are removed, so when the user next returns to A they |
| will restart at its original activity. |
| |
| <p>When this option is used in conjunction with |
| {@link android.R.attr#allowTaskReparenting}, the allowTaskReparenting trumps the |
| clear. That is, all activities above the root activity of the |
| task will be removed: those that have an affinity will be moved |
| to the task they are associated with, otherwise they will simply |
| be dropped as described here. --> |
| <attr name="clearTaskOnLaunch" format="boolean" /> |
| |
| <!-- Specify whether an activity should be kept in its history stack. |
| If this attribute is set, then as soon as the user navigates away |
| from the activity it will be finished and they will no longer be |
| able to return to it. --> |
| <attr name="noHistory" format="boolean" /> |
| |
| <!-- Specify whether an acitivty's task state should always be maintained |
| by the system, or if it is allowed to reset the task to its initial |
| state in certain situations. |
| |
| <p>Normally the system will reset a task (remove all activities from |
| the stack and reset the root activity) in certain situations when |
| the user re-selects that task from the home screen. Typically this |
| will be done if the user hasn't visited that task for a certain |
| amount of time, such as 30 minutes. |
| |
| <p>By setting this attribute, the user will always return to your |
| 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 the application |
| would not like to lose. --> |
| <attr name="alwaysRetainTaskState" format="boolean" /> |
| |
| <!-- Indicates that an Activity does not need to have its freeze state |
| (as returned by {@link android.app.Activity#onSaveInstanceState} |
| retained in order to be restarted. Generally you use this for activities |
| that do not store any state. When this flag is set, if for some reason |
| the activity is killed before it has a chance to save its state, |
| then the system will not remove it from the activity stack like |
| it normally would. Instead, the next time the user navigates to |
| it its {@link android.app.Activity#onCreate} method will be called |
| with a null icicle, just like it was starting for the first time. |
| |
| <p>This is used by the Home activity to make sure it does not get |
| removed if it crashes for some reason. --> |
| <attr name="stateNotNeeded" format="boolean" /> |
| |
| <!-- Indicates that an Activity should be excluded from the list of |
| recently launched activities. --> |
| <attr name="excludeFromRecents" format="boolean" /> |
| |
| <!-- Specify that an Activity should be shown over the lock screen and, |
| in a multiuser environment, across all users' windows. |
| @deprecated use {@link android.R.attr#showForAllUsers} instead. --> |
| <attr name="showOnLockScreen" format="boolean" /> |
| |
| <!-- Specify that an Activity should be shown even if the current/foreground user |
| is different from the user of the Activity. This will also force the |
| <code>android.view.LayoutParams.FLAG_SHOW_WHEN_LOCKED</code> flag |
| to be set for all windows of this activity --> |
| <attr name="showForAllUsers" format="boolean" /> |
| |
| <!-- Specifies whether an {@link android.app.Activity} should be shown on top of the lock screen |
| whenever the lockscreen is up and the activity is resumed. Normally an activity will be |
| transitioned to the stopped state if it is started while the lockscreen is up, but with |
| this flag set the activity will remain in the resumed state visible on-top of the lock |
| screen. |
| |
| <p>This should be used instead of {@link android.view.WindowManager.LayoutParams#FLAG_SHOW_WHEN_LOCKED} |
| flag set for Windows. When using the Window flag during activity startup, there may not be |
| time to add it before the system stops your activity for being behind the lock-screen. |
| This leads to a double life-cycle as it is then restarted.</p> --> |
| <attr name="showWhenLocked" format="boolean" /> |
| |
| <!-- Specifies whether the screen should be turned on when the {@link android.app.Activity} is resumed. |
| Normally an activity will be transitioned to the stopped state if it is started while the |
| screen if off, but with this flag set the activity will cause the screen to turn on if the |
| activity will be visible and resumed due to the screen coming on. The screen will not be |
| turned on if the activity won't be visible after the screen is turned on. This flag is |
| normally used in conjunction with the {@link android.R.attr#showWhenLocked} flag to make |
| sure the activity is visible after the screen is turned on when the lockscreen is up. In |
| addition, if this flag is set and the activity calls |
| {@link android.app.KeyguardManager#requestDismissKeyguard} |
| the screen will turn on. |
| |
| <p>This should be used instead of {@link android.view.WindowManager.LayoutParams#FLAG_TURN_SCREEN_ON} |
| flag set for Windows. When using the Window flag during activity startup, there may not be |
| time to add it before the system stops your activity because the screen has not yet turned |
| on. This leads to a double life-cycle as it is then restarted.</p> --> |
| <attr name="turnScreenOn" format="boolean" /> |
| |
| <!-- Specify the authorities under which this content provider can be |
| found. Multiple authorities may be supplied by separating them |
| with a semicolon. Authority names should use a Java-style naming |
| convention (such as <code>com.google.provider.MyProvider</code>) |
| in order to avoid conflicts. Typically this name is the same |
| as the class implementation describing the provider's data structure. --> |
| <attr name="authorities" format="string" /> |
| |
| <!-- Flag indicating whether this content provider would like to |
| participate in data synchronization. --> |
| <attr name="syncable" format="boolean" /> |
| |
| <!-- Flag declaring this activity to be 'immersive'; immersive activities |
| should not be interrupted with other activities or notifications. --> |
| <attr name="immersive" format="boolean" /> |
| |
| <!-- Flag declaring that this activity will be run in VR mode, and specifying |
| the component of the {@link android.service.vr.VrListenerService} that should be |
| bound while this Activity is visible if it is installed and enabled on this device. |
| This is equivalent to calling {@link android.app.Activity#setVrModeEnabled} with the |
| the given component name within the Activity that this attribute is set for. |
| Declaring this will prevent the system from leaving VR mode during an Activity |
| transtion from one VR activity to another. --> |
| <attr name="enableVrMode" format="string" /> |
| |
| <!-- Flag allowing the activity to specify which screen rotation animation |
| it desires. Valid values are "rotate", "crossfade", and "jumpcut" |
| as described in {@link android.view.WindowManager.LayoutParams#rotationAnimation}. |
| Specifying your Rotation animation in the WindowManager.LayoutParams |
| may be racy with app startup and updattransitions occuring during application startup and thusly |
| the manifest attribute is preferred. |
| --> |
| <attr name="rotationAnimation"> |
| <flag name="rotate" value= "0" /> |
| <flag name="crossfade" value = "1" /> |
| <flag name="jumpcut" value = "2" /> |
| <flag name="seamless" value = "3" /> |
| </attr> |
| |
| <!-- Specify the order in which content providers hosted by a process |
| are instantiated when that process is created. Not needed unless |
| you have providers with dependencies between each other, to make |
| sure that they are created in the order needed by those dependencies. |
| The value is a simple integer, with higher numbers being |
| initialized first. --> |
| <attr name="initOrder" format="integer" /> |
| |
| <!-- Specify the relative importance or ability in handling a particular |
| Intent. For receivers, this controls the order in which they are |
| executed to receive a broadcast (note that for |
| asynchronous broadcasts, this order is ignored). For activities, |
| this provides information about how good an activity is handling an |
| Intent; when multiple activities match an intent and have different |
| priorities, only those with the higher priority value will be |
| considered a match. |
| |
| <p>Only use if you really need to impose some specific |
| order in which the broadcasts are received, or want to forcibly |
| place an activity to always be preferred over others. The value is a |
| single integer, with higher numbers considered to be better. --> |
| <attr name="priority" format="integer" /> |
| |
| <!-- Indicate if this component is aware of direct boot lifecycle, and can be |
| safely run before the user has entered their credentials (such as a lock |
| pattern or PIN). --> |
| <attr name="directBootAware" format="boolean" /> |
| |
| <!-- Specify how an activity should be launched. See the |
| <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back |
| Stack</a> document for important information on how these options impact |
| the behavior of your application. |
| |
| <p>If this attribute is not specified, <code>standard</code> launch |
| mode will be used. Note that the particular launch behavior can |
| be changed in some ways at runtime through the |
| {@link android.content.Intent} flags |
| {@link android.content.Intent#FLAG_ACTIVITY_SINGLE_TOP}, |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK}, and |
| {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK}. --> |
| <attr name="launchMode"> |
| <!-- The default mode, which will usually create a new instance of |
| the activity when it is started, though this behavior may change |
| with the introduction of other options such as |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK |
| Intent.FLAG_ACTIVITY_NEW_TASK}. --> |
| <enum name="standard" value="0" /> |
| <!-- If, when starting the activity, there is already an |
| instance of the same activity class in the foreground that is |
| interacting with the user, then |
| re-use that instance. This existing instance will receive a call to |
| {@link android.app.Activity#onNewIntent Activity.onNewIntent()} with |
| the new Intent that is being started. --> |
| <enum name="singleTop" value="1" /> |
| <!-- If, when starting the activity, there is already a task running |
| that starts with this activity, then instead of starting a new |
| instance the current task is brought to the front. The existing |
| instance will receive a call to {@link android.app.Activity#onNewIntent |
| Activity.onNewIntent()} |
| with the new Intent that is being started, and with the |
| {@link android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT |
| Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT} flag set. This is a superset |
| of the singleTop mode, where if there is already an instance |
| of the activity being started at the top of the stack, it will |
| receive the Intent as described there (without the |
| FLAG_ACTIVITY_BROUGHT_TO_FRONT flag set). See the |
| <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back |
| Stack</a> document for more details about tasks.--> |
| <enum name="singleTask" value="2" /> |
| <!-- Only allow one instance of this activity to ever be |
| running. This activity gets a unique task with only itself running |
| in it; if it is ever launched again with the same Intent, then that |
| task will be brought forward and its |
| {@link android.app.Activity#onNewIntent Activity.onNewIntent()} |
| method called. If this |
| activity tries to start a new activity, that new activity will be |
| launched in a separate task. See the |
| <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back |
| Stack</a> document for more details about tasks.--> |
| <enum name="singleInstance" value="3" /> |
| </attr> |
| |
| <!-- Specify the orientation an activity should be run in. If not |
| specified, it will run in the current preferred orientation |
| of the screen. |
| <p>This attribute is supported by the <a |
| href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> |
| element. --> |
| <attr name="screenOrientation"> |
| <!-- No preference specified: let the system decide the best |
| orientation. This will either be the orientation selected |
| by the activity below, or the user's preferred orientation |
| if this activity is the bottom of a task. If the user |
| explicitly turned off sensor based orientation through settings |
| sensor based device rotation will be ignored. If not by default |
| sensor based orientation will be taken into account and the |
| orientation will changed based on how the user rotates the device. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED}. --> |
| <enum name="unspecified" value="-1" /> |
| <!-- Would like to have the screen in a landscape orientation: that |
| is, with the display wider than it is tall, ignoring sensor data. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. --> |
| <enum name="landscape" value="0" /> |
| <!-- Would like to have the screen in a portrait orientation: that |
| is, with the display taller than it is wide, ignoring sensor data. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_PORTRAIT}. --> |
| <enum name="portrait" value="1" /> |
| <!-- Use the user's current preferred orientation of the handset. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER}. --> |
| <enum name="user" value="2" /> |
| <!-- Keep the screen in the same orientation as whatever is behind |
| this activity. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_BEHIND}. --> |
| <enum name="behind" value="3" /> |
| <!-- Orientation is determined by a physical orientation sensor: |
| the display will rotate based on how the user moves the device. |
| Ignores user's setting to turn off sensor-based rotation. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR}. --> |
| <enum name="sensor" value="4" /> |
| <!-- Always ignore orientation determined by orientation sensor: |
| the display will not rotate when the user moves the device. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_NOSENSOR}. --> |
| <enum name="nosensor" value="5" /> |
| <!-- Would like to have the screen in landscape orientation, but can |
| use the sensor to change which direction the screen is facing. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR_LANDSCAPE}. --> |
| <enum name="sensorLandscape" value="6" /> |
| <!-- Would like to have the screen in portrait orientation, but can |
| use the sensor to change which direction the screen is facing. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR_PORTRAIT}. --> |
| <enum name="sensorPortrait" value="7" /> |
| <!-- Would like to have the screen in landscape orientation, turned in |
| the opposite direction from normal landscape. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_REVERSE_LANDSCAPE}. --> |
| <enum name="reverseLandscape" value="8" /> |
| <!-- Would like to have the screen in portrait orientation, turned in |
| the opposite direction from normal portrait. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_REVERSE_PORTRAIT}. --> |
| <enum name="reversePortrait" value="9" /> |
| <!-- Orientation is determined by a physical orientation sensor: |
| the display will rotate based on how the user moves the device. |
| This allows any of the 4 possible rotations, regardless of what |
| the device will normally do (for example some devices won't |
| normally use 180 degree rotation). |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_FULL_SENSOR}. --> |
| <enum name="fullSensor" value="10" /> |
| <!-- Would like to have the screen in landscape orientation, but if |
| the user has enabled sensor-based rotation then we can use the |
| sensor to change which direction the screen is facing. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER_LANDSCAPE}. --> |
| <enum name="userLandscape" value="11" /> |
| <!-- Would like to have the screen in portrait orientation, but if |
| the user has enabled sensor-based rotation then we can use the |
| sensor to change which direction the screen is facing. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER_PORTRAIT}. --> |
| <enum name="userPortrait" value="12" /> |
| <!-- Respect the user's sensor-based rotation preference, but if |
| sensor-based rotation is enabled then allow the screen to rotate |
| in all 4 possible directions regardless of what |
| the device will normally do (for example some devices won't |
| normally use 180 degree rotation). |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_FULL_USER}. --> |
| <enum name="fullUser" value="13" /> |
| <!-- Screen is locked to its current rotation, whatever that is. |
| Corresponds to |
| {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LOCKED}. --> |
| <enum name="locked" value="14" /> |
| </attr> |
| |
| <!-- Specify the configuration changes that trigger the system to recreate the |
| current activity if any of these configuration changes happen in the system. |
| The valid configuration changes include mcc and mnc which are the same with |
| those in configChanges. By default from Android O, we don't recreate the activity |
| even the app doesn't specify mcc or mnc in configChanges. If the app wants to |
| be recreated, specify them in recreateOnConfigChanges. --> |
| <attr name="recreateOnConfigChanges"> |
| <!-- The IMSI MCC has changed, that is a SIM has been detected and |
| updated the Mobile Country Code. --> |
| <flag name="mcc" value="0x0001" /> |
| <!-- The IMSI MNC has changed, that is a SIM has been detected and |
| updated the Mobile Network Code. --> |
| <flag name="mnc" value="0x0002" /> |
| </attr> |
| |
| <!-- Specify one or more configuration changes that the activity will |
| handle itself. If not specified, the activity will be restarted |
| if any of these configuration changes happen in the system. Otherwise, |
| the activity will remain running and its |
| {@link android.app.Activity#onConfigurationChanged Activity.onConfigurationChanged} |
| method called with the new configuration. |
| |
| <p>Note that all of these configuration changes can impact the |
| resource values seen by the application, so you will generally need |
| to re-retrieve all resources (including view layouts, drawables, etc) |
| to correctly handle any configuration change. |
| |
| <p>These values must be kept in sync with those in |
| {@link android.content.pm.ActivityInfo} and |
| include/utils/ResourceTypes.h. --> |
| <attr name="configChanges"> |
| <!-- The IMSI MCC has changed, that is a SIM has been detected and |
| updated the Mobile Country Code. By default from Android O, we |
| don't recreate the activity even the app doesn't specify mcc in |
| configChanges. If the app wants to recreate the activity, specify |
| mcc in recreateOnConfigChanges. --> |
| <flag name="mcc" value="0x0001" /> |
| <!-- The IMSI MNC has changed, that is a SIM has been detected and |
| updated the Mobile Network Code. By default from Android O, we |
| don't recreate the activity even the app doesn't specify mnc in |
| configChanges. If the app wants to recreate the acvitity, specify |
| mnc in recreateOnConfigChanges. --> |
| <flag name="mnc" value="0x0002" /> |
| <!-- The locale has changed, that is the user has selected a new |
| language that text should be displayed in. --> |
| <flag name="locale" value="0x0004" /> |
| <!-- The touchscreen has changed. Should never normally happen. --> |
| <flag name="touchscreen" value="0x0008" /> |
| <!-- The keyboard type has changed, for example the user has plugged |
| in an external keyboard. --> |
| <flag name="keyboard" value="0x0010" /> |
| <!-- The keyboard or navigation accessibility has changed, for example |
| the user has slid the keyboard out to expose it. Note that |
| despite its name, this applied to any accessibility: keyboard |
| or navigation. --> |
| <flag name="keyboardHidden" value="0x0020" /> |
| <!-- The navigation type has changed. Should never normally happen. --> |
| <flag name="navigation" value="0x0040" /> |
| <!-- The screen orientation has changed, that is the user has |
| rotated the device. --> |
| <flag name="orientation" value="0x0080" /> |
| <!-- The screen layout has changed. This might be caused by a |
| different display being activated. --> |
| <flag name="screenLayout" value="0x0100" /> |
| <!-- The global user interface mode has changed. For example, |
| going in or out of car mode, night mode changing, etc. --> |
| <flag name="uiMode" value="0x0200" /> |
| <!-- The current available screen size has changed. If applications don't |
| target at least {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2} |
| then the activity will always handle this itself (the change |
| will not result in a restart). This represents a change in the |
| currently available size, so will change when the user switches |
| between landscape and portrait. --> |
| <flag name="screenSize" value="0x0400" /> |
| <!-- The physical screen size has changed. If applications don't |
| target at least {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2} |
| then the activity will always handle this itself (the change |
| will not result in a restart). This represents a change in size |
| regardless of orientation, so will only change when the actual |
| physical screen size has changed such as switching to an external |
| display. --> |
| <flag name="smallestScreenSize" value="0x0800" /> |
| <!-- The display density has changed. This might be caused by the user |
| specifying a different display scale, or it might be caused by a |
| different display being activated. --> |
| <flag name="density" value="0x1000" /> |
| <!-- The layout direction has changed. For example going from LTR to RTL. --> |
| <flag name="layoutDirection" value="0x2000" /> |
| <!-- The color mode of the screen has changed (color gamut or dynamic range). --> |
| <flag name="colorMode" value="0x4000" /> |
| <!-- The font scaling factor has changed, that is the user has |
| selected a new global font size. --> |
| <flag name="fontScale" value="0x40000000" /> |
| </attr> |
| |
| <!-- Indicate that the activity can be launched as the embedded child of another |
| activity. Particularly in the case where the child lives in a container |
| such as a Display owned by another activity. |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="allowEmbedded" format="boolean" /> |
| |
| <!-- Specifies whether this {@link android.app.Activity} should be shown on |
| top of the lock screen whenever the lockscreen is up and this activity has another |
| activity behind it with the {@link android.R.attr#showWhenLocked} attribute set. That |
| is, this activity is only visible on the lock screen if there is another activity with |
| the {@link android.R.attr#showWhenLocked} attribute visible at the same time on the |
| lock screen. A use case for this is permission dialogs, that should only be visible on |
| the lock screen if their requesting activity is also visible. |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="inheritShowWhenLocked" format="boolean" /> |
| |
| <!-- Descriptive text for the associated data. --> |
| <attr name="description" format="reference" /> |
| |
| <!-- The name of the application package that an Instrumentation object |
| will run against. --> |
| <attr name="targetPackage" format="string" /> |
| |
| <!-- The name of an application's processes that an Instrumentation object |
| will run against. If not specified, only runs in the main process of the targetPackage. |
| Can either be a comma-separated list of process names or '*' for any process that |
| launches to run targetPackage code. --> |
| <attr name="targetProcesses" format="string" /> |
| |
| <!-- Flag indicating that an Instrumentation class wants to take care |
| of starting/stopping profiling itself, rather than relying on |
| the default behavior of profiling the complete time it is running. |
| This allows it to target profiling data at a specific set of |
| operations. --> |
| <attr name="handleProfiling" format="boolean" /> |
| |
| <!-- Flag indicating that an Instrumentation class should be run as a |
| functional test. --> |
| <attr name="functionalTest" format="boolean" /> |
| |
| <!-- The touch screen type used by an application. --> |
| <attr name="reqTouchScreen"> |
| <enum name="undefined" value="0" /> |
| <enum name="notouch" value="1" /> |
| <enum name="stylus" value="2" /> |
| <enum name="finger" value="3" /> |
| </attr> |
| |
| <!-- The input method preferred by an application. --> |
| <attr name="reqKeyboardType"> |
| <enum name="undefined" value="0" /> |
| <enum name="nokeys" value="1" /> |
| <enum name="qwerty" value="2" /> |
| <enum name="twelvekey" value="3" /> |
| </attr> |
| |
| <!-- Application's requirement for a hard keyboard --> |
| <attr name="reqHardKeyboard" format="boolean" /> |
| |
| <!-- The navigation device preferred by an application. --> |
| <attr name="reqNavigation"> |
| <enum name="undefined" value="0" /> |
| <enum name="nonav" value="1" /> |
| <enum name="dpad" value="2" /> |
| <enum name="trackball" value="3" /> |
| <enum name="wheel" value="4" /> |
| </attr> |
| |
| <!-- Application's requirement for five way navigation --> |
| <attr name="reqFiveWayNav" format="boolean" /> |
| |
| <!-- The name of the class subclassing <code>BackupAgent</code> to manage |
| backup and restore of the application's data on external storage. --> |
| <attr name="backupAgent" format="string" /> |
| |
| <!-- Whether to allow the application to participate in the backup |
| and restore infrastructure. If this attribute is set to <code>false</code>, |
| no backup or restore of the application will ever be performed, even by a |
| full-system backup that would otherwise cause all application data to be saved |
| via adb. The default value of this attribute is <code>true</code>. --> |
| <attr name="allowBackup" format="boolean" /> |
| |
| <!-- Applications will set this in their manifest to opt-in to or out of full app data back-up |
| and restore. Alternatively they can set it to an xml resource within their app that will |
| be parsed by the BackupAgent to selectively backup files indicated within that xml. --> |
| <attr name="fullBackupContent" format="reference|boolean" /> |
| |
| <!-- Indicates that even though the application provides a <code>BackupAgent</code>, |
| only full-data streaming backup operations are to be performed to save the app's |
| data. This lets the app rely on full-data backups while still participating in |
| the backup and restore process via the BackupAgent's full-data backup APIs. |
| When this attribute is <code>true</code> the app's BackupAgent overrides of |
| the onBackup() and onRestore() callbacks can be empty stubs. --> |
| <attr name="fullBackupOnly" format="boolean" /> |
| |
| <!-- Whether the application in question should be terminated after its |
| settings have been restored during a full-system restore operation. |
| Single-package restore operations will never cause the application to |
| be shut down. Full-system restore operations typically only occur once, |
| when the phone is first set up. Third-party applications will not usually |
| need to use this attribute. |
| |
| <p>The default is <code>true</code>, which means that after the application |
| has finished processing its data during a full-system restore, it will be |
| terminated. --> |
| <attr name="killAfterRestore" format="boolean" /> |
| |
| <!-- @deprecated This attribute is not used by the Android operating system. --> |
| <attr name="restoreNeedsApplication" format="boolean" /> |
| |
| <!-- Indicate that the application is prepared to attempt a restore of any |
| backed-up dataset, even if the backup is apparently from a newer version |
| of the application than is currently installed on the device. Setting |
| this attribute to <code>true</code> will permit the Backup Manager to |
| attempt restore even when a version mismatch suggests that the data are |
| incompatible. <em>Use with caution!</em> |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="restoreAnyVersion" format="boolean" /> |
| |
| <!-- Indicates that full-data backup operations for this application may |
| be performed even if the application is in a foreground-equivalent |
| state. <em>Use with caution!</em> Setting this flag to <code>true</code> |
| can impact app behavior while the user is interacting with the device. |
| |
| <p>If unspecified, the default value of this attribute is <code>false</code>, |
| which means that the OS will avoid backing up the application while it is |
| running in the foreground (such as a music app that is actively playing |
| music via a service in the startForeground() state). --> |
| <attr name="backupInForeground" format="boolean" /> |
| |
| <!-- The default install location defined by an application. --> |
| <attr name="installLocation"> |
| <!-- Let the system decide ideal install location --> |
| <enum name="auto" value="0" /> |
| <!-- Explicitly request to be installed on internal phone storage |
| only. --> |
| <enum name="internalOnly" value="1" /> |
| <!-- Prefer to be installed on SD card. There is no guarantee that |
| the system will honor this request. The application might end |
| up being installed on internal storage if external media |
| is unavailable or too full. --> |
| <enum name="preferExternal" value="2" /> |
| </attr> |
| |
| <!-- If set to <code>true</code>, indicates to the platform that any split APKs |
| installed for this application should be loaded into their own Context |
| objects and not appear in the base application's Context. |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="isolatedSplits" format="boolean" /> |
| |
| <!-- The classname of the classloader used to load the application's classes |
| from its APK. The APK in question can either be the 'base' APK or any |
| of the application's 'split' APKs if it's using a feature split. |
| |
| <p> |
| The supported values for this attribute are |
| <code>dalvik.system.PathClassLoader</code> and |
| <code>dalvik.system.DelegateLastClassLoader</code>. If unspecified, |
| the default value of this attribute is <code>dalvik.system.PathClassLoader</code>. |
| |
| If an unknown classloader is provided, a PackageParserException with cause |
| <code>PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED</code> will be |
| thrown and the app will not be installed. |
| --> |
| <attr name="classLoader" format="string" /> |
| |
| <!-- Name of the class that gets invoked for preloading application code, when starting an |
| {@link android.R.attr#isolatedProcess} service that has |
| {@link android.R.attr#useAppZygote} set to <code>true</code>. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyZygotePreload); as a |
| short-hand if the first character of the class is a period then it is appended |
| to your package name. The class must implement the {@link android.app.ZygotePreload} |
| interface. --> |
| <attr name="zygotePreloadName" format="string"/> |
| |
| <!-- If set to <code>true</code>, indicates to the platform that this APK is |
| a 'feature' split and that it implicitly depends on the base APK. This distinguishes |
| this split APK from a 'configuration' split, which provides resource overrides |
| for a particular 'feature' split. Only useful when the base APK specifies |
| <code>android:isolatedSplits="true"</code>. |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="isFeatureSplit" format="boolean" /> |
| |
| <!-- Flag to specify if this APK requires at least one split [either feature or |
| resource] to be present in order to function. Default value is false. --> |
| <attr name="isSplitRequired" format="boolean" /> |
| |
| <!-- Flag to specify if this app wants to run the dex within its APK but not extracted or |
| locally compiled variants. This keeps the dex code protected by the APK signature. Such |
| apps will always run in JIT mode (same when they are first installed), and the system will |
| never generate ahead-of-time compiled code for them. Depending on the app's workload, |
| there may be some run time performance change, noteably the cold start time. --> |
| <attr name="useEmbeddedDex" format="boolean" /> |
| |
| <!-- Extra options for an activity's UI. Applies to either the {@code <activity>} or |
| {@code <application>} tag. If specified on the {@code <application>} |
| tag these will be considered defaults for all activities in the |
| application. --> |
| <attr name="uiOptions"> |
| <!-- No extra UI options. This is the default. --> |
| <flag name="none" value="0" /> |
| <!-- Split the options menu into a separate bar at the bottom of |
| the screen when severely constrained for horizontal space. |
| (e.g. portrait mode on a phone.) Instead of a small number |
| of action buttons appearing in the action bar at the top |
| of the screen, the action bar will split into the top navigation |
| section and the bottom menu section. Menu items will not be |
| split across the two bars; they will always appear together. --> |
| <flag name="splitActionBarWhenNarrow" value="1" /> |
| </attr> |
| |
| <!-- The name of the logical parent of the activity as it appears in the manifest. --> |
| <attr name="parentActivityName" format="string" /> |
| |
| <!-- Define how an activity persist across reboots. Activities defined as "never" will not |
| be persisted. Those defined as "always" will be persisted. Those defined as "taskOnly" |
| will persist the root activity of the task only. See below for more detail as to |
| what gets persisted. --> |
| <attr name="persistableMode"> |
| <!-- The default. If this activity forms the root of a task then that task will be |
| persisted across reboots but only the launching intent will be used. If the task |
| relinquishes its identity then the intent used is that of the topmost inherited |
| identity. All activities above this activity in the task will not be persisted. |
| In addition this activity will not be passed a PersistableBundle into which it |
| could have stored its state. --> |
| <enum name="persistRootOnly" value="0" /> |
| <!-- If this activity forms the root of a task then that task will not be persisted |
| across reboots --> |
| <enum name="persistNever" value="1" /> |
| <!-- If this activity forms the root of a task then the task and this activity will |
| be persisted across reboots. If the activity above this activity is also |
| tagged with the attribute <code>"persist"</code> then it will be persisted as well. |
| And so on up the task stack until either an activity without the |
| <code>persistableMode="persistAcrossReboots"</code> attribute or one that was launched |
| with the flag Intent.FLAG_CLEAR_TASK_WHEN_RESET is encountered. |
| |
| <p>Activities that are declared with the persistAcrossReboots attribute will be |
| provided with a PersistableBundle in onSavedInstanceState(), These activities may |
| use this PeristableBundle to save their state. Then, following a reboot, that |
| PersistableBundle will be provided back to the activity in its onCreate() method. --> |
| <enum name="persistAcrossReboots" value="2" /> |
| </attr> |
| |
| <!-- This attribute specifies that an activity shall become the root activity of a |
| new task each time it is launched. Using this attribute permits the user to |
| have multiple documents from the same applications appear in the recent tasks list. |
| |
| <p>Such a document is any kind of item for which an application may want to |
| maintain multiple simultaneous instances. Examples might be text files, web |
| pages, spreadsheets, or emails. Each such document will be in a separate |
| task in the recent taskss list. |
| |
| <p>This attribute is equivalent to adding the flag {@link |
| android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT} to every Intent used to launch |
| the activity. |
| |
| <p>The documentLaunchMode attribute may be assigned one of four values, "none", |
| "intoExisting", "always" and "never", described in detail below. For values other than |
| <code>none</code> and <code>never</code> the activity must be defined with |
| {@link android.R.attr#launchMode} <code>standard</code>. |
| If this attribute is not specified, <code>none</code> will be used. |
| Note that <code>none</code> can be overridden at run time if the Intent used |
| to launch it contains the flag {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT |
| Intent.FLAG_ACTIVITY_NEW_DOCUMENT}. |
| Similarly <code>intoExisting</code> will be overridden by the flag |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT |
| Intent.FLAG_ACTIVITY_NEW_DOCUMENT} combined with |
| {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK |
| Intent.FLAG_ACTIVITY_MULTIPLE_TASK}. If the value of |
| documentLaunchModes is <code>never</code> then any use of |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT |
| Intent.FLAG_ACTIVITY_NEW_DOCUMENT} to launch this activity will be ignored. --> |
| <attr name="documentLaunchMode"> |
| <!-- The default mode, which will create a new task only when |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK |
| Intent.FLAG_ACTIVITY_NEW_TASK} is set. --> |
| <enum name="none" value="0" /> |
| <!-- All tasks will be searched for one whose base Intent's ComponentName and |
| data URI match those of the launching Intent. If such a task is found |
| that task will be cleared and restarted with the root activity receiving a call |
| to {@link android.app.Activity#onNewIntent Activity.onNewIntent}. If no |
| such task is found a new task will be created. |
| <p>This is the equivalent of launching an activity with {@link |
| android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT Intent.FLAG_ACTIVITY_NEW_DOCUMENT} |
| set and without {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK |
| Intent.FLAG_ACTIVITY_MULTIPLE_TASK} set. --> |
| <enum name="intoExisting" value="1" /> |
| <!-- A new task rooted at this activity will be created. This will happen whether or |
| not there is an existing task whose ComponentName and data URI match |
| that of the launcing intent This is the equivalent of launching an activity |
| with {@link |
| android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT Intent.FLAG_ACTIVITY_NEW_DOCUMENT} |
| and {@link android.content.Intent#FLAG_ACTIVITY_MULTIPLE_TASK |
| Intent.FLAG_ACTIVITY_MULTIPLE_TASK} both set. --> |
| <enum name="always" value="2" /> |
| <!-- This activity will not be launched into a new document even if the Intent contains |
| {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT |
| Intent.FLAG_ACTIVITY_NEW_DOCUMENT}. This gives the activity writer ultimate |
| control over how their activity is used. Note that applications prior to api |
| 21 will default to documentLaunchMode="none" so only activities that explicitly |
| opt out with <code>"never"</code> may do so. --> |
| <enum name="never" value="3" /> |
| </attr> |
| |
| <!-- The maximum number of entries of tasks rooted at this activity in the recent task list. |
| When this number of entries is reached the least recently used instance of this activity |
| will be removed from recents. The value will be clamped between 1 and 100 inclusive. |
| The default value for this if it is not specified is 15. --> |
| <attr name="maxRecents" format="integer" /> |
| |
| <!-- Tasks launched by activities with this attribute will remain in the recent tasks |
| list until the last activity in the task is completed. When that happens the task |
| will be automatically removed from the recent tasks list. This overrides the caller's |
| use of {@link android.content.Intent#FLAG_ACTIVITY_RETAIN_IN_RECENTS |
| Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS} --> |
| <attr name="autoRemoveFromRecents" format="boolean" /> |
| |
| <!-- Tasks whose root has this attribute set to true will replace baseIntent with that of the |
| next activity in the task. If the next activity also has this attribute set to true then |
| it will yield the baseIntent to any activity that it launches in the same task. This |
| continues until an activity is encountered which has this attribute set to false. False |
| is the default. This attribute set to true also permits activity's use of the |
| TaskDescription to change labels, colors and icons in the recent task list. --> |
| <attr name="relinquishTaskIdentity" format="boolean" /> |
| |
| <!-- Indicate that it is okay for this activity be resumed while the previous |
| activity is in the process of pausing, without waiting for the previous pause |
| to complete. Use this with caution: your activity can not acquire any exclusive |
| resources (such as opening the camera or recording audio) when it launches, or it |
| may conflict with the previous activity and fail. |
| |
| <p>The default value of this attribute is <code>false</code>. --> |
| <attr name="resumeWhilePausing" format="boolean" /> |
| |
| <!-- Indicates that it is okay for this activity to be resized to any dimension. Intended for a |
| multi-window device where there can be multiple activities of various sizes on the screen |
| at the same time. |
| |
| <p>The default value is <code>false</code> for applications with |
| <code>targetSdkVersion</code> lesser than {@link android.os.Build.VERSION_CODES#N} and |
| <code>true</code> otherwise. |
| |
| <p>NOTE: A task's root activity value is applied to all additional activities launched in |
| the task. That is if the root activity of a task is resizeable then the system will treat |
| all other activities in the task as resizeable and will not if the root activity isn't |
| resizeable. |
| |
| <p>NOTE: The value of {@link android.R.attr#screenOrientation} is ignored for |
| resizeable activities when in multi-window mode. --> |
| <attr name="resizeableActivity" format="boolean" /> |
| |
| <!-- Indicates that the activity specifically supports the picture-in-picture form of |
| multi-window. If true, this activity will support entering picture-in-picture, but will |
| only support split-screen and other forms of multi-window if |
| {@link android.R.attr#resizeableActivity} is also set to true. |
| |
| Note that your activity may still be resized even if this attribute is true and |
| {@link android.R.attr#resizeableActivity} is false. |
| |
| <p>The default value is <code>false</code>. --> |
| <attr name="supportsPictureInPicture" format="boolean" /> |
| |
| <!-- This value indicates the maximum aspect ratio the activity supports. If the app runs on a |
| device with a wider aspect ratio, the system automatically letterboxes the app, leaving |
| portions of the screen unused so the app can run at its specified maximum aspect ratio. |
| <p> |
| Maximum aspect ratio, expressed as (longer dimension / shorter dimension) in decimal |
| form. For example, if the maximum aspect ratio is 7:3, set value to 2.33. |
| <p> |
| Value needs to be greater or equal to 1.0, otherwise it is ignored. |
| <p> |
| NOTE: This attribute is ignored if the activity has |
| {@link android.R.attr#resizeableActivity} set to true, since that means your activity |
| supports any size. --> |
| <attr name="maxAspectRatio" format="float" /> |
| |
| <!-- This value indicates the minimum aspect ratio the activity supports. If the app runs on a |
| device with a narrower aspect ratio, the system automatically letterboxes the app, leaving |
| portions of the screen unused so the app can run at its specified minimum aspect ratio. |
| <p> |
| Minimum aspect ratio, expressed as (longer dimension / shorter dimension) in decimal |
| form. For example, if the minimum aspect ratio is 4:3, set value to 1.33. |
| <p> |
| Value needs to be greater or equal to 1.0, otherwise it is ignored. |
| <p> |
| NOTE: This attribute is ignored if the activity has |
| {@link android.R.attr#resizeableActivity} set to true, since that means your activity |
| supports any size. --> |
| <attr name="minAspectRatio" format="float" /> |
| |
| <!-- This value indicates how tasks rooted at this activity will behave in lockTask mode. |
| While in lockTask mode the system will not launch non-permitted tasks until |
| lockTask mode is disabled. |
| <p>While in lockTask mode with multiple permitted tasks running, each launched task is |
| permitted to finish, transitioning to the previous locked task, until there is only one |
| task remaining. At that point the last task running is not permitted to finish, unless it |
| uses the value always. --> |
| <attr name="lockTaskMode"> |
| <!-- This is the default value. Tasks will not launch into lockTask mode but can be |
| placed there by calling {@link android.app.Activity#startLockTask}. If a task with |
| this mode has been whitelisted using {@link |
| android.app.admin.DevicePolicyManager#setLockTaskPackages} then calling |
| {@link android.app.Activity#startLockTask} will enter lockTask mode immediately, |
| otherwise the user will be presented with a dialog to approve entering pinned mode. |
| <p>If the system is already in lockTask mode when a new task rooted at this activity |
| is launched that task will or will not start depending on whether the package of this |
| activity has been whitelisted. |
| <p>Tasks rooted at this activity can only exit lockTask mode using |
| {@link android.app.Activity#stopLockTask}. --> |
| <enum name="normal" value="0"/> |
| <!-- Tasks will not launch into lockTask mode and cannot be placed there using |
| {@link android.app.Activity#startLockTask} or be pinned from the Overview screen. |
| If the system is already in lockTask mode when a new task rooted at this activity is |
| launched that task will not be started. |
| <p>Note: This mode is only available to system and privileged applications. |
| Non-privileged apps with this value will be treated as normal. |
| --> |
| <enum name="never" value="1"/> |
| <!-- Tasks rooted at this activity will always launch into lockTask mode. If the system is |
| already in lockTask mode when this task is launched then the new task will be launched |
| on top of the current task. Tasks launched in this mode are capable of exiting |
| lockTask mode using {@link android.app.Activity#finish()}. |
| <p>Note: This mode is only available to system and privileged applications. |
| Non-privileged apps with this value will be treated as normal. |
| --> |
| <enum name="always" value="2"/> |
| <!-- If the DevicePolicyManager (DPM) authorizes this package ({@link |
| android.app.admin.DevicePolicyManager#setLockTaskPackages}) then this mode is |
| identical to always, except that the activity needs to call |
| {@link android.app.Activity#stopLockTask} before being able to finish if it is the last |
| locked task. |
| If the DPM does not authorize this package then this mode is identical to normal. --> |
| <enum name="if_whitelisted" value="3"/> |
| </attr> |
| <!-- When set installer will extract native libraries. If set to false |
| libraries in the apk must be stored and page-aligned. --> |
| <attr name="extractNativeLibs" format="boolean"/> |
| |
| <!-- Specify whether an activity intent filter will need to be verified thru its set |
| of data URIs. This will only be used when the Intent's action is set to |
| {@link android.content.Intent#ACTION_VIEW Intent.ACTION_VIEW} and the Intent's category is |
| set to {@link android.content.Intent#CATEGORY_BROWSABLE Intent.CATEGORY_BROWSABLE} and the |
| intern filter data scheme is set to "http" or "https". When set to true, the intent filter |
| will need to use its data tag for getting the URIs to verify with. |
| |
| For each URI, an HTTPS network request will be done to <code>/.well-known/statements.json</code> |
| host to verify that the web site is okay with the app intercepting the URI. |
| --> |
| <attr name="autoVerify" format="boolean" /> |
| |
| <!-- Specify whether a component should be visible to instant apps. |
| --> |
| <attr name="visibleToInstantApps" format="boolean" /> |
| |
| <!-- An XML resource with the application's Network Security Config. --> |
| <attr name="networkSecurityConfig" format="reference" /> |
| |
| <!-- When an application is partitioned into splits, this is the name of the |
| split that contains the defined component. --> |
| <attr name="splitName" format="string" /> |
| |
| <!-- Specifies the target sandbox this app wants to use. Higher sandbox versions |
| will have increasing levels of security. |
| |
| <p>The default value of this attribute is <code>1</code>. |
| <p> |
| @deprecated The security properties have been moved to |
| {@link android.os.Build.VERSION Build.VERSION} 27 and 28. --> |
| <attr name="targetSandboxVersion" format="integer" /> |
| |
| <!-- The user-visible SDK version (ex. 26) of the framework against which the application was |
| compiled. This attribute is automatically specified by the Android build tools and should |
| NOT be manually specified. |
| <p> |
| This attribute is the compile-time equivalent of |
| {@link android.os.Build.VERSION#SDK_INT Build.VERSION.SDK_INT}. --> |
| <attr name="compileSdkVersion" format="integer" /> |
| |
| <!-- The development codename (ex. "O") of the framework against which the application was |
| compiled, or "REL" if the application was compiled against a release build. This attribute |
| is automatically specified by the Android build tools and should NOT be manually |
| specified. |
| <p> |
| This attribute is the compile-time equivalent of |
| {@link android.os.Build.VERSION#CODENAME Build.VERSION.CODENAME}. --> |
| <attr name="compileSdkVersionCodename" format="string" /> |
| |
| <!-- The (optional) fully-qualified name for a subclass of |
| {@link android.app.AppComponentFactory} that the system uses to instantiate |
| every other manifest defined class. Most applications |
| don't need this attribute. If it's not specified, the system |
| instantiates items without it.--> |
| <attr name="appComponentFactory" format="string" /> |
| |
| <attr name="usesNonSdkApi" format="boolean" /> |
| |
| <!-- Specify the type of foreground service. Multiple types can be specified by ORing the flags |
| together. --> |
| <attr name="foregroundServiceType"> |
| <!-- Data (photo, file, account) upload/download, backup/restore, import/export, fetch, |
| transfer over network between device and cloud. --> |
| <flag name="dataSync" value="0x01" /> |
| <!-- Music, video, news or other media play. --> |
| <flag name="mediaPlayback" value="0x02" /> |
| <!-- Ongoing phone call or video conference. --> |
| <flag name="phoneCall" value="0x04" /> |
| <!-- GPS, map, navigation location update. --> |
| <flag name="location" value="0x08" /> |
| <!-- Auto, bluetooth, TV or other devices connection, monitoring and interaction. --> |
| <flag name="connectedDevice" value="0x10" /> |
| <!-- Managing a media projection session, e.g, for screen recording or taking |
| screenshots.--> |
| <flag name="mediaProjection" value="0x20" /> |
| </attr> |
| |
| |
| <!-- The <code>manifest</code> tag is the root of an |
| <code>AndroidManifest.xml</code> file, |
| describing the contents of an Android package (.apk) file. One |
| attribute must always be supplied: <code>package</code> gives a |
| unique name for the package, using a Java-style naming convention |
| to avoid name collisions. For example, applications published |
| by Google could have names of the form |
| <code>com.google.app.<em>appname</em></code> |
| |
| <p>Inside of the manifest tag, may appear the following tags |
| in any order: {@link #AndroidManifestPermission permission}, |
| {@link #AndroidManifestPermissionGroup permission-group}, |
| {@link #AndroidManifestPermissionTree permission-tree}, |
| {@link #AndroidManifestUsesSdk uses-sdk}, |
| {@link #AndroidManifestUsesPermission uses-permission}, |
| {@link #AndroidManifestUsesConfiguration uses-configuration}, |
| {@link #AndroidManifestApplication application}, |
| {@link #AndroidManifestInstrumentation instrumentation}, |
| {@link #AndroidManifestUsesFeature uses-feature}. --> |
| <declare-styleable name="AndroidManifest"> |
| <attr name="versionCode" /> |
| <attr name="versionCodeMajor" /> |
| <attr name="versionName" /> |
| <attr name="revisionCode" /> |
| <attr name="sharedUserId" /> |
| <attr name="sharedUserLabel" /> |
| <attr name="installLocation" /> |
| <attr name="isolatedSplits" /> |
| <attr name="isFeatureSplit" /> |
| <attr name="targetSandboxVersion" /> |
| <attr name="compileSdkVersion" /> |
| <attr name="compileSdkVersionCodename" /> |
| <attr name="isSplitRequired" /> |
| </declare-styleable> |
| |
| <!-- The <code>application</code> tag describes application-level components |
| contained in the package, as well as general application |
| attributes. Many of the attributes you can supply here (such |
| as theme, label, icon, permission, process, taskAffinity, |
| and allowTaskReparenting) serve |
| as default values for the corresponding attributes of components |
| declared inside of the application. |
| |
| <p>Inside of this element you specify what the application contains, |
| using the elements {@link #AndroidManifestProvider provider}, |
| {@link #AndroidManifestService service}, |
| {@link #AndroidManifestReceiver receiver}, |
| {@link #AndroidManifestActivity activity}, |
| {@link #AndroidManifestActivityAlias activity-alias}, |
| {@link #AndroidManifestUsesLibrary uses-library}, |
| {@link #AndroidManifestUsesStaticLibrary uses-static-library}, and |
| {@link #AndroidManifestUsesPackage uses-package}. |
| The application tag |
| appears as a child of the root {@link #AndroidManifest manifest} tag in |
| an application's manifest file. --> |
| <declare-styleable name="AndroidManifestApplication" parent="AndroidManifest"> |
| <!-- The (optional) fully-qualified name for a subclass of |
| {@link android.app.Application} that the system instantiates before |
| any other class when an app's process starts. Most applications |
| don't need this attribute. If it's not specified, the system |
| instantiates the base Application class instead.--> |
| <attr name="name" /> |
| <attr name="theme" /> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="description" /> |
| <attr name="permission" /> |
| <attr name="process" /> |
| <attr name="taskAffinity" /> |
| <attr name="allowTaskReparenting" /> |
| <!-- Indicate whether this application contains code. If set to false, |
| there is no code associated with it and thus the system will not |
| try to load its code when launching components. The default is true |
| for normal behavior. --> |
| <attr name="hasCode" format="boolean" /> |
| <attr name="persistent" /> |
| <attr name="persistentWhenFeatureAvailable" /> |
| <attr name="requiredForAllUsers" /> |
| <!-- Specify whether the components in this application are enabled or not (that is, can be |
| instantiated by the system). |
| If "false", it overrides any component specific values (a value of "true" will not |
| override the component specific values). --> |
| <attr name="enabled" /> |
| <attr name="debuggable" /> |
| <attr name="vmSafeMode" /> |
| <attr name="hardwareAccelerated" /> |
| <!-- Name of activity to be launched for managing the application's space on the device. --> |
| <attr name="manageSpaceActivity" /> |
| <attr name="allowClearUserData" /> |
| <attr name="testOnly" /> |
| <attr name="backupAgent" /> |
| <attr name="allowBackup" /> |
| <attr name="fullBackupOnly" /> |
| <attr name="fullBackupContent" /> |
| <attr name="killAfterRestore" /> |
| <attr name="restoreNeedsApplication" /> |
| <attr name="restoreAnyVersion" /> |
| <attr name="backupInForeground" /> |
| <!-- Request that your application's processes be created with |
| a large Dalvik heap. This applies to <em>all</em> processes |
| created for the application. It only applies to the first |
| application loaded into a process; if using a sharedUserId |
| to allow multiple applications to use a process, they all must |
| use this option consistently or will get unpredictable results. --> |
| <attr name="largeHeap" format="boolean" /> |
| <!-- Declare that this application can't participate in the normal |
| state save/restore mechanism. Since it is not able to save and |
| restore its state on demand, |
| it can not participate in the normal activity lifecycle. It will |
| not be killed while in the background; the user must explicitly |
| quit it. Only one such app can be running at a time; if the user |
| tries to launch a second such app, they will be prompted |
| to quit the first before doing so. While the |
| application is running, the user will be informed of this. --> |
| <attr name="cantSaveState" format="boolean" /> |
| <attr name="uiOptions" /> |
| <!-- Declare that your application will be able to deal with RTL (right to left) layouts. |
| The default value is false. --> |
| <attr name="supportsRtl" format="boolean" /> |
| <!-- Declare that this application requires access to restricted accounts of a certain |
| type. The default value is null and restricted accounts won\'t be visible to this |
| application. The type should correspond to the account authenticator type, such as |
| "com.google". --> |
| <attr name="restrictedAccountType" format="string"/> |
| <!-- Declare that this application requires an account of a certain |
| type. The default value is null and indicates that the application can work without |
| any accounts. The type should correspond to the account authenticator type, such as |
| "com.google". --> |
| <attr name="requiredAccountType" format="string"/> |
| <!-- @deprecated replaced by setting appCategory attribute to "game" --> |
| <attr name="isGame" /> |
| <!-- Declare that this application may use cleartext traffic, such as HTTP rather than |
| HTTPS; WebSockets rather than WebSockets Secure; XMPP, IMAP, STMP without STARTTLS or |
| TLS). Defaults to true. If set to false {@code false}, the application declares that it |
| does not intend to use cleartext network traffic, in which case platform components |
| (e.g. HTTP stacks, {@code DownloadManager}, {@code MediaPlayer}) will refuse |
| applications's requests to use cleartext traffic. Third-party libraries are encouraged |
| to honor this flag as well. --> |
| <attr name="usesCleartextTraffic" /> |
| <attr name="multiArch" /> |
| <attr name="useEmbeddedDex" /> |
| <attr name="extractNativeLibs" /> |
| <attr name="defaultToDeviceProtectedStorage" format="boolean" /> |
| <attr name="directBootAware" /> |
| <attr name="resizeableActivity" /> |
| <attr name="maxAspectRatio" /> |
| <attr name="minAspectRatio" /> |
| <attr name="networkSecurityConfig" /> |
| <!-- Declare the category of this app. Categories are used to cluster multiple apps |
| together into meaningful groups, such as when summarizing battery, network, or |
| disk usage. Apps should only define this value when they fit well into one of |
| the specific categories. --> |
| <attr name="appCategory"> |
| <!-- Apps which are primarily games. --> |
| <enum name="game" value="0" /> |
| <!-- Apps which primarily work with audio or music, such as music players. --> |
| <enum name="audio" value="1" /> |
| <!-- Apps which primarily work with video or movies, such as streaming video apps. --> |
| <enum name="video" value="2" /> |
| <!-- Apps which primarily work with images or photos, such as camera or gallery apps. --> |
| <enum name="image" value="3" /> |
| <!-- Apps which are primarily social apps, such as messaging, communication, email, or social network apps. --> |
| <enum name="social" value="4" /> |
| <!-- Apps which are primarily news apps, such as newspapers, magazines, or sports apps. --> |
| <enum name="news" value="5" /> |
| <!-- Apps which are primarily maps apps, such as navigation apps. --> |
| <enum name="maps" value="6" /> |
| <!-- Apps which are primarily productivity apps, such as cloud storage or workplace apps. --> |
| <enum name="productivity" value="7" /> |
| </attr> |
| |
| <!-- Declares the kind of classloader this application's classes must be loaded with --> |
| <attr name="classLoader" /> |
| |
| <attr name="appComponentFactory" /> |
| |
| <!-- Declares that this application should be invoked without non-SDK API enforcement --> |
| <attr name="usesNonSdkApi" /> |
| |
| <!-- If {@code true} the user is prompted to keep the app's data on uninstall --> |
| <attr name="hasFragileUserData" /> |
| |
| <attr name="zygotePreloadName" /> |
| |
| <!-- If {@code true} the system will clear app's data if a restore operation fails. |
| This flag is turned on by default. <em>This attribute is usable only by system apps. |
| </em> --> |
| <attr name="allowClearUserDataOnFailedRestore"/> |
| <!-- If {@code true} the app's non sensitive audio can be capture by other apps. |
| The default value is true. --> |
| <attr name="allowAudioPlaybackCapture" format="boolean" /> |
| </declare-styleable> |
| <!-- The <code>permission</code> tag declares a security permission that can be |
| used to control access from other packages to specific components or |
| features in your package (or other packages). See the |
| <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> |
| document for more information on permissions. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestPermission" parent="AndroidManifest"> |
| <!-- Required public name of the permission, which other components and |
| packages will use when referring to this permission. This is a string using |
| Java-style scoping to ensure it is unique. The prefix will often |
| be the same as our overall package name, for example |
| "com.mycompany.android.myapp.SomePermission". --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="permissionGroup" /> |
| <attr name="backgroundPermission" /> |
| <attr name="description" /> |
| <attr name="request" /> |
| <attr name="protectionLevel" /> |
| <attr name="permissionFlags" /> |
| </declare-styleable> |
| |
| <!-- The <code>permission-group</code> tag declares a logical grouping of |
| related permissions. |
| |
| <p>Note that this tag does not declare a permission itself, only |
| a namespace in which further permissions can be placed. See |
| the {@link #AndroidManifestPermission <permission>} tag for |
| more information. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestPermissionGroup" parent="AndroidManifest"> |
| <!-- Required public name of the permission group, permissions will use |
| to specify the group they are in. This is a string using |
| Java-style scoping to ensure it is unique. The prefix will often |
| be the same as our overall package name, for example |
| "com.mycompany.android.myapp.SomePermission". --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="description" /> |
| <attr name="request" /> |
| <attr name="requestDetail" /> |
| <attr name="backgroundRequest" /> |
| <attr name="backgroundRequestDetail" /> |
| <attr name="permissionGroupFlags" /> |
| <attr name="priority" /> |
| </declare-styleable> |
| |
| <!-- The <code>permission-tree</code> tag declares the base of a tree of |
| permission values: it declares that this package has ownership of |
| the given permission name, as well as all names underneath it |
| (separated by '.'). This allows you to use the |
| {@link android.content.pm.PackageManager#addPermission |
| PackageManager.addPermission()} method to dynamically add new |
| permissions under this tree. |
| |
| <p>Note that this tag does not declare a permission itself, only |
| a namespace in which further permissions can be placed. See |
| the {@link #AndroidManifestPermission <permission>} tag for |
| more information. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestPermissionTree" parent="AndroidManifest"> |
| <!-- Required public name of the permission tree, which is the base name |
| of all permissions under it. This is a string using |
| Java-style scoping to ensure it is unique. The prefix will often |
| be the same as our overall package name, for example |
| "com.mycompany.android.myapp.SomePermission". A permission tree name |
| must have more than two segments in its path; that is, |
| "com.me.foo" is okay, but not "com.me" or "com". --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-permission</code> tag requests a |
| {@link #AndroidManifestPermission <permission>} that the containing |
| package must be granted in order for it to operate correctly. For runtime |
| permissions, i.e. ones with <code>dangerous</code> protection level, on a |
| platform that supports runtime permissions, the permission will not be |
| granted until the app explicitly requests it at runtime and the user approves |
| the grant. You cannot request at runtime permissions that are not declared |
| as used in the manifest. See the |
| <a href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> |
| document for more information on permissions. Also available is a |
| {@link android.Manifest.permission list of permissions} included |
| with the base platform. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestUsesPermission" parent="AndroidManifest"> |
| <!-- Required name of the permission you use, as published with the |
| corresponding name attribute of a |
| {@link android.R.styleable#AndroidManifestPermission <permission>} |
| tag; often this is one of the {@link android.Manifest.permission standard |
| system permissions}. --> |
| <attr name="name" /> |
| <!-- Optional: specify the maximum version of the Android OS for which the |
| application wishes to request the permission. When running on a version |
| of Android higher than the number given here, the permission will not |
| be requested. --> |
| <attr name="maxSdkVersion" format="integer" /> |
| <!-- Optional: the system must support this feature for the permission to be |
| requested. If it doesn't support the feature, it will be as if the manifest didn't |
| request it at all. --> |
| <attr name="requiredFeature" format="string" /> |
| <!-- Optional: the system must NOT support this feature for the permission to be |
| requested. If it does support the feature, it will be as if the manifest didn't |
| request it at all. --> |
| <attr name="requiredNotFeature" format="string" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-configuration</code> tag specifies |
| a specific hardware configuration value used by the application. |
| For example an application might specify that it requires |
| a physical keyboard or a particular navigation method like |
| trackball. Multiple such attribute values can be specified by the |
| application. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. |
| |
| @deprecated Use <code>feature-group</code> instead.--> |
| <declare-styleable name="AndroidManifestUsesConfiguration" parent="AndroidManifest"> |
| <!-- The type of touch screen used by an application. --> |
| <attr name="reqTouchScreen" /> |
| <attr name="reqKeyboardType" /> |
| <attr name="reqHardKeyboard" /> |
| <attr name="reqNavigation" /> |
| <attr name="reqFiveWayNav" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-feature</code> tag specifies a specific device |
| hardware or software feature used by the application. For |
| example an application might specify that it requires |
| a camera. Multiple attribute values can be specified by the |
| application. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestUsesFeature" parent="AndroidManifest"> |
| <!-- The name of the feature that is being used. --> |
| <attr name="name" /> |
| <!-- The version of the feature that is being used. --> |
| <attr name="version" format="integer" /> |
| <!-- The GLES driver version number needed by an application. |
| The higher 16 bits represent the major number and the lower 16 bits |
| represent the minor number. For example for GL 1.2 referring to |
| 0x00000102, the actual value should be set as 0x00010002. --> |
| <attr name="glEsVersion" format="integer" /> |
| <!-- Specify whether this feature is required for the application. |
| The default is true, meaning the application requires the |
| feature, and does not want to be installed on devices that |
| don't support it. If you set this to false, then this will |
| not impose a restriction on where the application can be |
| installed. --> |
| <attr name="required" format="boolean" /> |
| </declare-styleable> |
| |
| <!-- The <code>feature-group</code> tag specifies |
| a set of one or more <code>uses-feature</code> elements that |
| the application can utilize. An application uses multiple |
| <code>feature-group</code> sets to indicate that it can support |
| different combinations of features. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestFeatureGroup"> |
| <!-- The human-readable name of the feature group. --> |
| <attr name="label" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-sdk</code> tag describes the SDK features that the |
| containing package must be running on to operate correctly. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestUsesSdk" parent="AndroidManifest"> |
| <!-- This is the minimum SDK version number that the application |
| requires. This number is an abstract integer, from the list |
| in {@link android.os.Build.VERSION_CODES} If |
| not supplied, the application will work on any SDK. This |
| may also be string (such as "Donut") if the application was built |
| against a development branch, in which case it will only work against |
| the development builds. --> |
| <attr name="minSdkVersion" format="integer|string" /> |
| <!-- This is the SDK version number that the application is targeting. |
| It is able to run on older versions (down to minSdkVersion), but |
| was explicitly tested to work with the version specified here. |
| Specifying this version allows the platform to disable compatibility |
| code that are not required or enable newer features that are not |
| available to older applications. This may also be a string |
| (such as "Donut") if this is built against a development |
| branch, in which case minSdkVersion is also forced to be that |
| string. --> |
| <attr name="targetSdkVersion" format="integer|string" /> |
| <!-- This is the maximum SDK version number that an application works |
| on. You can use this to ensure your application is filtered out |
| of later versions of the platform when you know you have |
| incompatibility with them. --> |
| <attr name="maxSdkVersion" /> |
| </declare-styleable> |
| |
| <!-- The <code>library</code> tag declares that this apk is providing itself |
| as a shared library for other applications to use. It can only be used |
| with apks that are built in to the system image. Other apks can link to |
| it with the {@link #AndroidManifestUsesLibrary uses-library} tag. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestLibrary" parent="AndroidManifest"> |
| <!-- Required public name of the library, which other components and |
| packages will use when referring to this library. This is a string using |
| Java-style scoping to ensure it is unique. The name should typically |
| be the same as the apk's package name. --> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| |
| <!-- The <code>static-library</code> tag declares that this apk is providing itself |
| as a static shared library for other applications to use. Any app can declare such |
| a library and there can be only one static shared library per package. These libraries |
| are updatable, multiple versions can be installed at the same time, and an app links |
| against a specific version simulating static linking while allowing code sharing. |
| Other apks can link to it with the {@link #AndroidManifestUsesLibrary uses-static-library} |
| tag. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestStaticLibrary" parent="AndroidManifestApplication"> |
| <!-- Required public name of the library, which other components and |
| packages will use when referring to this library. This is a string using |
| Java-style scoping to ensure it is unique. The name should typically |
| be the same as the apk's package name. --> |
| <attr name="name" /> |
| <!-- Required specific library version. --> |
| <attr name="version" /> |
| <!-- Required specific library major version code. This matches |
| android:versionCodeMajor of the library. --> |
| <!-- Required specific library version. --> |
| <attr name="versionMajor" format="integer" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-libraries</code> specifies a shared library that this |
| package requires to be linked against. Specifying this flag tells the |
| system to include this library's code in your class loader. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestUsesLibrary" parent="AndroidManifestApplication"> |
| <!-- Required name of the library you use. --> |
| <attr name="name" /> |
| <!-- Specify whether this library is required for the application. |
| The default is true, meaning the application requires the |
| library, and does not want to be installed on devices that |
| don't support it. If you set this to false, then this will |
| allow the application to be installed even if the library |
| doesn't exist, and you will need to check for its presence |
| dynamically at runtime. --> |
| <attr name="required" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-static-library</code> specifies a shared <strong>static</strong> |
| library that this package requires to be statically linked against. Specifying |
| this tag tells the system to include this library's code in your class loader. |
| Depending on a static shared library is equivalent to statically linking with |
| the library at build time while it offers apps to share code defined in such |
| libraries. Hence, static libraries are strictly required. |
| |
| <p>On devices running O MR1 or higher, if the library is singed with multiple |
| signing certificates you must to specify the SHA-256 hashes of the additional |
| certificates via adding |
| {@link #AndroidManifestAdditionalCertificate additional-certificate} tags. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestUsesStaticLibrary" parent="AndroidManifestApplication"> |
| <!-- Required name of the library you use. --> |
| <attr name="name" /> |
| <!-- Specify which version of the shared library should be statically linked. --> |
| <attr name="version" /> |
| <!-- The SHA-256 digest of the library signing certificate. --> |
| <attr name="certDigest" format="string" /> |
| </declare-styleable> |
| |
| <!-- The <code>additional-certificate</code> specifies the SHA-256 digest of a static |
| shared library's additional signing certificate. You need to use this tag if the |
| library is singed with more than one certificate. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestUsesStaticLibrary uses-static-library} or |
| {@link #AndroidManifestUsesPackage uses-package} tag. --> |
| <declare-styleable name="AndroidManifestAdditionalCertificate" parent="AndroidManifestUsesStaticLibrary"> |
| <!-- The SHA-256 digest of the library signing certificate. --> |
| <attr name="certDigest" /> |
| </declare-styleable> |
| |
| <!-- The <code>uses-package</code> specifies some kind of dependency on another |
| package. It does not have any impact on the app's execution on the device, |
| but provides information about dependencies it has on other packages that need |
| to be satisfied for it to run correctly. That is, this is primarily for |
| installers to know what other apps need to be installed along with this one. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestUsesPackage" parent="AndroidManifestApplication"> |
| <!-- Required type of association with the package, for example "android.package.ad_service" |
| if it provides an advertising service. This should use the standard scoped naming |
| convention as used for other things such as package names, based on the Java naming |
| convention. --> |
| <attr name="packageType" format="string" /> |
| <!-- Required name of the package you use. --> |
| <attr name="name" /> |
| <!-- Optional minimum version of the package that satisfies the dependency. --> |
| <attr name="version" /> |
| <!-- Optional minimum major version of the package that satisfies the dependency. --> |
| <attr name="versionMajor" format="integer" /> |
| <!-- Optional SHA-256 digest of the package signing certificate. --> |
| <attr name="certDigest" format="string" /> |
| </declare-styleable> |
| |
| <!-- The <code>supports-screens</code> specifies the screen dimensions an |
| application supports. By default a modern application supports all |
| screen sizes and must explicitly disable certain screen sizes here; |
| older applications are assumed to only support the traditional normal |
| (HVGA) screen size. Note that screen size is a separate axis from |
| density, and is determined as the available pixels to an application |
| after density scaling has been applied. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestSupportsScreens" parent="AndroidManifest"> |
| <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, |
| this is the new way to specify the minimum screen size an application is |
| compatible with. This attribute provides the required minimum |
| "smallest screen width" (as per the -swNNNdp resource configuration) |
| that the application can run on. For example, a typical phone |
| screen is 320, a 7" tablet 600, and a 10" tablet 720. If the |
| smallest screen width of the device is below the value supplied here, |
| then the application is considered incompatible with that device. |
| If not supplied, then any old smallScreens, normalScreens, largeScreens, |
| or xlargeScreens attributes will be used instead. --> |
| <attr name="requiresSmallestWidthDp" format="integer" /> |
| <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, |
| this is the new way to specify the largest screens an application is |
| compatible with. This attribute provides the maximum |
| "smallest screen width" (as per the -swNNNdp resource configuration) |
| that the application is designed for. If this value is smaller than |
| the "smallest screen width" of the device it is running on, the user |
| is offered to run it in a compatibility mode that emulates a |
| smaller screen and zooms it to fit the screen. Currently the compatibility mode only |
| emulates phone screens with a 320dp width, so compatibility mode is not applied if the |
| value for compatibleWidthLimitDp is larger than 320. --> |
| <attr name="compatibleWidthLimitDp" format="integer" /> |
| <!-- Starting with {@link android.os.Build.VERSION_CODES#HONEYCOMB_MR2}, |
| this is the new way to specify the screens an application is |
| compatible with. This attribute provides the maximum |
| "smallest screen width" (as per the -swNNNdp resource configuration) |
| that the application can work well on. If this value is smaller than |
| the "smallest screen width" of the device it is running on, the |
| application will be forced in to screen compatibility mode with |
| no way for the user to turn it off. Currently the compatibility mode only |
| emulates phone screens with a 320dp width, so compatibility mode is not applied if the |
| value for largestWidthLimitDp is larger than 320. --> |
| <attr name="largestWidthLimitDp" format="integer" /> |
| <!-- Indicates whether the application supports smaller screen form-factors. |
| A small screen is defined as one with a smaller aspect ratio than |
| the traditional HVGA screen; that is, for a portrait screen, less |
| tall than an HVGA screen. In practice, this means a QVGA low |
| density or VGA high density screen. An application that does |
| not support small screens <em>will not be available</em> for |
| small screen devices, since there is little the platform can do |
| to make such an application work on a smaller screen. --> |
| <attr name="smallScreens" format="boolean" /> |
| <!-- Indicates whether an application supports the normal screen |
| form-factors. Traditionally this is an HVGA normal density |
| screen, but WQVGA low density and WVGA high density are also |
| considered to be normal. This attribute is true by default, |
| and applications currently should leave it that way. --> |
| <attr name="normalScreens" format="boolean" /> |
| <!-- Indicates whether the application supports larger screen form-factors. |
| A large screen is defined as a screen that is significantly larger |
| than a normal phone screen, and thus may require some special care |
| on the application's part to make good use of it. An example would |
| be a VGA <em>normal density</em> screen, though even larger screens |
| are certainly possible. An application that does not support |
| large screens will be placed as a postage stamp on such a |
| screen, so that it retains the dimensions it was originally |
| designed for. --> |
| <attr name="largeScreens" format="boolean" /> |
| <!-- Indicates whether the application supports extra large screen form-factors. --> |
| <attr name="xlargeScreens" format="boolean" /> |
| <!-- Indicates whether the application can resize itself to newer |
| screen sizes. This is mostly used to distinguish between old |
| applications that may not be compatible with newly introduced |
| screen sizes and newer applications that should be; it will be |
| set for you automatically based on whether you are targeting |
| a newer platform that supports more screens. --> |
| <attr name="resizeable" format="boolean" /> |
| <!-- Indicates whether the application can accommodate any screen |
| density. Older applications are assumed to not be able to, |
| new ones able to. You can explicitly supply your abilities |
| here. --> |
| <attr name="anyDensity" format="boolean" /> |
| </declare-styleable> |
| |
| <!-- Private tag to declare system protected broadcast actions. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestProtectedBroadcast" parent="AndroidManifest"> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- Private tag to declare the original package name that this package is |
| based on. Only used for packages installed in the system image. If |
| given, and different than the actual package name, and the given |
| original package was previously installed on the device but the new |
| one was not, then the data for the old one will be renamed to be |
| for the new package. |
| |
| <p>This appears as a child tag of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestOriginalPackage" parent="AndroidManifest"> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- The <code>provider</code> tag declares a |
| {@link android.content.ContentProvider} class that is available |
| as part of the package's application components, supplying structured |
| access to data managed by the application. |
| |
| <p>This appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestProvider" parent="AndroidManifestApplication"> |
| <!-- Required name of the class implementing the provider, deriving from |
| {@link android.content.ContentProvider}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyProvider); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="description" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="process" /> |
| <attr name="authorities" /> |
| <attr name="syncable" /> |
| <attr name="readPermission" /> |
| <attr name="writePermission" /> |
| <attr name="grantUriPermissions" /> |
| <attr name="forceUriPermissions" /> |
| <attr name="permission" /> |
| <attr name="multiprocess" /> |
| <attr name="initOrder" /> |
| <!-- Specify whether this provider is enabled or not (that is, can be instantiated by the system). |
| It can also be specified for an application as a whole, in which case a value of "false" |
| will override any component specific values (a value of "true" will not override the |
| component specific values). --> |
| <attr name="enabled" /> |
| <attr name="exported" /> |
| <attr name="singleUser" /> |
| <attr name="directBootAware" /> |
| <attr name="visibleToInstantApps" /> |
| <!-- The code for this component is located in the given split. --> |
| <attr name="splitName" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>grant-uri-permission</code> tag, a child of the |
| {@link #AndroidManifestProvider provider} tag, describing a specific |
| URI path that can be granted as a permission. This tag can be |
| specified multiple time to supply multiple paths. --> |
| <declare-styleable name="AndroidManifestGrantUriPermission" parent="AndroidManifestProvider"> |
| <!-- Specify a URI path that must exactly match, as per |
| {@link android.os.PatternMatcher} with |
| {@link android.os.PatternMatcher#PATTERN_LITERAL}. --> |
| <attr name="path" format="string" /> |
| <!-- Specify a URI path that must be a prefix to match, as per |
| {@link android.os.PatternMatcher} with |
| {@link android.os.PatternMatcher#PATTERN_PREFIX}. --> |
| <attr name="pathPrefix" format="string" /> |
| <!-- Specify a URI path that matches a simple pattern, as per |
| {@link android.os.PatternMatcher} with |
| {@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB}. |
| Note that because '\' is used as an escape character when |
| reading the string from XML (before it is parsed as a pattern), |
| you will need to double-escape: for example a literal "*" would |
| be written as "\\*" and a literal "\" would be written as |
| "\\\\". This is basically the same as what you would need to |
| write if constructing the string in Java code. --> |
| <attr name="pathPattern" format="string" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>path-permission</code> tag, a child of the |
| {@link #AndroidManifestProvider provider} tag, describing a permission |
| that allows access to a specific path in the provider. This tag can be |
| specified multiple time to supply multiple paths. --> |
| <declare-styleable name="AndroidManifestPathPermission" parent="AndroidManifestProvider"> |
| <attr name="path" /> |
| <attr name="pathPrefix" /> |
| <attr name="pathPattern" /> |
| <attr name="pathAdvancedPattern" /> |
| <attr name="permission" /> |
| <attr name="readPermission" /> |
| <attr name="writePermission" /> |
| </declare-styleable> |
| |
| <!-- The <code>service</code> tag declares a |
| {@link android.app.Service} class that is available |
| as part of the package's application components, implementing |
| long-running background operations or a rich communication API |
| that can be called by other packages. |
| |
| <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} |
| tags can be included inside of a service, to specify the Intents |
| that can connect with it. If none are specified, the service can |
| only be accessed by direct specification of its class name. |
| The service tag appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestService" parent="AndroidManifestApplication"> |
| <!-- Required name of the class implementing the service, deriving from |
| {@link android.app.Service}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyService); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="description" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="permission" /> |
| <attr name="process" /> |
| <!-- Specify whether the service is enabled or not (that is, can be instantiated by the system). |
| It can also be specified for an application as a whole, in which case a value of "false" |
| will override any component specific values (a value of "true" will not override the |
| component specific values). --> |
| <attr name="enabled" /> |
| <attr name="exported" /> |
| <!-- If set to true, this service with be automatically stopped |
| when the user remove a task rooted in an activity owned by |
| the application. The default is false. --> |
| <attr name="stopWithTask" format="boolean" /> |
| <!-- If set to true, this service will run under a special process |
| that is isolated from the rest of the system. The only communication |
| with it is through the Service API (binding and starting). --> |
| <attr name="isolatedProcess" format="boolean" /> |
| <attr name="singleUser" /> |
| <attr name="directBootAware" /> |
| <!-- If the service is an {@link android.R.attr#isolatedProcess} service, this permits a |
| client to bind to the service as if it were running it its own package. The service |
| must also be {@link android.R.attr#exported} if this flag is set. --> |
| <attr name="externalService" format="boolean" /> |
| <attr name="visibleToInstantApps" /> |
| <!-- The code for this component is located in the given split. --> |
| <attr name="splitName" /> |
| <!-- If true, and this is an {@link android.R.attr#isolatedProcess} service, the service |
| will be spawned from an Application Zygote, instead of the regular Zygote. |
| <p> |
| The Application Zygote will first pre-initialize the application's class loader. Then, |
| if the application has defined the {@link android.R.attr#zygotePreloadName} attribute, |
| the Application Zygote will call into that class to allow it to perform |
| application-specific preloads (such as loading a shared library). Therefore, |
| spawning from the Application Zygote will typically reduce the service |
| launch time and reduce its memory usage. The downside of using this flag |
| is that you will have an additional process (the app zygote itself) that |
| is taking up memory. Whether actual memory usage is improved therefore strongly |
| depends on the number of isolated services that an application starts, |
| and how much memory those services save by preloading and sharing memory with |
| the app zygote. Therefore, it is recommended to measure memory usage under |
| typical workloads to determine whether it makes sense to use this flag. --> |
| <attr name="useAppZygote" format="boolean" /> |
| <!-- If this is a foreground service, specify its category. --> |
| <attr name="foregroundServiceType" /> |
| </declare-styleable> |
| |
| <!-- The <code>receiver</code> tag declares an |
| {@link android.content.BroadcastReceiver} class that is available |
| as part of the package's application components, allowing the |
| application to receive actions or data broadcast by other |
| applications even if it is not currently running. |
| |
| <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} |
| tags can be included inside of a receiver, to specify the Intents |
| it will receive. If none are specified, the receiver will only |
| be run when an Intent is broadcast that is directed at its specific |
| class name. The receiver tag appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestReceiver" parent="AndroidManifestApplication"> |
| <!-- Required name of the class implementing the receiver, deriving from |
| {@link android.content.BroadcastReceiver}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyReceiver); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <attr name="label" /> |
| <attr name="description" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="permission" /> |
| <attr name="process" /> |
| <!-- Specify whether the receiver is enabled or not (that is, can be instantiated by the system). |
| It can also be specified for an application as a whole, in which case a value of "false" |
| will override any component specific values (a value of "true" will not override the |
| component specific values). --> |
| <attr name="enabled" /> |
| <attr name="exported" /> |
| <attr name="singleUser" /> |
| <attr name="directBootAware" /> |
| </declare-styleable> |
| |
| <!-- The <code>activity</code> tag declares an |
| {@link android.app.Activity} class that is available |
| as part of the package's application components, implementing |
| a part of the application's user interface. |
| |
| <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} |
| tags can be included inside of an activity, to specify the Intents |
| that it can handle. If none are specified, the activity can |
| only be started through direct specification of its class name. |
| The activity tag appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestActivity" parent="AndroidManifestApplication"> |
| <!-- Required name of the class implementing the activity, deriving from |
| {@link android.app.Activity}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyActivity); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <attr name="theme" /> |
| <attr name="label" /> |
| <attr name="description" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="launchMode" /> |
| <attr name="screenOrientation" /> |
| <attr name="configChanges" /> |
| <attr name="recreateOnConfigChanges" /> |
| <attr name="permission" /> |
| <attr name="multiprocess" /> |
| <attr name="process" /> |
| <attr name="taskAffinity" /> |
| <attr name="allowTaskReparenting" /> |
| <attr name="finishOnTaskLaunch" /> |
| <attr name="finishOnCloseSystemDialogs" /> |
| <attr name="clearTaskOnLaunch" /> |
| <attr name="noHistory" /> |
| <attr name="alwaysRetainTaskState" /> |
| <attr name="stateNotNeeded" /> |
| <attr name="excludeFromRecents" /> |
| <!-- @deprecated use {@link android.R.attr#showForAllUsers} instead. --> |
| <attr name="showOnLockScreen" /> |
| <!-- Specify whether the activity is enabled or not (that is, can be instantiated by the system). |
| It can also be specified for an application as a whole, in which case a value of "false" |
| will override any component specific values (a value of "true" will not override the |
| component specific values). --> |
| <attr name="enabled" /> |
| <attr name="exported" /> |
| <!-- Specify the default soft-input mode for the main window of |
| this activity. A value besides "unspecified" here overrides |
| any value in the theme. --> |
| <attr name="windowSoftInputMode" /> |
| <attr name="immersive" /> |
| <attr name="hardwareAccelerated" /> |
| <attr name="uiOptions" /> |
| <attr name="parentActivityName" /> |
| <attr name="singleUser" /> |
| <!-- @hide This broadcast receiver or activity will only receive broadcasts for the |
| system user--> |
| <attr name="systemUserOnly" format="boolean" /> |
| <attr name="persistableMode" /> |
| <attr name="allowEmbedded" /> |
| <attr name="documentLaunchMode" /> |
| <attr name="maxRecents" /> |
| <attr name="autoRemoveFromRecents" /> |
| <attr name="relinquishTaskIdentity" /> |
| <attr name="resumeWhilePausing" /> |
| <attr name="resizeableActivity" /> |
| <attr name="supportsPictureInPicture" /> |
| <attr name="maxAspectRatio" /> |
| <attr name="minAspectRatio" /> |
| <attr name="lockTaskMode" /> |
| <attr name="showForAllUsers" /> |
| |
| <attr name="showWhenLocked" /> |
| <attr name="inheritShowWhenLocked" /> |
| <attr name="turnScreenOn" /> |
| |
| <attr name="directBootAware" /> |
| <!-- @hide This activity is always focusable regardless of if it is in a task/stack whose |
| activities are normally not focusable. |
| For example, {@link android.R.attr#supportsPictureInPicture} activities are placed |
| in a task/stack that isn't focusable. This flag allows them to be focusable.--> |
| <attr name="alwaysFocusable" format="boolean" /> |
| <attr name="enableVrMode" /> |
| <attr name="rotationAnimation" /> |
| <attr name="visibleToInstantApps" /> |
| <!-- The code for this component is located in the given split. --> |
| <attr name="splitName" /> |
| <!-- Specify the color mode the activity desires. The requested color mode may be ignored |
| depending on the capabilities of the display the activity is displayed on. --> |
| <attr name="colorMode"> |
| <!-- The default color mode (typically sRGB, low-dynamic range). --> |
| <enum name="default" value="0" /> |
| <!-- Wide color gamut color mode. --> |
| <enum name="wideColorGamut" value="1" /> |
| <!-- High dynamic range color mode. --> |
| <enum name="hdr" value="2" /> |
| </attr> |
| </declare-styleable> |
| |
| <!-- The <code>activity-alias</code> tag declares a new |
| name for an existing {@link #AndroidManifestActivity activity} |
| tag. |
| |
| <p>Zero or more {@link #AndroidManifestIntentFilter intent-filter} |
| tags can be included inside of an activity-alias, to specify the Intents |
| that it can handle. If none are specified, the activity can |
| only be started through direct specification of its class name. |
| The activity-alias tag appears as a child tag of the |
| {@link #AndroidManifestApplication application} tag. --> |
| <declare-styleable name="AndroidManifestActivityAlias" parent="AndroidManifestApplication"> |
| <!-- Required name of the class implementing the activity, deriving from |
| {@link android.app.Activity}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyActivity); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <!-- The name of the activity this alias should launch. The activity |
| must be in the same manifest as the alias, and have been defined |
| in that manifest before the alias here. This must use a Java-style |
| naming convention to ensure the name is unique, for example |
| "com.mycompany.MyName". --> |
| <attr name="targetActivity" format="string" /> |
| <attr name="label" /> |
| <attr name="description" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="permission" /> |
| <!-- Specify whether the activity-alias is enabled or not (that is, can be instantiated by the system). |
| It can also be specified for an application as a whole, in which case a value of "false" |
| will override any component specific values (a value of "true" will not override the |
| component specific values). --> |
| <attr name="enabled" /> |
| <attr name="exported" /> |
| <attr name="parentActivityName" /> |
| </declare-styleable> |
| |
| <!-- The <code>meta-data</code> tag is used to attach additional |
| arbitrary data to an application component. The data can later |
| be retrieved programmatically from the |
| {@link android.content.pm.ComponentInfo#metaData |
| ComponentInfo.metaData} field. There is no meaning given to this |
| data by the system. You may supply the data through either the |
| <code>value</code> or <code>resource</code> attribute; if both |
| are given, then <code>resource</code> will be used. |
| |
| <p>It is highly recommended that you avoid supplying related data as |
| multiple separate meta-data entries. Instead, if you have complex |
| data to associate with a component, then use the <code>resource</code> |
| attribute to assign an XML resource that the client can parse to |
| retrieve the complete data. --> |
| <declare-styleable name="AndroidManifestMetaData" |
| parent="AndroidManifestApplication |
| AndroidManifestActivity |
| AndroidManifestReceiver |
| AndroidManifestProvider |
| AndroidManifestService |
| AndroidManifestPermission |
| AndroidManifestPermissionGroup |
| AndroidManifestInstrumentation"> |
| <attr name="name" /> |
| <!-- Concrete value to assign to this piece of named meta-data. |
| The data can later be retrieved from the meta data Bundle |
| through {@link android.os.Bundle#getString Bundle.getString}, |
| {@link android.os.Bundle#getInt Bundle.getInt}, |
| {@link android.os.Bundle#getBoolean Bundle.getBoolean}, |
| or {@link android.os.Bundle#getFloat Bundle.getFloat} depending |
| on the type used here. --> |
| <attr name="value" format="string|integer|color|float|boolean" /> |
| <!-- Resource identifier to assign to this piece of named meta-data. |
| The resource identifier can later be retrieved from the meta data |
| Bundle through {@link android.os.Bundle#getInt Bundle.getInt}. --> |
| <attr name="resource" format="reference" /> |
| </declare-styleable> |
| |
| <!-- The <code>intent-filter</code> tag is used to construct an |
| {@link android.content.IntentFilter} object that will be used |
| to determine which component can handle a particular |
| {@link android.content.Intent} that has been given to the system. |
| It can be used as a child of the |
| {@link #AndroidManifestActivity activity}, |
| {@link #AndroidManifestReceiver receiver} and |
| {@link #AndroidManifestService service} |
| tags. |
| |
| <p> Zero or more {@link #AndroidManifestAction action}, |
| {@link #AndroidManifestCategory category}, and/or |
| {@link #AndroidManifestData data} tags should be |
| included inside to describe the contents of the filter. |
| |
| <p> The optional label and icon attributes here are used with |
| an activity to supply an alternative description of that activity |
| when it is being started through an Intent matching this filter. --> |
| <declare-styleable name="AndroidManifestIntentFilter" |
| parent="AndroidManifestActivity AndroidManifestReceiver AndroidManifestService"> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="priority" /> |
| <attr name="autoVerify" /> |
| <!-- Within an application, multiple intent filters may match a particular |
| intent. This allows the app author to specify the order filters should |
| be considered. We don't want to use priority because that is global |
| across applications. |
| <p>Only use if you really need to forcibly set the order in which |
| filters are evaluated. It is preferred to target an activity with a |
| directed intent instead. |
| <p>The value is a single integer, with higher numbers considered to |
| be better. If not specified, the default order is 0. --> |
| <attr name="order" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>action</code> tag, a child of the |
| {@link #AndroidManifestIntentFilter intent-filter} tag. |
| See {@link android.content.IntentFilter#addAction} for |
| more information. --> |
| <declare-styleable name="AndroidManifestAction" parent="AndroidManifestIntentFilter"> |
| <!-- The name of an action that is handled, using the Java-style |
| naming convention. For example, to support |
| {@link android.content.Intent#ACTION_VIEW Intent.ACTION_VIEW} |
| you would put <code>android.intent.action.VIEW</code> here. |
| Custom actions should generally use a prefix matching the |
| package name. --> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>data</code> tag, a child of the |
| {@link #AndroidManifestIntentFilter intent-filter} tag, describing |
| the types of data that match. This tag can be specified multiple |
| times to supply multiple data options, as described in the |
| {@link android.content.IntentFilter} class. Note that all such |
| tags are adding options to the same IntentFilter so that, for example, |
| <code><data android:scheme="myscheme" android:host="me.com" /></code> |
| is equivalent to <code><data android:scheme="myscheme" /> |
| <data android:host="me.com" /></code>. --> |
| <declare-styleable name="AndroidManifestData" parent="AndroidManifestIntentFilter"> |
| <!-- Specify a MIME type that is handled, as per |
| {@link android.content.IntentFilter#addDataType |
| IntentFilter.addDataType()}. |
| <p><em>Note: MIME type matching in the Android framework is |
| case-sensitive, unlike formal RFC MIME types. As a result, |
| MIME types here should always use lower case letters.</em></p> --> |
| <attr name="mimeType" format="string" /> |
| <!-- Specify a URI scheme that is handled, as per |
| {@link android.content.IntentFilter#addDataScheme |
| IntentFilter.addDataScheme()}. |
| <p><em>Note: scheme matching in the Android framework is |
| case-sensitive, unlike the formal RFC. As a result, |
| schemes here should always use lower case letters.</em></p> --> |
| <attr name="scheme" format="string" /> |
| <!-- Specify a URI scheme specific part that must exactly match, as per |
| {@link android.content.IntentFilter#addDataSchemeSpecificPart |
| IntentFilter.addDataSchemeSpecificPart()} with |
| {@link android.os.PatternMatcher#PATTERN_LITERAL}. --> |
| <attr name="ssp" format="string" /> |
| <!-- Specify a URI scheme specific part that must be a prefix to match, as per |
| {@link android.content.IntentFilter#addDataSchemeSpecificPart |
| IntentFilter.addDataSchemeSpecificPart()} with |
| {@link android.os.PatternMatcher#PATTERN_PREFIX}. --> |
| <attr name="sspPrefix" format="string" /> |
| <!-- Specify a URI scheme specific part that matches a simple pattern, as per |
| {@link android.content.IntentFilter#addDataSchemeSpecificPart |
| IntentFilter.addDataSchemeSpecificPart()} with |
| {@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB}. |
| Note that because '\' is used as an escape character when |
| reading the string from XML (before it is parsed as a pattern), |
| you will need to double-escape: for example a literal "*" would |
| be written as "\\*" and a literal "\" would be written as |
| "\\\\". This is basically the same as what you would need to |
| write if constructing the string in Java code. --> |
| <attr name="sspPattern" format="string" /> |
| <!-- Specify a URI authority host that is handled, as per |
| {@link android.content.IntentFilter#addDataAuthority |
| IntentFilter.addDataAuthority()}. |
| <p><em>Note: host name matching in the Android framework is |
| case-sensitive, unlike the formal RFC. As a result, |
| host names here should always use lower case letters.</em></p> --> |
| <attr name="host" format="string" /> |
| <!-- Specify a URI authority port that is handled, as per |
| {@link android.content.IntentFilter#addDataAuthority |
| IntentFilter.addDataAuthority()}. If a host is supplied |
| but not a port, any port is matched. --> |
| <attr name="port" format="string" /> |
| <!-- Specify a URI path that must exactly match, as per |
| {@link android.content.IntentFilter#addDataPath |
| IntentFilter.addDataPath()} with |
| {@link android.os.PatternMatcher#PATTERN_LITERAL}. --> |
| <attr name="path" /> |
| <!-- Specify a URI path that must be a prefix to match, as per |
| {@link android.content.IntentFilter#addDataPath |
| IntentFilter.addDataPath()} with |
| {@link android.os.PatternMatcher#PATTERN_PREFIX}. --> |
| <attr name="pathPrefix" /> |
| <!-- Specify a URI path that matches a simple pattern, as per |
| {@link android.content.IntentFilter#addDataPath |
| IntentFilter.addDataPath()} with |
| {@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB}. |
| Note that because '\' is used as an escape character when |
| reading the string from XML (before it is parsed as a pattern), |
| you will need to double-escape: for example a literal "*" would |
| be written as "\\*" and a literal "\" would be written as |
| "\\\\". This is basically the same as what you would need to |
| write if constructing the string in Java code. --> |
| <attr name="pathPattern" /> |
| <!-- Specify a URI path that matches an advanced pattern, as per |
| {@link android.content.IntentFilter#addDataPath |
| IntentFilter.addDataPath()} with |
| {@link android.os.PatternMatcher#PATTERN_ADVANCED_GLOB}. |
| Note that because '\' is used as an escape character when |
| reading the string from XML (before it is parsed as a pattern), |
| you will need to double-escape: for example a literal "*" would |
| be written as "\\*" and a literal "\" would be written as |
| "\\\\". This is basically the same as what you would need to |
| write if constructing the string in Java code. --> |
| <attr name="pathAdvancedPattern" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>category</code> tag, a child of the |
| {@link #AndroidManifestIntentFilter intent-filter} tag. |
| See {@link android.content.IntentFilter#addCategory} for |
| more information. --> |
| <declare-styleable name="AndroidManifestCategory" parent="AndroidManifestIntentFilter"> |
| <!-- The name of category that is handled, using the Java-style |
| naming convention. For example, to support |
| {@link android.content.Intent#CATEGORY_LAUNCHER Intent.CATEGORY_LAUNCHER} |
| you would put <code>android.intent.category.LAUNCHER</code> here. |
| Custom actions should generally use a prefix matching the |
| package name. --> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>instrumentation</code> tag, a child of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestInstrumentation" parent="AndroidManifest"> |
| <!-- Required name of the class implementing the instrumentation, deriving from |
| {@link android.app.Instrumentation}. This is a fully |
| qualified class name (for example, com.mycompany.myapp.MyActivity); as a |
| short-hand if the first character of the class |
| is a period then it is appended to your package name. --> |
| <attr name="name" /> |
| <attr name="targetPackage" /> |
| <attr name="targetProcesses" /> |
| <attr name="label" /> |
| <attr name="icon" /> |
| <attr name="roundIcon" /> |
| <attr name="banner" /> |
| <attr name="logo" /> |
| <attr name="handleProfiling" /> |
| <attr name="functionalTest" /> |
| </declare-styleable> |
| |
| <!-- Attributes that can be supplied in an AndroidManifest.xml |
| <code>screen</code> tag, a child of <code>compatible-screens</code>, |
| which is itself a child of the root |
| {@link #AndroidManifest manifest} tag. --> |
| <declare-styleable name="AndroidManifestCompatibleScreensScreen" |
| parent="AndroidManifest.AndroidManifestCompatibleScreens"> |
| <!-- Specifies a compatible screen size, as per the device |
| configuration screen size bins. --> |
| <attr name="screenSize"> |
| <!-- A small screen configuration, at least 240x320dp. --> |
| <enum name="small" value="200" /> |
| <!-- A normal screen configuration, at least 320x480dp. --> |
| <enum name="normal" value="300" /> |
| <!-- A large screen configuration, at least 400x530dp. --> |
| <enum name="large" value="400" /> |
| <!-- An extra large screen configuration, at least 600x800dp. --> |
| <enum name="xlarge" value="500" /> |
| </attr> |
| <!-- Specifies a compatible screen density, as per the device |
| configuration screen density bins. --> |
| <attr name="screenDensity" format="integer"> |
| <!-- A low density screen, approximately 120dpi. --> |
| <enum name="ldpi" value="120" /> |
| <!-- A medium density screen, approximately 160dpi. --> |
| <enum name="mdpi" value="160" /> |
| <!-- A high density screen, approximately 240dpi. --> |
| <enum name="hdpi" value="240" /> |
| <!-- An extra high density screen, approximately 320dpi. --> |
| <enum name="xhdpi" value="320" /> |
| <!-- An extra extra high density screen, approximately 480dpi. --> |
| <enum name="xxhdpi" value="480" /> |
| <!-- An extra extra extra high density screen, approximately 640dpi. --> |
| <enum name="xxxhdpi" value="640" /> |
| </attr> |
| </declare-styleable> |
| |
| <!-- The <code>input-type</code> tag is a child of the <code>supports-input</code> tag, which |
| is itself a child of the root {@link #AndroidManifest manifest} tag. Each |
| <code>input-type</code> tag specifices the name of a specific input device type. When |
| grouped with the other elements of the parent <code>supports-input</code> tag it defines |
| a collection of input devices, which when all used together, are considered a supported |
| input mechanism for the application. There may be multiple <code>supports-input</code> |
| tags defined, each containing a different combination of input device types. --> |
| <declare-styleable name="AndroidManifestSupportsInputInputType" |
| parent="AndroidManifest.AndroidManifestSupportsInput"> |
| <!-- Specifices the name of the input device type --> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- The attribute that holds a Base64-encoded public key. --> |
| <attr name="publicKey" format="string" /> |
| |
| <!-- Attributes relating to a package verifier. --> |
| <declare-styleable name="AndroidManifestPackageVerifier" parent="AndroidManifest"> |
| <!-- Specifies the Java-style package name that defines this |
| package verifier. --> |
| <attr name="name" /> |
| |
| <!-- The Base64 encoded public key of the package verifier's |
| signature. --> |
| <attr name="publicKey" /> |
| </declare-styleable> |
| |
| <!-- Attributes relating to resource overlay packages. --> |
| <declare-styleable name="AndroidManifestResourceOverlay" parent="AndroidManifest"> |
| <!-- Package name of base package whose resources will be overlaid. --> |
| <attr name="targetPackage" /> |
| |
| <!-- Category of the resource overlay. --> |
| <attr name="category" format="string"/> |
| |
| <!-- Load order of overlay package. --> |
| <attr name="priority" /> |
| |
| <!-- Whether the given RRO is static or not. --> |
| <attr name="isStatic" format="boolean" /> |
| |
| <!-- Required property name/value pair used to enable this overlay. |
| e.g. name=ro.oem.sku value=MKT210. |
| Overlay will be ignored unless system property exists and is |
| set to specified value --> |
| <!-- @hide This shouldn't be public. --> |
| <attr name="requiredSystemPropertyName" format="string" /> |
| <!-- @hide This shouldn't be public. --> |
| <attr name="requiredSystemPropertyValue" format="string" /> |
| |
| <!-- The name of the overlayable whose resources will be overlaid. --> |
| <attr name="targetName" /> |
| </declare-styleable> |
| |
| <!-- Declaration of an {@link android.content.Intent} object in XML. May |
| also include zero or more {@link #IntentCategory <category>} and |
| {@link #Extra <extra>} tags. --> |
| <declare-styleable name="Intent"> |
| <!-- The action name to assign to the Intent, as per |
| {@link android.content.Intent#setAction Intent.setAction()}. --> |
| <attr name="action" format="string" /> |
| <!-- The data URI to assign to the Intent, as per |
| {@link android.content.Intent#setData Intent.setData()}. |
| <p><em>Note: scheme and host name matching in the Android framework is |
| case-sensitive, unlike the formal RFC. As a result, |
| URIs here should always be normalized to use lower case letters |
| for these elements (as well as other proper Uri normalization).</em></p> --> |
| <attr name="data" format="string" /> |
| <!-- The MIME type name to assign to the Intent, as per |
| {@link android.content.Intent#setType Intent.setType()}. |
| <p><em>Note: MIME type matching in the Android framework is |
| case-sensitive, unlike formal RFC MIME types. As a result, |
| MIME types here should always use lower case letters.</em></p> --> |
| <attr name="mimeType" /> |
| <!-- The package part of the ComponentName to assign to the Intent, as per |
| {@link android.content.Intent#setComponent Intent.setComponent()}. --> |
| <attr name="targetPackage" /> |
| <!-- The class part of the ComponentName to assign to the Intent, as per |
| {@link android.content.Intent#setComponent Intent.setComponent()}. --> |
| <attr name="targetClass" format="string" /> |
| </declare-styleable> |
| |
| <!-- A category to add to an Intent, as per |
| {@link android.content.Intent#addCategory Intent.addCategory()}. --> |
| <declare-styleable name="IntentCategory" parent="Intent"> |
| <!-- Required name of the category. --> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- An extra data value to place into a an extra/name value pair held |
| in a Bundle, as per {@link android.os.Bundle}. --> |
| <declare-styleable name="Extra" parent="Intent"> |
| <!-- Required name of the extra data. --> |
| <attr name="name" /> |
| <!-- Concrete value to put for this named extra data. --> |
| <attr name="value" /> |
| </declare-styleable> |
| |
| <!-- Groups signing keys into a {@code KeySet} for easier reference in |
| other APIs. However, currently no APIs use this. --> |
| <attr name="keySet" /> |
| <declare-styleable name="AndroidManifestPublicKey"> |
| <attr name="name" /> |
| <attr name="value" /> |
| </declare-styleable> |
| <declare-styleable name="AndroidManifestKeySet"> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- Associate declared KeySets with upgrading capability. --> |
| <declare-styleable name="AndroidManifestUpgradeKeySet" parent="AndroidManifest"> |
| <attr name="name" /> |
| </declare-styleable> |
| |
| <!-- <code>layout</code> tag allows configuring the layout for the activity within multi-window |
| environment. --> |
| <declare-styleable name="AndroidManifestLayout" parent="AndroidManifestActivity"> |
| <!-- Default width of the activity. Can be either a fixed value or fraction, in which case |
| the width will be constructed as a fraction of the total available width. --> |
| <attr name="defaultWidth" format="dimension|fraction" /> |
| <!-- Default height of the activity. Can be either a fixed value or fraction, in which case |
| the height will be constructed as a fraction of the total available height. --> |
| <attr name="defaultHeight" format="dimension|fraction" /> |
| <!-- Where to initially position the activity inside the available space. Uses constants |
| defined in {@link android.view.Gravity}. --> |
| <attr name="gravity" /> |
| <!-- Minimal width of the activity. |
| |
| <p><strong>NOTE:</strong> A task's root activity value is applied to all additional |
| activities launched in the task. That is if the root activity of a task set minimal width, |
| then the system will set the same minimal width on all other activities in the task. It |
| will also ignore any other minimal width attributes of non-root activities. --> |
| <attr name="minWidth" /> |
| <!-- Minimal height of the activity. |
| |
| <p><strong>NOTE:</strong> A task's root activity value is applied to all additional |
| activities launched in the task. That is if the root activity of a task set minimal height, |
| then the system will set the same minimal height on all other activities in the task. It |
| will also ignore any other minimal height attributes of non-root activities. --> |
| <attr name="minHeight" /> |
| </declare-styleable> |
| |
| <!-- <code>restrict-update</code> tag restricts system apps from being updated unless the |
| SHA-512 hash equals the specified value. |
| @hide --> |
| <declare-styleable name="AndroidManifestRestrictUpdate" parent="AndroidManifest"> |
| <!-- The SHA-512 hash of the only APK that can be used to update a package. |
| <p>NOTE: This is only applicable to system packages. |
| @hide --> |
| <attr name="hash" format="string" /> |
| </declare-styleable> |
| |
| <declare-styleable name="AndroidManifestUsesSplit" parent="AndroidManifest"> |
| <attr name="name" format="string" /> |
| </declare-styleable> |
| |
| |
| <declare-styleable name="AndroidManifestProfileable" parent="AndroidManifestApplication"> |
| <!-- Flag indicating whether the application can be profiled by the shell user, |
| even when running on a device that is running in user mode. --> |
| <attr name="shell" format="boolean" /> |
| </declare-styleable> |
| </resources> |