LabeledIntent

Broadcast Action: The user has switched the phone into or out of Airplane Mode. One or more radios have been turned off or on. The intent will have the following extra value:

• state - A boolean value indicating whether Airplane Mode is on. If true, then cell radio and possibly other radios such as bluetooth or WiFi may have also been turned off

This is a protected intent that can only be sent by the system.

Activity Action: List all available applications.

Input: Nothing.

Output: nothing.

Activity Action: Handle an incoming phone call.

Input: nothing.

Output: nothing.

Broadcast Action: Locale of a particular app has changed.

This broadcast is explicitly sent to the android.content.pm.InstallSourceInfo#getInstallingPackageName installer of the app whose locale has changed.

The broadcast could also be received by manifest-declared receivers with android.permission.READ_APP_SPECIFIC_LOCALES

This is a protected intent that can only be sent by the system.

Includes the following extras:

• EXTRA_PACKAGE_NAME is the name of the package for which locale changed.
• EXTRA_LOCALE_LIST contains locales that are currently set for specified app

An activity that provides a user interface for adjusting application preferences. Optional but recommended settings for all applications which have settings.

Broadcast Action: Sent after application restrictions are changed.

This is a protected intent that can only be sent by the system.

Activity Action: The user pressed the "Report" button in the crash/ANR dialog. This intent is delivered to the package which installed the application, usually Google Play.

Input: No data is specified. The bug report is passed in using an EXTRA_BUG_REPORT field.

Output: Nothing.

Activity Action: Perform assist action.

Input: EXTRA_ASSIST_PACKAGE, EXTRA_ASSIST_CONTEXT, can provide additional optional contextual information about where the user was when they requested the assist; EXTRA_REFERRER may be set with additional referrer information. Output: nothing.

Used to indicate that some piece of data should be attached to some other place. For example, image data could be attached to a contact. It is up to the recipient to decide where the data should be attached; the intent does not specify the ultimate destination.

Input: getData is URI of data to be attached.

Output: nothing.

Activity action: Launch UI to manage auto-revoke state. This is equivalent to Intent#ACTION_APPLICATION_DETAILS_SETTINGS

Input: data should be a package-scheme Uri with a package name, whose auto-revoke state will be reviewed (mandatory). E.g. Uri.fromParts("package", packageName, null)

Output: Nothing.

Broadcast Action: This is a sticky broadcast containing the charging state, level, and other information about the battery. See android.os.BatteryManager for documentation on the contents of the Intent.

You cannot receive this through components declared in manifests, only by explicitly registering for it with Context.registerReceiver(). See ACTION_BATTERY_LOW, ACTION_BATTERY_OKAY, ACTION_POWER_CONNECTED, and ACTION_POWER_DISCONNECTED for distinct battery-related broadcasts that are sent and can be received through manifest receivers.

This is a protected intent that can only be sent by the system.

Broadcast Action: Indicates low battery condition on the device. This broadcast corresponds to the "Low battery warning" system dialog.

This is a protected intent that can only be sent by the system.

Broadcast Action: Indicates the battery is now okay after being low. This will be sent after ACTION_BATTERY_LOW once the battery has gone back up to an okay state.

This is a protected intent that can only be sent by the system.

Broadcast Action: This is broadcast once, after the user has finished booting. It can be used to perform application-specific initialization, such as installing alarms. You must hold the android.Manifest.permission#RECEIVE_BOOT_COMPLETED permission in order to receive this broadcast.

This broadcast is sent at boot by all devices (both with and without direct boot support). Upon receipt of this broadcast, the user is unlocked and both device-protected and credential-protected storage can accessed safely.

If you need to run while the user is still locked (before they've entered their lock pattern or PIN for the first time), you can listen for the ACTION_LOCKED_BOOT_COMPLETED broadcast.

This is a protected intent that can only be sent by the system.

Activity Action: Show activity for reporting a bug.

Input: Nothing.

Output: Nothing.

Activity Action: Perform a call to someone specified by the data.

Input: If nothing, an empty dialer is started; else getData is URI of a phone number to be dialed or a tel: URI of an explicit phone number.

Output: nothing.

Note: there will be restrictions on which applications can initiate a call; most applications should use the ACTION_DIAL.

Note: this Intent cannot be used to call emergency numbers. Applications can dial emergency numbers using ACTION_DIAL, however.

Note: This Intent can only be used to dial call forwarding MMI codes if the application using this intent is set as the default or system dialer. The system will treat any other application using this Intent for the purpose of dialing call forwarding MMI codes as if the ACTION_DIAL Intent was used instead.

Note: An app filling the android.app.role.RoleManager#ROLE_DIALER role should use android.telecom.TelecomManager#placeCall(Uri, Bundle) to place calls rather than relying on this intent.

Note: if you app targets M and above and declares as using the android.Manifest.permission#CALL_PHONE permission which is not granted, then attempting to use this action will result in a java.lang.SecurityException.

Activity Action: The user pressed the "call" button to go to the dialer or other appropriate UI for placing a call.

Input: Nothing.

Output: Nothing.

Broadcast Action: The "Camera Button" was pressed. Includes a single extra field, EXTRA_KEY_EVENT, containing the key event that caused the broadcast.

Activity Action: Main entry point for carrier setup apps.

Carrier apps that provide an implementation for this action may be invoked to configure carrier service and typically require carrier privileges to fulfill their duties.

Activity Action: Display an activity chooser, allowing the user to pick what they want to before proceeding. This can be used as an alternative to the standard activity picker that is displayed by the system when you try to start an activity with multiple possible matches, with these differences in behavior:

• You can specify the title that will appear in the activity chooser.
• The user does not have the option to make one of the matching activities a preferred activity, and all possible activities will always be shown even if one of them is currently marked as the preferred activity.

This action should be used when the user will naturally expect to select an activity in order to proceed. An example if when not to use it is when the user clicks on a "mailto:" link. They would naturally expect to go directly to their mail app, so startActivity() should be called directly: it will either launch the current preferred app, or put up a dialog allowing the user to pick an app to use and optionally marking that as preferred.

In contrast, if the user is selecting a menu item to send a picture they are viewing to someone else, there are many different things they may want to do at this point: send it through e-mail, upload it to a web service, etc. In this case the CHOOSER action should be used, to always present to the user a list of the things they can do, with a nice title given by the caller such as "Send this photo with:".

If you need to grant URI permissions through a chooser, you must specify the permissions to be granted on the ACTION_CHOOSER Intent in addition to the EXTRA_INTENT inside. This means using setClipData to specify the URIs to be granted as well as FLAG_GRANT_READ_URI_PERMISSION and/or FLAG_GRANT_WRITE_URI_PERMISSION as appropriate.

As a convenience, an Intent of this form can be created with the #createChooser function.

Input: No data should be specified. get*Extra must have a EXTRA_INTENT field containing the Intent being executed, and can optionally have a EXTRA_TITLE field containing the title text to display in the chooser.

Output: Depends on the protocol of EXTRA_INTENT.

Broadcast Action: This is broadcast when a user action should request a temporary system dialog to dismiss. Some examples of temporary system dialogs are the notification window-shade and the recent tasks dialog.
Requires android.Manifest.permission.BROADCAST_CLOSE_SYSTEM_DIALOGS

Broadcast Action: The current device android.content.res.Configuration (orientation, locale, etc) has changed. When such a change happens, the UIs (view hierarchy) will need to be rebuilt based on this new information; for the most part, applications don't need to worry about this, because the system will take care of stopping and restarting the application to make sure it sees the new changes. Some system code that can not be restarted will need to watch for this action and handle it appropriately.

You cannot receive this through components declared in manifests, only by explicitly registering for it with Context.registerReceiver().

This is a protected intent that can only be sent by the system.

Activity Action: Allow the user to create a new document. When invoked, the system will display the various DocumentsProvider instances installed on the device, letting the user navigate through them. The returned document may be a newly created document with no content, or it may be an existing document with the requested MIME type.

Each document is represented as a content:// URI backed by a DocumentsProvider, which can be opened as a stream with ContentResolver#openFileDescriptor(Uri, String), or queried for android.provider.DocumentsContract.Document metadata.

Callers must indicate the concrete MIME type of the document being created by setting setType(java.lang.String). This MIME type cannot be changed after the document is created.

Callers can provide an initial display name through EXTRA_TITLE, but the user may change this value before creating the file.

Callers must include CATEGORY_OPENABLE in the Intent to obtain URIs that can be opened with ContentResolver#openFileDescriptor(Uri, String).

Callers can set a document URI through DocumentsContract#EXTRA_INITIAL_URI to indicate the initial location of documents navigator. System will do its best to launch the navigator in the specified document if it's a folder, or the folder that contains the specified document if not.

Output: The URI of the item that was created. This must be a content:// URI so that any receiver can access it.

Activity Action: Starts a note-taking activity that can be used to create a note. This action can be used to start an activity on the lock screen. Activity should ensure to appropriately handle privacy sensitive data and features when launched on the lock screen. See android.app.KeyguardManager for lock screen checks.

Activity Action: Creates a reminder.

Input: EXTRA_TITLE The title of the reminder that will be shown to the user. EXTRA_TEXT The reminder text that will be shown to the user. The intent should at least specify a title or a text. EXTRA_TIME The time when the reminder will be shown to the user. The time is specified in milliseconds since the Epoch (optional).

Output: Nothing.

Activity Action: Creates a shortcut.

Input: Nothing.

Output: An Intent representing the android.content.pm.ShortcutInfo result.

For compatibility with older versions of android the intent may also contain three extras: SHORTCUT_INTENT (value: Intent), SHORTCUT_NAME (value: String), and SHORTCUT_ICON (value: Bitmap) or SHORTCUT_ICON_RESOURCE (value: ShortcutIconResource).

Broadcast Action: The date has changed.

A synonym for ACTION_VIEW, the "standard" action that is performed on a piece of data.

Activity Action: Define the meaning of the selected word(s).

Input: getCharSequence(EXTRA_TEXT) is the text to define.

Output: nothing.

Activity Action: Delete the given data from its container.

Input: getData is URI of data to be deleted.

Output: nothing.

Broadcast Action: A sticky broadcast that indicates low storage space condition on the device

This is a protected intent that can only be sent by the system.

Broadcast Action: Indicates low storage space condition on the device no longer exists

This is a protected intent that can only be sent by the system.

Activity Action: Dial a number as specified by the data. This shows a UI with the number being dialed, allowing the user to explicitly initiate the call.

Input: If nothing, an empty dialer is started; else getData is URI of a phone number to be dialed or a tel: URI of an explicit phone number.

Output: nothing.

Broadcast Action: A sticky broadcast for changes in the physical docking state of the device.

The intent will have the following extra values:

• EXTRA_DOCK_STATE - the current dock state, indicating which dock the device is physically in.

This is intended for monitoring the current physical dock state. See android.app.UiModeManager for the normal API dealing with dock mode changes.

Broadcast Action: Sent after the system starts dreaming.

This is a protected intent that can only be sent by the system. It is only sent to registered receivers.

Broadcast Action: Sent after the system stops dreaming.

This is a protected intent that can only be sent by the system. It is only sent to registered receivers.

Activity Action: Provide explicit editable access to the given data.

Input: getData is URI of data to be edited.

Output: nothing.

Broadcast Action: Resources for a set of packages (which were previously unavailable) are currently available since the media on which they exist is available. The extra data EXTRA_CHANGED_PACKAGE_LIST contains a list of packages whose availability changed. The extra data EXTRA_CHANGED_UID_LIST contains a list of uids of packages whose availability changed. Note that the packages in this list do not receive this broadcast. The specified set of packages are now available on the system.

Includes the following extras:

• EXTRA_CHANGED_PACKAGE_LIST is the set of packages whose resources(were previously unavailable) are currently available. EXTRA_CHANGED_UID_LIST is the set of uids of the packages whose resources(were previously unavailable) are currently available.

This is a protected intent that can only be sent by the system.

Broadcast Action: Resources for a set of packages are currently unavailable since the media on which they exist is unavailable. The extra data EXTRA_CHANGED_PACKAGE_LIST contains a list of packages whose availability changed. The extra data EXTRA_CHANGED_UID_LIST contains a list of uids of packages whose availability changed. The specified set of packages can no longer be launched and are practically unavailable on the system.

Inclues the following extras:

• EXTRA_CHANGED_PACKAGE_LIST is the set of packages whose resources are no longer available. EXTRA_CHANGED_UID_LIST is the set of packages whose resources are no longer available.

This is a protected intent that can only be sent by the system.

Activity Action: Main entry point for factory tests. Only used when the device is booting in factory test node. The implementing package must be installed in the system image.

Input: nothing

Output: nothing

Activity Action: Allow the user to select a particular kind of data and return it. This is different than ACTION_PICK in that here we just say what kind of data is desired, not a URI of existing data from which the user can pick. An ACTION_GET_CONTENT could allow the user to create the data as it runs (for example taking a picture or recording a sound), let them browse over the web and download the desired data, etc.

There are two main ways to use this action: if you want a specific kind of data, such as a person contact, you set the MIME type to the kind of data you want and launch it with Context#startActivity(Intent). The system will then launch the best application to select that kind of data for you.

You may also be interested in any of a set of types of content the user can pick. For example, an e-mail application that wants to allow the user to add an attachment to an e-mail message can use this action to bring up a list of all of the types of content the user can attach.

In this case, you should wrap the GET_CONTENT intent with a chooser (through #createChooser), which will give the proper interface for the user to pick how to send your data and allow you to specify a prompt indicating what they are doing. You will usually specify a broad MIME type (such as image/* or */*), resulting in a broad range of content types the user can select from.

When using such a broad GET_CONTENT action, it is often desirable to only pick from data that can be represented as a stream. This is accomplished by requiring the CATEGORY_OPENABLE in the Intent.

Callers can optionally specify EXTRA_LOCAL_ONLY to request that the launched content chooser only returns results representing data that is locally available on the device. For example, if this extra is set to true then an image picker should not show any pictures that are available from a remote server but not already on the local device (thus requiring they be downloaded when opened).

If the caller can handle multiple returned items (the user performing multiple selection), then it can specify EXTRA_ALLOW_MULTIPLE to indicate this.

Input: getType is the desired MIME type to retrieve. Note that no URI is supplied in the intent, as there are no constraints on where the returned data originally comes from. You may also include the CATEGORY_OPENABLE if you can only accept data that can be opened as a stream. You may use EXTRA_LOCAL_ONLY to limit content selection to local data. You may use EXTRA_ALLOW_MULTIPLE to allow the user to select multiple items.

Output: The URI of the item that was picked. This must be a content: URI so that any receiver can access it.

Broadcast to a specific application to query any supported restrictions to impose on restricted users. The broadcast intent contains an extra with the currently persisted restrictions as a Bundle of key/value pairs. The value types can be Boolean, String or String[] depending on the restriction type.

Broadcast Action: A GTalk connection has been established.

Broadcast Action: A GTalk connection has been disconnected.

Broadcast Action: Wired Headset plugged in or unplugged. Same as android.media.AudioManager#ACTION_HEADSET_PLUG, to be consulted for value and documentation.

If the minimum SDK version of your application is android.os.Build.VERSION_CODES#LOLLIPOP, it is recommended to refer to the AudioManager constant in your receiver registration code instead.

Broadcast Action: An input method has been changed.

Activity Action: Insert an empty item into the given container.

Input: getData is URI of the directory (vnd.android.cursor.dir/*) in which to place the data.

Output: URI of the new data that was created.

Activity Action: Pick an existing item, or insert a new item, and then edit it.

Input: getType is the desired MIME type of the item to create or edit. The extras can contain type specific data to pass through to the editing/creating activity.

Output: The URI of the item that was picked. This must be a content: URI so that any receiver can access it.

Activity Action: Activity to handle split installation failures.

Splits may be installed dynamically. This happens when an Activity is launched, but the split that contains the application isn't installed. When a split is installed in this manner, the containing package usually doesn't know this is happening. However, if an error occurs during installation, the containing package can define a single activity handling this action to deal with such failures.

The activity handling this action must be in the base package.

Input: EXTRA_INTENT the original intent that started split installation. EXTRA_SPLIT_NAME the name of the split that failed to be installed.

Activity Action: Launch application installer.

Input: The data must be a content: URI at which the application can be retrieved. As of android.os.Build.VERSION_CODES#JELLY_BEAN_MR1, you can also use "package:" to install an application for the current user that is already installed for another user. You can optionally supply EXTRA_INSTALLER_PACKAGE_NAME, EXTRA_NOT_UNKNOWN_SOURCE, EXTRA_ALLOW_REPLACE, and EXTRA_RETURN_RESULT.

Output: If EXTRA_RETURN_RESULT, returns whether the install succeeded.

Note:If your app is targeting API level higher than 25 you need to hold android.Manifest.permission#REQUEST_INSTALL_PACKAGES in order to launch the application installer.

Activity Action: Use with startActivityForResult to start a system activity that captures content on the screen to take a screenshot and present it to the user for editing. The edited screenshot is saved on device and returned to the calling activity as a Uri through getData(). User interaction is required to return the edited screenshot to the calling activity.

This intent action requires the permission android.Manifest.permission#LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE.

Callers should query StatusBarManager#canLaunchCaptureContentActivityForNote(Activity) before showing a UI element that allows users to trigger this flow.
Requires android.Manifest.permission#LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE

Broadcast Action: The receiver's effective locale has changed. This happens when the device locale, the receiving app's locale (set via android.app.LocaleManager#setApplicationLocales) or language tags of Regional preferences changed. Can be received by manifest-declared receivers.

If only the app locale changed, includes the following extras:

• EXTRA_PACKAGE_NAME is the name of the package for which locale changed.
• EXTRA_LOCALE_LIST contains locales that are currently set for specified app

This is a protected intent that can only be sent by the system.

Broadcast Action: This is broadcast once, after the user has finished booting, but while still in the "locked" state. It can be used to perform application-specific initialization, such as installing alarms. You must hold the android.Manifest.permission#RECEIVE_BOOT_COMPLETED permission in order to receive this broadcast.

This broadcast is sent immediately at boot by all devices (regardless of direct boot support) running android.os.Build.VERSION_CODES#N or higher. Upon receipt of this broadcast, the user is still locked and only device-protected storage can be accessed safely. If you want to access credential-protected storage, you need to wait for the user to be unlocked (typically by entering their lock pattern or PIN for the first time), after which the ACTION_USER_UNLOCKED and ACTION_BOOT_COMPLETED broadcasts are sent.

To receive this broadcast, your receiver component must be marked as being ComponentInfo#directBootAware.

This is a protected intent that can only be sent by the system.

Activity Action: Start as a main entry point, does not expect to receive data.

Input: nothing

Output: nothing

Broadcast sent to the primary user when an associated managed profile is added (the profile was created and is ready to be used). Carries an extra EXTRA_USER that specifies the UserHandle of the profile that was added. Only applications (for example Launchers) that need to display merged content across both primary and managed profiles need to worry about this broadcast. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the primary user when an associated managed profile has become available. Currently this includes when the user disables quiet mode for the profile. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. When quiet mode is changed, this broadcast will carry a boolean extra EXTRA_QUIET_MODE indicating the new state of quiet mode. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the primary user when an associated managed profile is removed. Carries an extra EXTRA_USER that specifies the UserHandle of the profile that was removed. Only applications (for example Launchers) that need to display merged content across both primary and managed profiles need to worry about this broadcast. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the primary user when an associated managed profile has become unavailable. Currently this includes when the user enables quiet mode for the profile. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. When quiet mode is changed, this broadcast will carry a boolean extra EXTRA_QUIET_MODE indicating the new state of quiet mode. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the primary user when the credential-encrypted private storage for an associated managed profile is unlocked. Carries an extra EXTRA_USER that specifies the UserHandle of the profile that was unlocked. Only applications (for example Launchers) that need to display merged content across both primary and managed profiles need to worry about this broadcast. This is only sent to registered receivers, not manifest receivers.

Activity Action: Show settings for managing network data usage of a specific application. Applications should define an activity that offers options to control data usage.

Broadcast Action: Indicates low memory condition notification acknowledged by user and package management should be started. This is triggered by the user from the ACTION_DEVICE_STORAGE_LOW notification.

Activity action: Launch UI to manage unused apps (hibernated apps).

Input: Nothing.

Output: Nothing.

Broadcast Action: External media was removed from SD card slot, but mount point was not unmounted. The path to the mount point for the removed media is contained in the Intent.mData field.

Broadcast Action: The "Media Button" was pressed. Includes a single extra field, EXTRA_KEY_EVENT, containing the key event that caused the broadcast.

Broadcast Action: External media is present, and being disk-checked The path to the mount point for the checking media is contained in the Intent.mData field.

Broadcast Action: User has expressed the desire to remove the external storage media. Applications should close all files they have open within the mount point when they receive this intent. The path to the mount point for the media to be ejected is contained in the Intent.mData field.

Broadcast Action: External media is present and mounted at its mount point. The path to the mount point for the mounted media is contained in the Intent.mData field. The Intent contains an extra with name "read-only" and Boolean value to indicate if the media was mounted read only.

Broadcast Action: External media is present, but is using an incompatible fs (or is blank) The path to the mount point for the checking media is contained in the Intent.mData field.

Broadcast Action: External media has been removed. The path to the mount point for the removed media is contained in the Intent.mData field.

Broadcast Action: The media scanner has finished scanning a directory. The path to the scanned directory is contained in the Intent.mData field.

Broadcast Action: Request the media scanner to scan a file and add it to the media database.

The path to the file is contained in Intent#getData().

Broadcast Action: The media scanner has started scanning a directory. The path to the directory being scanned is contained in the Intent.mData field.

Broadcast Action: External media is unmounted because it is being shared via USB mass storage. The path to the mount point for the shared media is contained in the Intent.mData field.

Broadcast Action: External media is present but cannot be mounted. The path to the mount point for the unmountable media is contained in the Intent.mData field.

Broadcast Action: External media is present, but not mounted at its mount point. The path to the mount point for the unmounted media is contained in the Intent.mData field.

Broadcast Action: A new version of your application has been installed over an existing one. This is only sent to the application that was replaced. It does not contain any additional data; to receive it, just use an intent filter for this action.

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent to a package that has been suspended by the system. This is sent whenever a package is put into a suspended state or any of its app extras change while in the suspended state.

Optionally includes the following extras:

• EXTRA_SUSPENDED_PACKAGE_EXTRAS which is a Bundle which will contain useful information for the app being suspended.

This is a protected intent that can only be sent by the system. This will be delivered to BroadcastReceiver components declared in the manifest.

Broadcast Action: Sent to a package that has been unsuspended.

This is a protected intent that can only be sent by the system. This will be delivered to BroadcastReceiver components declared in the manifest.

Broadcast Action: An outgoing call is about to be placed.

The Intent will have the following extra value:

• android.content.Intent#EXTRA_PHONE_NUMBER - the phone number originally intended to be dialed.

Starting in Android 15, this broadcast is no longer sent as an ordered broadcast. The resultData no longer has any effect and will not determine the actual routing of the call. Further, receivers of this broadcast do not get foreground priority and cannot launch background activities.

Once the broadcast is finished, the resultData is used as the actual number to call. If null, no call will be placed.

It is perfectly acceptable for multiple receivers to process the outgoing call in turn: for example, a parental control application might verify that the user is authorized to place the call at that time, then a number-rewriting application might add an area code if one was not specified.

For consistency, any receiver whose purpose is to prohibit phone calls should have a priority of 0, to ensure it will see the final phone number to be dialed. Any receiver whose purpose is to rewrite phone numbers to be called should have a positive priority. Negative priorities are reserved for the system for this broadcast; using them may cause problems.

Any BroadcastReceiver receiving this Intent must not abort the broadcast.

Emergency calls cannot be intercepted using this mechanism, and other calls cannot be modified to call emergency numbers using this mechanism.

Some apps (such as VoIP apps) may want to redirect the outgoing call to use their own service instead. Those apps should first prevent the call from being placed by setting resultData to null and then start their own app to make the call.

You must hold the android.Manifest.permission#PROCESS_OUTGOING_CALLS permission to receive this Intent.

This is a protected intent that can only be sent by the system.

If the user has chosen a android.telecom.CallRedirectionService to handle redirection of outgoing calls, this intent will NOT be sent as an ordered broadcast. This means that attempts to re-write the outgoing call by other apps using this intent will be ignored.

Activity Action: Allow the user to select and return one or more existing documents. When invoked, the system will display the various DocumentsProvider instances installed on the device, letting the user interactively navigate through them. These documents include local media, such as photos and video, and documents provided by installed cloud storage providers.

Each document is represented as a content:// URI backed by a DocumentsProvider, which can be opened as a stream with ContentResolver#openFileDescriptor(Uri, String), or queried for android.provider.DocumentsContract.Document metadata.

All selected documents are returned to the calling application with persistable read and write permission grants. If you want to maintain access to the documents across device reboots, you need to explicitly take the persistable permissions using ContentResolver#takePersistableUriPermission(Uri, int).

Callers must indicate the acceptable document MIME types through setType(java.lang.String). For example, to select photos, use image/*. If multiple disjoint MIME types are acceptable, define them in EXTRA_MIME_TYPES and setType(java.lang.String) to */*.

If the caller can handle multiple returned items (the user performing multiple selection), then you can specify EXTRA_ALLOW_MULTIPLE to indicate this.

Callers must include CATEGORY_OPENABLE in the Intent to obtain URIs that can be opened with ContentResolver#openFileDescriptor(Uri, String).

Callers can set a document URI through DocumentsContract#EXTRA_INITIAL_URI to indicate the initial location of documents navigator. System will do its best to launch the navigator in the specified document if it's a folder, or the folder that contains the specified document if not.

Output: The URI of the item that was picked, returned in getData(). This must be a content:// URI so that any receiver can access it. If multiple documents were selected, they are returned in getClipData().

Activity Action: Allow the user to pick a directory subtree. When invoked, the system will display the various DocumentsProvider instances installed on the device, letting the user navigate through them. Apps can fully manage documents within the returned directory.

To gain access to descendant (child, grandchild, etc) documents, use DocumentsContract#buildDocumentUriUsingTree(Uri, String) and DocumentsContract#buildChildDocumentsUriUsingTree(Uri, String) with the returned URI.

Callers can set a document URI through DocumentsContract#EXTRA_INITIAL_URI to indicate the initial location of documents navigator. System will do its best to launch the navigator in the specified document if it's a folder, or the folder that contains the specified document if not.

Output: The URI representing the selected directory tree.

Broadcast Action: Packages have been suspended.

Includes the following extras:

• EXTRA_CHANGED_PACKAGE_LIST is the set of packages which have been suspended
• EXTRA_CHANGED_UID_LIST is the set of uids which have been suspended

This is a protected intent that can only be sent by the system. It is only sent to registered receivers.

Broadcast Action: Packages have been unsuspended.

Includes the following extras:

• EXTRA_CHANGED_PACKAGE_LIST is the set of packages which have been unsuspended
• EXTRA_CHANGED_UID_LIST is the set of uids which have been unsuspended

This is a protected intent that can only be sent by the system. It is only sent to registered receivers.

Broadcast Action: A new application package has been installed on the device. The data contains the name of the package. Note that the newly installed package does not receive this broadcast.

May include the following extras:

• EXTRA_UID containing the integer uid assigned to the new package.
• EXTRA_REPLACING is set to true if this is following an ACTION_PACKAGE_REMOVED broadcast for the same package.

This is a protected intent that can only be sent by the system.

Broadcast Action: An existing application package has been changed (for example, a component has been enabled or disabled). The data contains the name of the package.

• EXTRA_UID containing the integer uid assigned to the package.
• EXTRA_CHANGED_COMPONENT_NAME_LIST containing the class name of the changed components (or the package name itself).
• EXTRA_DONT_KILL_APP containing boolean field to override the default action of restarting the application.

This is a protected intent that can only be sent by the system.

Broadcast Action: The user has cleared the data of a package. This should be preceded by ACTION_PACKAGE_RESTARTED, after which all of its persistent data is erased and this broadcast sent. Note that the cleared package does not receive this broadcast. The data contains the name of the package.

• EXTRA_UID containing the integer uid assigned to the package. If the package whose data was cleared is an uninstalled instant app, then the UID will be -1. The platform keeps some meta-data associated with instant apps after they are uninstalled.
• EXTRA_PACKAGE_NAME containing the package name only if the cleared data was for an instant app.

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent to the installer package of an application when that application is first launched (that is the first time it is moved out of the stopped state). The data contains the name of the package.

When the application is first launched, the application itself doesn't receive this broadcast.

This is a protected intent that can only be sent by the system.

Broadcast Action: An existing application package has been completely removed from the device. The data contains the name of the package. This is like ACTION_PACKAGE_REMOVED, but only set when EXTRA_DATA_REMOVED is true and EXTRA_REPLACING is false of that broadcast.

• EXTRA_UID containing the integer uid previously assigned to the package.

This is a protected intent that can only be sent by the system.

Broadcast Action: Trigger the download and eventual installation of a package.

Input: getData is the URI of the package file to download.

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent to the system package verifier when a package needs to be verified. The data contains the package URI.

This is a protected intent that can only be sent by the system.

Broadcast Action: An existing application package has been removed from the device. The data contains the name of the package. The package that is being removed does not receive this Intent.

• EXTRA_UID containing the integer uid previously assigned to the package.
• EXTRA_DATA_REMOVED is set to true if the entire application -- data and code -- is being removed.
• EXTRA_REPLACING is set to true if this will be followed by an ACTION_PACKAGE_ADDED broadcast for the same package.
• EXTRA_USER_INITIATED containing boolean field to signal that the application was removed with the user-initiated action.

This is a protected intent that can only be sent by the system.

Broadcast Action: A new version of an application package has been installed, replacing an existing version that was previously installed. The data contains the name of the package.

May include the following extras:

• EXTRA_UID containing the integer uid assigned to the new package.

This is a protected intent that can only be sent by the system.

Broadcast Action: The user has restarted a package, and all of its processes have been killed. All runtime state associated with it (processes, alarms, notifications, etc) should be removed. Note that the restarted package does not receive this broadcast. The data contains the name of the package.

• EXTRA_UID containing the integer uid assigned to the package.

This is a protected intent that can only be sent by the system.

Starting in Android V, an extra timestamp EXTRA_TIME is included with this broadcast to indicate the exact time the package was restarted, in elapsed realtime.

Broadcast Action: An application package that was previously in the stopped state has been started and is no longer considered stopped.

When a package is force-stopped, the ACTION_PACKAGE_RESTARTED broadcast is sent and the package in the stopped state cannot self-start for any reason unless there's an explicit request to start a component in the package. The ACTION_PACKAGE_UNSTOPPED broadcast is sent when such an explicit process start occurs and the package is taken out of the stopped state. The data contains the name of the package.

• EXTRA_UID containing the integer uid assigned to the package.
• EXTRA_TIME containing the elapsed realtime of when the package was unstopped.

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent to the system package verifier when a package is verified. The data contains the package URI.

This is a protected intent that can only be sent by the system.

Activity Action: Create a new item in the given container, initializing it from the current contents of the clipboard.

Input: getData is URI of the directory (vnd.android.cursor.dir/*) in which to place the data.

Output: URI of the new data that was created.

Activity Action: Pick an item from the data, returning what was selected.

Input: getData is URI containing a directory of data (vnd.android.cursor.dir/*) from which to pick an item.

Output: The URI of the item that was picked.

Activity Action: Pick an activity given an intent, returning the class selected.

Input: get*Extra field EXTRA_INTENT is an Intent used with android.content.pm.PackageManager#queryIntentActivities to determine the set of activities from which to pick.

Output: Class name of the activity that was selected.

Broadcast Action: External power has been connected to the device. This is intended for applications that wish to register specifically to this notification. Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to stay active to receive this notification. This action can be used to implement actions that wait until power is available to trigger.

This is a protected intent that can only be sent by the system.

Broadcast Action: External power has been removed from the device. This is intended for applications that wish to register specifically to this notification. Unlike ACTION_BATTERY_CHANGED, applications will be woken for this and so do not have to stay active to receive this notification. This action can be used to implement actions that wait until power is available to trigger.

This is a protected intent that can only be sent by the system.

Activity Action: Show power usage information to the user.

Input: Nothing.

Output: Nothing.

Activity Action: Process a piece of text.

Input: EXTRA_PROCESS_TEXT contains the text to be processed. EXTRA_PROCESS_TEXT_READONLY states if the resulting text will be read-only.

Output: EXTRA_PROCESS_TEXT contains the processed text.

Broadcast sent to the parent user when an associated profile has been started and unlocked. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the parent user when an associated profile is added (the profile was created and is ready to be used). Carries an extra EXTRA_USER that specifies the UserHandle of the profile that was added.

This broadcast is similar to ACTION_MANAGED_PROFILE_ADDED but functions as a generic broadcast for all profile users. It is sent in addition to the ACTION_MANAGED_PROFILE_ADDED broadcast when a managed user is added.

Only applications (for example Launchers) that need to display merged content across both the parent user and its associated profiles need to worry about this broadcast. This is only sent to registered receivers created with android.content.Context#registerReceiver. It is not sent to manifest receivers.

Broadcast sent to the primary user when an associated profile has become available. This is sent when a user disables quiet mode for the profile. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. When quiet mode is changed, this broadcast will carry a boolean extra EXTRA_QUIET_MODE indicating the new state of quiet mode. This is only sent to registered receivers, not manifest receivers.

This broadcast is similar to ACTION_MANAGED_PROFILE_AVAILABLE but functions as a generic broadcast for all users of type android.os.UserManager#isProfile()}. In case of a managed profile, both ACTION_MANAGED_PROFILE_AVAILABLE and ACTION_PROFILE_AVAILABLE broadcasts are sent.

Broadcast sent to the parent user when an associated profile has stopped. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. This is only sent to registered receivers, not manifest receivers.

Broadcast sent to the parent user when an associated profile is removed. Carries an extra EXTRA_USER that specifies the UserHandle of the profile that was removed.

This broadcast is similar to ACTION_MANAGED_PROFILE_REMOVED but functions as a generic broadcast for all profile users. It is sent in addition to the ACTION_MANAGED_PROFILE_REMOVED broadcast when a managed user is removed.

Only applications (for example Launchers) that need to display merged content across both the parent user and its associated profiles need to worry about this broadcast. This is only sent to registered receivers created with android.content.Context#registerReceiver. It is not sent to manifest receivers.

Broadcast sent to the primary user when an associated profile has become unavailable. This is sent when a user enables quiet mode for the profile. Carries an extra EXTRA_USER that specifies the UserHandle of the profile. When quiet mode is changed, this broadcast will carry a boolean extra EXTRA_QUIET_MODE indicating the new state of quiet mode. This is only sent to registered receivers, not manifest receivers.

This broadcast is similar to ACTION_MANAGED_PROFILE_UNAVAILABLE but functions as a generic broadcast for all users of type android.os.UserManager#isProfile()}. In case of a managed profile, both ACTION_MANAGED_PROFILE_UNAVAILABLE and ACTION_PROFILE_UNAVAILABLE broadcasts are sent.

Broadcast Action: Some content providers have parts of their namespace where they publish new events or items that the user may be especially interested in. For these things, they may broadcast this action when the set of interesting items change. For example, GmailProvider sends this notification when the set of unread mail in the inbox changes.

The data of the intent identifies which part of which provider changed. When queried through the content resolver, the data URI will return the data set in question.

The intent will have the following extra values:

• count - The number of items in the data set. This is the same as the number of items in the cursor returned by querying the data URI.

Sent when the user taps on the clock widget in the system's "quick settings" area.

Activity Action: Quick view the data. Launches a quick viewer for a URI or a list of URIs.

Activities handling this intent action should handle the vast majority of MIME types rather than only specific ones.

Quick viewers must render the quick view image locally, and must not send file content outside current device.

Input: getData is a mandatory content URI of the item to preview. getClipData contains an optional list of content URIs if there is more than one item to preview. EXTRA_INDEX is an optional index of the URI in the clip data to show first. EXTRA_QUICK_VIEW_FEATURES is an optional extra indicating the features that can be shown in the quick view UI.

Output: nothing.

Broadcast Action: Have the device reboot. This is only for use by system code.

This is a protected intent that can only be sent by the system.

Activity Action: Run the data, whatever that means.

Input: ? (Note: this is currently specific to the test harness.)

Output: nothing.

Activity action: Launch UI to open the Safety Center, which highlights the user's security and privacy status.

Broadcast Action: Sent when the device goes to sleep and becomes non-interactive.

For historical reasons, the name of this broadcast action refers to the power state of the screen but it is actually sent in response to changes in the overall interactive state of the device.

This broadcast is sent when the device becomes non-interactive which may have nothing to do with the screen turning off. To determine the actual state of the screen, use android.view.Display#getState.

See android.os.PowerManager#isInteractive for details.

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent when the device wakes up and becomes interactive.

For historical reasons, the name of this broadcast action refers to the power state of the screen but it is actually sent in response to changes in the overall interactive state of the device.

This broadcast is sent when the device becomes interactive which may have nothing to do with the screen turning on. To determine the actual state of the screen, use android.view.Display#getState.

See android.os.PowerManager#isInteractive for details.

This is a protected intent that can only be sent by the system.

Activity Action: Perform a search.

Input: getStringExtra(SearchManager.QUERY) is the text to search for. If empty, simply enter your search results Activity with the search UI activated.

Output: nothing.

Activity Action: Start action associated with long pressing on the search key.

Input: Nothing.

Output: Nothing.

Activity Action: Deliver some data to someone else. Who the data is being delivered to is not specified; it is up to the receiver of this action to ask the user where the data should be sent.

When launching a SEND intent, you should usually wrap it in a chooser (through #createChooser), which will give the proper interface for the user to pick how to send your data and allow you to specify a prompt indicating what they are doing.

Input: getType is the MIME type of the data being sent. get*Extra can have either a EXTRA_TEXT or EXTRA_STREAM field, containing the data to be sent. If using EXTRA_TEXT, the MIME type should be "text/plain"; otherwise it should be the MIME type of the data in EXTRA_STREAM. Use */* if the MIME type is unknown (this will only allow senders that can handle generic data streams). If using EXTRA_TEXT, you can also optionally supply EXTRA_HTML_TEXT for clients to retrieve your text with HTML formatting.

As of android.os.Build.VERSION_CODES#JELLY_BEAN, the data being sent can be supplied through setClipData(android.content.ClipData). This allows you to use FLAG_GRANT_READ_URI_PERMISSION when sharing content: URIs and other advanced features of ClipData. If using this approach, you still must supply the same data through the EXTRA_TEXT or EXTRA_STREAM fields described below for compatibility with old applications. If you don't set a ClipData, it will be copied there for you when calling Context#startActivity(Intent).

Starting from android.os.Build.VERSION_CODES#O, if CATEGORY_TYPED_OPENABLE is passed, then the Uris passed in either EXTRA_STREAM or via setClipData(android.content.ClipData) may be openable only as asset typed files using ContentResolver#openTypedAssetFileDescriptor(Uri, String, Bundle).

Optional standard extras, which may be interpreted by some recipients as appropriate, are: EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC, EXTRA_SUBJECT.

Output: nothing.

Activity Action: Send a message to someone specified by the data.

Input: getData is URI describing the target.

Output: nothing.

Activity Action: Deliver multiple data to someone else.

Like ACTION_SEND, except the data is multiple.

Input: getType is the MIME type of the data being sent. get*ArrayListExtra can have either a EXTRA_TEXT or EXTRA_STREAM field, containing the data to be sent. If using EXTRA_TEXT, you can also optionally supply EXTRA_HTML_TEXT for clients to retrieve your text with HTML formatting.

Multiple types are supported, and receivers should handle mixed types whenever possible. The right way for the receiver to check them is to use the content resolver on each URI. The intent sender should try to put the most concrete mime type in the intent type, but it can fall back to <type>/* or */* as needed.

e.g. if you are sending image/jpg and image/jpg, the intent's type can be image/jpg, but if you are sending image/jpg and image/png, then the intent's type should be image/*.

As of android.os.Build.VERSION_CODES#JELLY_BEAN, the data being sent can be supplied through setClipData(android.content.ClipData). This allows you to use FLAG_GRANT_READ_URI_PERMISSION when sharing content: URIs and other advanced features of ClipData. If using this approach, you still must supply the same data through the EXTRA_TEXT or EXTRA_STREAM fields described below for compatibility with old applications. If you don't set a ClipData, it will be copied there for you when calling Context#startActivity(Intent).

Starting from android.os.Build.VERSION_CODES#O, if CATEGORY_TYPED_OPENABLE is passed, then the Uris passed in either EXTRA_STREAM or via setClipData(android.content.ClipData) may be openable only as asset typed files using ContentResolver#openTypedAssetFileDescriptor(Uri, String, Bundle).

Optional standard extras, which may be interpreted by some recipients as appropriate, are: EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC, EXTRA_SUBJECT.

Output: nothing.

Activity Action: Show settings for choosing wallpaper.

Input: Nothing.

Output: Nothing.

Activity Action: Launch an activity showing the app information. For applications which install other applications (such as app stores), it is recommended to handle this action for providing the app information to the user.

Input: EXTRA_PACKAGE_NAME specifies the package whose information needs to be displayed.

Output: Nothing.

Activity Action: Action to show the list of all work apps in the launcher. For example, shows the work apps folder or tab.

Input: Nothing.

Output: nothing.

Broadcast Action: Device is shutting down. This is broadcast when the device is being shut down (completely turned off, not sleeping). Once the broadcast is complete, the final shutdown will proceed and all unsaved data lost. Apps will not normally need to handle this, since the foreground activity will be paused as well.

As of Build.VERSION_CODES#P this broadcast is only sent to receivers registered through Context.registerReceiver.

This is a protected intent that can only be sent by the system.

May include the following extras:

• EXTRA_SHUTDOWN_USERSPACE_ONLY a boolean that is set to true if this shutdown is only for userspace processes. If not set, assumed to be false.

Activity Action: Perform a data synchronization.

Input: ?

Output: ?

Activity Action: Start the platform-defined tutorial

Input: getStringExtra(SearchManager.QUERY) is the text to search for. If empty, simply enter your search results Activity with the search UI activated.

Output: nothing.

Broadcast Action: The timezone has changed. The intent will have the following extra values:

• EXTRA_TIMEZONE - The java.util.TimeZone.getID() value identifying the new time zone.

This is a protected intent that can only be sent by the system.

Broadcast Action: The time was set.

Broadcast Action: The current time has changed. Sent every minute. You cannot receive this through components declared in manifests, only by explicitly registering for it with Context.registerReceiver().

This is a protected intent that can only be sent by the system.

Activity Action: Perform text translation.

Input: getCharSequence(EXTRA_TEXT) is the text to translate.

Output: nothing.

Broadcast Action: A uid has been removed from the system. The uid number is stored in the extra data under EXTRA_UID. In certain instances, EXTRA_REPLACING is set to true if the UID is not being fully removed.

This is a protected intent that can only be sent by the system.

Broadcast Action: The device has entered USB Mass Storage mode. This is used mainly for the USB Settings panel. Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified when the SD card file system is mounted or unmounted

Broadcast Action: The device has exited USB Mass Storage mode. This is used mainly for the USB Settings panel. Apps should listen for ACTION_MEDIA_MOUNTED and ACTION_MEDIA_UNMOUNTED broadcasts to be notified when the SD card file system is mounted or unmounted

Broadcast Action: Sent to the responsible installer of an archived package when unarchival is requested.

Activity Action: Launch application uninstaller.

Input: The data must be a package: URI whose scheme specific part is the package name of the current installed package to be uninstalled. You can optionally supply EXTRA_RETURN_RESULT.

Output: If EXTRA_RETURN_RESULT, returns whether the uninstall succeeded.

Requires android.Manifest.permission#REQUEST_DELETE_PACKAGES since Build.VERSION_CODES#P.

Sent after a user switch is complete, if the switch caused the process's user to be sent to the background. This is only sent to receivers registered through Context.registerReceiver. It is sent to the user that is going to the background. This is sent as a foreground broadcast, since it is part of a visible user interaction; be as quick as possible when handling it.

Sent after a user switch is complete, if the switch caused the process's user to be brought to the foreground. This is only sent to receivers registered through Context.registerReceiver. It is sent to the user that is going to the foreground. This is sent as a foreground broadcast, since it is part of a visible user interaction; be as quick as possible when handling it.

Sent the first time a user is starting, to allow system apps to perform one time initialization. (This will not be seen by third party applications because a newly initialized user does not have any third party applications installed for it.) This is sent early in starting the user, around the time the home app is started, before ACTION_BOOT_COMPLETED is sent. This is sent as a foreground broadcast, since it is part of a visible user interaction; be as quick as possible when handling it.

Note: This broadcast is not sent to the system user.

Broadcast Action: Sent when the user is present after device wakes up (e.g when the keyguard is gone).

This is a protected intent that can only be sent by the system.

Broadcast Action: Sent when the credential-encrypted private storage has become unlocked for the target user. This is only sent to registered receivers, not manifest receivers.

Note: The user's actual state might have changed by the time the broadcast is received. For example, the user could have been removed, started or stopped already, regardless of which broadcast you receive. Because of that, receivers should always check the current state of the user.

Activity Action: Display the data to the user. This is the most common action performed on data -- it is the generic action you can use on a piece of data to get the most reasonable thing to occur. For example, when used on a contacts entry it will view the entry; when used on a mailto: URI it will bring up a compose window filled with the information supplied by the URI; when used with a tel: URI it will invoke the dialer.

Input: getData is URI from which to retrieve data.

Output: nothing.

Activity Action: Display an activity state associated with an unique LocusId.

For example, a chat app could use the context to resume a conversation between 2 users.

Input: EXTRA_LOCUS_ID specifies the unique identifier of the locus in the app domain. Should be stable across reboots and backup / restore.

Output: nothing.

Activity action: Launch UI to show information about the usage of a given permission group. This action would be handled by apps that want to show details about how and why given permission group is being used.

Important:You must protect the activity that handles this action with the START_VIEW_PERMISSION_USAGE permission to ensure that only the system can launch this activity. The system will not launch activities that are not properly protected.

Input: EXTRA_PERMISSION_GROUP_NAME specifies the permission group for which the launched UI would be targeted.

Output: Nothing.

Activity action: Launch UI to show information about the usage of a given permission group in a given period. This action would be handled by apps that want to show details about how and why given permission group is being used.

Important:You must protect the activity that handles this action with the android.Manifest.permission#START_VIEW_PERMISSION_USAGE permission to ensure that only the system can launch this activity. The system will not launch activities that are not properly protected.

Input: EXTRA_PERMISSION_GROUP_NAME specifies the permission group for which the launched UI would be targeted.

Input: EXTRA_ATTRIBUTION_TAGS specifies the attribution tags for the usage entry.

Input: EXTRA_START_TIME specifies the start time of the period (epoch time in millis). Both start time and end time are needed and start time must be <= end time.

Input: EXTRA_END_TIME specifies the end time of the period (epoch time in millis). Both start time and end time are needed and start time must be <= end time.

Output: Nothing.

Activity Action: Start Voice Command.

Input: Nothing.

Output: Nothing.

In some cases, a matching Activity may not exist, so ensure you safeguard against this.

Broadcast Action: The current system wallpaper has changed. See android.app.WallpaperManager for retrieving the new wallpaper. This should only be used to determine when the wallpaper has changed to show the new wallpaper to the user. You should certainly never, in response to this, change the wallpaper or other attributes of it such as the suggested size. That would be unexpected, right? You'd cause all kinds of loops, especially if other apps are doing similar things, right? Of course. So please don't do this.

Activity Action: Perform a web search.

Input: getStringExtra(SearchManager.QUERY) is the text to search for. If it is a url starts with http or https, the site will be opened. If it is plain text, Google search will be applied.

Output: nothing.

A response code used with EXTRA_CAPTURE_CONTENT_FOR_NOTE_STATUS_CODE to indicate that screenshot is blocked by IT admin.

A response code used with EXTRA_CAPTURE_CONTENT_FOR_NOTE_STATUS_CODE to indicate that something went wrong.

A response code used with EXTRA_CAPTURE_CONTENT_FOR_NOTE_STATUS_CODE to indicate that the request was a success.

This code will only be returned after the user has interacted with the system screenshot activity to consent to sharing the data with the note.

The captured screenshot is returned as a Uri through getData().

A response code used with EXTRA_CAPTURE_CONTENT_FOR_NOTE_STATUS_CODE to indicate that user canceled the content capture flow.

A response code used with EXTRA_CAPTURE_CONTENT_FOR_NOTE_STATUS_CODE to indicate that the intent action ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE was started by an activity that is running in a non-supported window mode.

The accessibility shortcut is a global gesture for users with disabilities to trigger an important for them accessibility feature to help developers determine whether they want to make their activity a shortcut target.

An activity of interest to users with accessibility needs may request to be the target of the accessibility shortcut. It handles intent ACTION_MAIN with this category, which will be dispatched by the system when the user activates the shortcut when it is configured to point at this target.

An activity declared itself to be a target of the shortcut in AndroidManifest.xml. It must also do two things:

Specify that it handles the android.intent.action.MAIN android.content.Intent with category android.intent.category.ACCESSIBILITY_SHORTCUT_TARGET.
Provide a meta-data entry android.accessibilityshortcut.target in the manifest when declaring the activity.

<activity android:name=".MainActivity"
  . . .
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.ACCESSIBILITY_SHORTCUT_TARGET" />
    </intent-filter>
    <meta-data android:name="android.accessibilityshortcut.target"
                    android:resource="@xml/accessibilityshortcut" />
  </activity>
  

This is a sample XML file configuring a accessibility shortcut target:

<accessibility-shortcut-target
      android:description="@string/shortcut_target_description"
      android:summary="@string/shortcut_target_summary"
      android:animatedImageDrawable="@drawable/shortcut_target_animated_image"
      android:htmlDescription="@string/shortcut_target_html_description"
      android:settingsActivity="com.example.android.shortcut.target.SettingsActivity" />
  

Both description and summary are necessary. The system will ignore the accessibility shortcut target if they are missing. The animated image and html description are supported to help users understand how to use the shortcut target. The settings activity is a component name that allows the user to modify the settings for this accessibility shortcut target.

Set if the activity should be considered as an alternative action to the data the user is currently viewing. See also CATEGORY_SELECTED_ALTERNATIVE for an alternative action that applies to the selection in a list of items.

Supporting this category means that you would like your activity to be displayed in the set of alternative things the user can do, usually as part of the current activity's options menu. You will usually want to include a specific label in the <intent-filter> of this action describing to the user what it does.

The action of IntentFilter with this category is important in that it describes the specific action the target will perform. This generally should not be a generic action (such as ACTION_VIEW, but rather a specific name such as "com.android.camera.action.CROP. Only one alternative of any particular action will be shown to the user, so using a specific action like this makes sure that your alternative will be displayed while also allowing other applications to provide their own overrides of that particular action.

Used with ACTION_MAIN to launch the browser application. The activity should be able to browse the Internet.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the calculator application. The activity should be able to perform standard arithmetic operations.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the calendar application. The activity should be able to view and manipulate calendar entries.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the contacts application. The activity should be able to view and manipulate address book entries.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the email application. The activity should be able to send and receive email.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the files application. The activity should be able to browse and manage files stored on the device.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the fitness application. The activity should be able to give the user fitness information and manage workouts

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the gallery application. The activity should be able to view and manipulate image and video files stored on the device.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the maps application. The activity should be able to show the user's current location and surroundings.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

This activity allows the user to browse and download new applications.

Used with ACTION_MAIN to launch the messaging application. The activity should be able to send and receive text messages.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the music application. The activity should be able to play, browse, or manipulate music files stored on the device.

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Used with ACTION_MAIN to launch the weather application. The activity should be able to give the user information about the weather

NOTE: This should not be used as the primary key of an Intent, since it will not result in the app launching with the correct action and category. Instead, use this with makeMainSelectorActivity(java.lang.String,java.lang.String) to generate a main Intent with this category in the selector.

Activities that can be safely invoked from a browser must support this category. For example, if the user is viewing a web page or an e-mail and clicks on a link in the text, the Intent generated execute that link will require the BROWSABLE category, so that only activities supporting this category will be considered as possible actions. By supporting this category, you are promising that there is nothing damaging (without user intervention) that can happen by invoking any matching Intent.

An activity to run when device is inserted into a car dock. Used with ACTION_MAIN to launch an activity. For more information, see android.app.UiModeManager.

Used to indicate that the activity can be used in a car environment.

Set if the activity should be an option for the default action (center press) to perform on a piece of data. Setting this will hide from the user any activities without it set when performing an action on some data. Note that this is normally -not- set in the Intent when initiating an action -- it is for use in intent filters specified in packages.

An activity to run when device is inserted into a desk dock. Used with ACTION_MAIN to launch an activity. For more information, see android.app.UiModeManager.

This activity is a development preference panel.

Capable of running inside a parent activity container.

To be used as code under test for framework instrumentation tests.

An activity to run when device is inserted into a digital (high end) dock. Used with ACTION_MAIN to launch an activity. For more information, see android.app.UiModeManager.

This is the home activity, that is the first activity that is displayed when the device boots.

Provides information about the package it is in; typically used if a package does not contain a CATEGORY_LAUNCHER to provide a front-door to the user without having to be shown in the all apps list.

Should be displayed in the top-level launcher.

Indicates an activity optimized for Leanback mode, and that should be displayed in the Leanback launcher.

An activity to run when device is inserted into a analog (low end) dock. Used with ACTION_MAIN to launch an activity. For more information, see android.app.UiModeManager.

This activity may be exercised by the monkey or other automated test tools.

Used to indicate that an intent only wants URIs that can be opened with ContentResolver#openFileDescriptor(Uri, String). Openable URIs must support at least the columns defined in OpenableColumns when queried.

This activity is a preference panel.

To be used as a sample code example (not part of the normal user experience).

The home activity shown on secondary displays that support showing home activities.

Set if the activity should be considered as an alternative selection action to the data the user has currently selected. This is like CATEGORY_ALTERNATIVE, but is used in activities showing a list of items from which the user can select, giving them alternatives to the default action that will be performed on it.

Intended to be used as a tab inside of a containing TabActivity.

To be used as a test (not part of the normal user experience).

Used to indicate that an intent filter can accept files which are not necessarily openable by ContentResolver#openFileDescriptor(Uri, String), but at least streamable via ContentResolver#openTypedAssetFileDescriptor(Uri, String, Bundle) using one of the stream types exposed via ContentResolver#getStreamTypes(Uri, String).

To be used as a unit test (run through the Test Harness).

Categories for activities that can participate in voice interaction. An activity that supports this category must be prepared to run with no UI shown at all (though in some case it may have a UI shown), and rely on android.app.VoiceInteractor to interact with the user.

An activity to use for the launcher when the device is placed in a VR Headset viewer. Used with ACTION_MAIN to launch an activity. For more information, see android.app.UiModeManager.

Indicates that the content being shared with ACTION_SEND represents an album (e.g. containing photos).

Used as an int extra field in android.app.AlarmManager pending intents to tell the application being invoked how many pending alarms are being delivered with the intent. For one-shot alarms this will always be 1. For recurring alarms, this might be greater than 1 if the device was asleep or powered off at the time an earlier alarm would have been delivered.

Note: You must supply a mutable android.app.PendingIntent to AlarmManager while setting your alarms to be able to read this value on receiving them. Mutability of pending intents must be explicitly specified by apps targeting Build.VERSION_CODES#S or higher.

Extra used to indicate that an intent can allow the user to select and return multiple items. This is a boolean extra; the default is false. If true, an implementation is allowed to present the user with a UI where they can pick multiple items that are all returned to the caller. When this happens, they should be returned as the getClipData() part of the result Intent.

Used as a boolean extra field with ACTION_INSTALL_PACKAGE to install a package. Tells the installer UI to skip the confirmation with the user if the .apk is replacing an existing one.

An Intent[] describing additional, alternate choices you would like shown with ACTION_CHOOSER.

An app may be capable of providing several different payload types to complete a user's intended action. For example, an app invoking ACTION_SEND to share photos with another app may use EXTRA_ALTERNATE_INTENTS to have the chooser transparently offer several different supported sending mechanisms for sharing, such as the actual "image/*" photo data or a hosted link where the photos can be viewed.

The intent present in EXTRA_INTENT will be treated as the first/primary/preferred intent in the set. Additional intents specified in this extra are ordered; by default intents that appear earlier in the array will be preferred over intents that appear later in the array as matches for the same target component. To alter this preference, a calling app may also supply EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER.

Used as a boolean extra field in android.content.Intent#ACTION_PACKAGE_ADDED and android.content.Intent#ACTION_PACKAGE_REMOVED intents to indicate that the package is being archived. Either by removing the existing APK, or by installing a package without an APK.

An optional field on ACTION_ASSIST and containing additional contextual information supplied by the current foreground app at the time of the assist request. This is a Bundle of additional data.

An optional field on ACTION_ASSIST containing the InputDevice id that was used to invoke the assist.

An optional field on ACTION_ASSIST suggesting that the user will likely use a keyboard as the primary input device for assistance.

An optional field on ACTION_ASSIST containing the name of the current foreground application package at the time the assist was invoked.

An optional field on ACTION_ASSIST containing the uid of the current foreground application package at the time the assist was invoked.

A String[] holding attribution tags when used with ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD and ACTION_MANAGE_PERMISSION_USAGE E.g. an attribution tag could be location_provider, com.google.android.gms.*, etc.

Used as a boolean extra field in ACTION_CHOOSER intents to specify whether to show the chooser or not when there is only one application available to choose from.

A String[] holding e-mail addresses that should be blind carbon copied.

Used as a parcelable extra field in ACTION_APP_ERROR, containing the bug report.

An int extra used by activity started with ACTION_LAUNCH_CAPTURE_CONTENT_ACTIVITY_FOR_NOTE to indicate status of the response. This extra is used along with result code set to android.app.Activity#RESULT_OK.

The value for this extra can be one of the following:

• CAPTURE_CONTENT_FOR_NOTE_SUCCESS
• CAPTURE_CONTENT_FOR_NOTE_FAILED
• CAPTURE_CONTENT_FOR_NOTE_USER_CANCELED
• CAPTURE_CONTENT_FOR_NOTE_WINDOW_MODE_UNSUPPORTED
• CAPTURE_CONTENT_FOR_NOTE_BLOCKED_BY_ADMIN

A String[] holding e-mail addresses that should be carbon copied.

This field is part of android.content.Intent#ACTION_PACKAGE_CHANGED, and contains a string array of all of the components that have changed. If the state of the overall package has changed, then it will contain an entry with the package name itself.

This field is part of android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE, android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE, android.content.Intent#ACTION_PACKAGES_SUSPENDED, android.content.Intent#ACTION_PACKAGES_UNSUSPENDED and contains a string array of all of the components that have changed.

This field is part of android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_AVAILABLE, android.content.Intent#ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE and contains an integer array of uids of all of the components that have changed.

Optional argument used to provide a ContentProviderUri to an ACTION_CHOOSER Intent which allows additional toggleable items to be included in the sharing UI.

For example, this could be used to show photos being shared in the context of the user's entire photo roll, with the option to change the set of photos being shared.

When this is provided in an ACTION_CHOOSER Intent with an ACTION_SEND or ACTION_SEND_MULTIPLE target Intent, the sharesheet will query (see ContentProvider#query(Uri, String[], Bundle, CancellationSignal)) this URI to retrieve a set of additional items available for selection. The set of items returned by the content provider is expected to contain all the items from the EXTRA_STREAM argument, in their relative order, which will be marked as selected. The URI's authority must be different from any shared items URI provided in EXTRA_STREAM or returned by the provider.

The Bundle argument of the ContentProvider#query(Uri, String[], Bundle, CancellationSignal) method will contains the original intent Chooser has been launched with under the EXTRA_INTENT key as a context for the current sharing session. The returned android.database.Cursor should contain:

• android.service.chooser.AdditionalContentContract.Columns#URI column for the item URI.
• Optional columns MediaStore.MediaColumns#WIDTH and MediaStore.MediaColumns#HEIGHT for the dimensions of the preview image. These columns can also be returned for each EXTRA_STREAM item metadata ContentProvider#query(Uri, String[], Bundle, CancellationSignal) call.
• Optional AdditionalContentContract.CursorExtraKeys#POSITION extra that specifies the cursor starting position; the item at this position is expected to match the item specified by EXTRA_CHOOSER_FOCUSED_ITEM_POSITION.

When the user makes a selection change, ContentProvider#call(String, String, Bundle) method will be invoked with the "method" argument set to android.service.chooser.AdditionalContentContract.MethodNames#ON_SELECTION_CHANGED, the "arg" argument set to this argument's value, and the "extras" Bundle argument containing EXTRA_INTENT key containing the original intent Chooser has been launched with but with the modified target intent --Chooser will modify the target intent according to the selection changes made by the user. Applications may implement this method to change any of the following Chooser arguments by returning new values in the result bundle: EXTRA_CHOOSER_TARGETS, EXTRA_ALTERNATE_INTENTS, EXTRA_CHOOSER_CUSTOM_ACTIONS, EXTRA_CHOOSER_MODIFY_SHARE_ACTION, EXTRA_METADATA_TEXT, EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER, EXTRA_CHOOSER_RESULT_INTENT_SENDER.

Optional integer extra to be used with ACTION_CHOOSER to describe conteng being shared.

If provided, sharesheets may customize their UI presentation to include a more precise description of the content being shared.

A Parcelable[] of ChooserAction objects to provide the Android Sharesheet with app-specific actions to be presented to the user when invoking ACTION_CHOOSER. You can provide as many as five custom actions.

Optional argument to be used with EXTRA_CHOOSER_ADDITIONAL_CONTENT_URI, used in combination with EXTRA_CHOOSER_ADDITIONAL_CONTENT_URI. An integer, zero-based index into EXTRA_STREAM argument indicating the item that should be focused by the Chooser in preview.

Optional argument to be used with ACTION_CHOOSER. A ChooserAction to allow the user to modify what is being shared in some way. This may be integrated into the content preview on sharesheets that have a preview UI.

An IntentSender for an Activity that will be invoked when the user makes a selection from the chooser activity presented by ACTION_CHOOSER.

An app preparing an action for another app to complete may wish to allow the user to disambiguate between several options for completing the action based on the chosen target or otherwise refine the action before it is invoked.

When sent, this IntentSender may be filled in with the following extras:

• EXTRA_INTENT The first intent that matched the user's chosen target
• EXTRA_ALTERNATE_INTENTS Any additional intents that also matched the user's chosen target beyond the first
• EXTRA_RESULT_RECEIVER A ResultReceiver that the refinement activity should fill in and send once the disambiguation is complete

A ChooserResult which describes how the sharing session completed.

An instance is supplied to the optional IntentSender provided to createChooser(android.content.Intent,java.lang.CharSequence,android.content.IntentSender) when the session completes.

An IntentSender that will be notified when a user successfully chooses a target component or initiates an action such as copy or edit within an ACTION_CHOOSER activity. The IntentSender will have the extra EXTRA_CHOOSER_RESULT describing the result.

A ChooserTarget[] for ACTION_CHOOSER describing additional high-priority deep-link targets for the chooser to present to the user.

Targets provided in this way will be presented inline with all other targets provided by services from other apps. They will be prioritized before other service targets, but after those targets provided by sources that the user has manually pinned to the front. You can provide up to two targets on this extra (the limit of two targets starts in Android 10).

The ComponentName chosen by the user to complete an action.

An IntentSender that will be notified if a user successfully chooses a target component to handle an action in an ACTION_CHOOSER activity. The IntentSender will have the extra EXTRA_CHOSEN_COMPONENT appended to it containing the ComponentName of the chosen component.

In some situations this callback may never come, for example if the user abandons the chooser, switches to another task or any number of other reasons. Apps should not be written assuming that this callback will always occur.

Intent extra: A ComponentName value.

Type: String

An ArrayList of String annotations describing content for ACTION_CHOOSER.

If EXTRA_CONTENT_ANNOTATIONS is present in an intent used to start a ACTION_CHOOSER activity, the first three annotations will be used to rank apps.

Annotations should describe the major components or topics of the content. It is up to apps initiating ACTION_CHOOSER to learn and add annotations. Annotations should be learned in advance, e.g., when creating or saving content, to avoid increasing latency to start ACTION_CHOOSER. Names of customized annotations should not contain the colon character. Performance on customized annotations can suffer, if they are rarely used for ACTION_CHOOSER in the past 14 days. Therefore, it is recommended to use the following annotations when applicable.

• "product" represents that the topic of the content is mainly about products, e.g., health & beauty, and office supplies.
• "emotion" represents that the topic of the content is mainly about emotions, e.g., happy, and sad.
• "person" represents that the topic of the content is mainly about persons, e.g., face, finger, standing, and walking.
• "child" represents that the topic of the content is mainly about children, e.g., child, and baby.
• "selfie" represents that the topic of the content is mainly about selfies.
• "crowd" represents that the topic of the content is mainly about crowds.
• "party" represents that the topic of the content is mainly about parties.
• "animal" represent that the topic of the content is mainly about animals.
• "plant" represents that the topic of the content is mainly about plants, e.g., flowers.
• "vacation" represents that the topic of the content is mainly about vacations.
• "fashion" represents that the topic of the content is mainly about fashion, e.g. sunglasses, jewelry, handbags and clothing.
• "material" represents that the topic of the content is mainly about materials, e.g., paper, and silk.
• "vehicle" represents that the topic of the content is mainly about vehicles, like cars, and boats.
• "document" represents that the topic of the content is mainly about documents, e.g. posters.
• "design" represents that the topic of the content is mainly about design, e.g. arts and designs of houses.
• "holiday" represents that the topic of the content is mainly about holidays, e.g., Christmas and Thanksgiving.

Optional CharSequence extra to provide a search query. The format of this query is dependent on the receiving application.

Applicable to Intent with actions:

• Intent#ACTION_GET_CONTENT
• Intent#ACTION_OPEN_DOCUMENT

Used as a boolean extra field in android.content.Intent#ACTION_PACKAGE_REMOVED intents to indicate whether this represents a full uninstall (removing both the code and its data) or a partial uninstall (leaving its data, implying that this is an update).

Used as an int extra field in android.content.Intent#ACTION_DOCK_EVENT intents to request the dock state. Possible values are android.content.Intent#EXTRA_DOCK_STATE_UNDOCKED, android.content.Intent#EXTRA_DOCK_STATE_DESK, or android.content.Intent#EXTRA_DOCK_STATE_CAR, or android.content.Intent#EXTRA_DOCK_STATE_LE_DESK, or android.content.Intent#EXTRA_DOCK_STATE_HE_DESK.

Used as an int value for android.content.Intent#EXTRA_DOCK_STATE to represent that the phone is in a car dock.

Used as an int value for android.content.Intent#EXTRA_DOCK_STATE to represent that the phone is in a desk dock.

Used as an int value for android.content.Intent#EXTRA_DOCK_STATE to represent that the phone is in a digital (high end) dock.

Used as an int value for android.content.Intent#EXTRA_DOCK_STATE to represent that the phone is in a analog (low end) dock.

Used as an int value for android.content.Intent#EXTRA_DOCK_STATE to represent that the phone is not in any dock.

Used as a boolean extra field in android.content.Intent#ACTION_PACKAGE_REMOVED or android.content.Intent#ACTION_PACKAGE_CHANGED intents to override the default action of restarting the application.

Intent extra: The number of milliseconds.

Type: long

A String[] holding e-mail addresses that should be delivered to.

A long representing the end timestamp (epoch time in millis) of the permission usage when used with ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD and ACTION_MANAGE_PERMISSION_USAGE

A ComponentName[] describing components that should be filtered out and omitted from a list of components presented to the user.

When used with ACTION_CHOOSER, the chooser will omit any of the components in this array if it otherwise would have shown them. Useful for omitting specific targets from your own package or other apps from your organization if the idea of sending to those targets would be redundant with other app functionality. Filtered components will not be able to present targets from an associated ChooserTargetService.

Extra that can be included on activity intents coming from the storage UI when it launches sub-activities to manage various types of storage. For example, it may use ACTION_VIEW with a "image/*" MIME type to have an app show the images on the device, and in that case also include this extra to tell the app it is coming from the storage UI so should help the user manage storage of this type.

A constant String that is associated with the Intent, used with ACTION_SEND to supply an alternative to EXTRA_TEXT as HTML formatted text. Note that you must also supply EXTRA_TEXT.

Optional index with semantics depending on the intent action.

The value must be an integer greater or equal to 0.

A Parcelable[] of Intent or android.content.pm.LabeledIntent objects as set with putExtra(java.lang.String,android.os.Parcelable[]) to place at the front of the list of choices, when shown to the user with an ACTION_CHOOSER. You can choose up to two additional activities to show before the app suggestions (the limit of two additional activities starts in Android 10).

Used as a string extra field with ACTION_INSTALL_PACKAGE to install a package. Specifies the installer package name; this package will receive the ACTION_APP_ERROR intent.

An Intent describing the choices you would like shown with ACTION_PICK_ACTIVITY or ACTION_CHOOSER.

A android.view.KeyEvent object containing the event that triggered the creation of the Intent it is in.

Intent extra: A android.os.LocaleList

Type: LocaleList

Extra used to indicate that an intent should only return data that is on the local device. This is a boolean extra; the default is false. If true, an implementation should only allow the user to select data that is already on the device, not requiring it be downloaded from a remote service when opened.

Intent extra: ID of the context used on ACTION_VIEW_LOCUS.

Type: LocusId

A CharSequence of additional text describing the content being shared. This text will be displayed to the user as a part of the sharesheet when included in an ACTION_CHOOSER Intent.

e.g. When sharing a photo, metadata could inform the user that location data is included in the photo they are sharing.

Extra used to communicate a set of acceptable MIME types. The type of the extra is String[]. Values may be a combination of concrete MIME types (such as "image/png") and/or partial MIME types (such as "audio/*").

Used as a boolean extra field with ACTION_INSTALL_PACKAGE to install a package. Specifies that the application being installed should not be treated as coming from an unknown source, but as coming from the app invoking the Intent. For this to work you must start the installer with startActivityForResult().

Used as a URI extra field with ACTION_INSTALL_PACKAGE and ACTION_VIEW to indicate the URI from which the local APK in the Intent data field originated from.

String array of package names.

Intent extra: An app package name.

Type: String

Intent extra: The name of a permission group.

Type: String

A String holding the phone number originally entered in android.content.Intent#ACTION_NEW_OUTGOING_CALL, or the actual number to call in a android.content.Intent#ACTION_CALL.

The name of the extra used to define the text to be processed, as a CharSequence. Note that this may be a styled CharSequence, so you must use Bundle.getCharSequence() to retrieve it.

The name of the boolean extra used to define if the processed text will be used as read-only.

An optional extra of String[] indicating which quick view features should be made available to the user in the quick view UI while handing a Intent#ACTION_QUICK_VIEW intent.

Optional boolean extra indicating whether quiet mode has been switched on or off. When a profile goes into quiet mode, all apps in the profile are killed and the profile user is stopped. Widgets originating from the profile are masked, and app launcher icons are grayed out.

This extra can be used with any Intent used to launch an activity, supplying information about who is launching that activity. This field contains a android.net.Uri object, typically an http: or https: URI of the web site that the referral came from; it can also use the android-app: scheme to identify a native application that it came from.

To retrieve this value in a client, use android.app.Activity#getReferrer instead of directly retrieving the extra. It is also valid for applications to instead supply EXTRA_REFERRER_NAME for cases where they can only create a string, not a Uri; the field here, if supplied, will always take precedence, however.

Alternate version of EXTRA_REFERRER that supplies the URI as a String rather than a android.net.Uri object. Only for use in cases where Uri objects can not be created, in particular when Intent extras are supplied through the intent: or android-app: schemes.

Used in the extra field in the remote intent. It's a string token passed with the remote intent.

A Bundle forming a mapping of potential target package names to different extras Bundles to add to the default intent extras in EXTRA_INTENT when used with ACTION_CHOOSER. Each key should be a package name. The package need not be currently installed on the device.

An application may choose to provide alternate extras for the case where a user selects an activity from a predetermined set of target packages. If the activity the user selects from the chooser belongs to a package with its package name as a key in this bundle, the corresponding extras for that package will be merged with the extras already present in the intent at EXTRA_INTENT. If a replacement extra has the same key as an extra already present in the intent it will overwrite the extra from the intent.

Examples:

• An application may offer different EXTRA_TEXT to an application when sharing with it via ACTION_SEND, augmenting a link with additional query parameters for that target.
• An application may offer additional metadata for known targets of a given intent to pass along information only relevant to that target such as account or content identifiers already known to that application.

Used as a boolean extra field in android.content.Intent#ACTION_PACKAGE_REMOVED intents to indicate that this is a replacement of the package, so this broadcast will immediately be followed by an add broadcast for a different version of the same package.

Extra sent in the intent to the BroadcastReceiver that handles ACTION_GET_RESTRICTION_ENTRIES. The type of the extra is a Bundle containing the restrictions as key/value pairs.

Extra used in the response from a BroadcastReceiver that handles ACTION_GET_RESTRICTION_ENTRIES.

Extra used in the response from a BroadcastReceiver that handles ACTION_GET_RESTRICTION_ENTRIES. The type of the extra is ArrayList<RestrictionEntry>.

A ResultReceiver used to return data back to the sender.

Used to complete an app-specific refinement for ACTION_CHOOSER.

If EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER is present in the intent used to start a ACTION_CHOOSER activity this extra will be filled in to that IntentSender and sent when the user selects a target component from the chooser. It is up to the recipient to send a result to this ResultReceiver to signal that disambiguation is complete and that the chooser should invoke the user's choice.

The disambiguator should provide a Bundle to the ResultReceiver with an intent assigned to the key EXTRA_INTENT. This supplied intent will be used by the chooser to match and fill in the final Intent or ChooserTarget before starting it. The supplied intent must match one of the intents from EXTRA_INTENT or EXTRA_ALTERNATE_INTENTS passed to EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER to be accepted.

The result code passed to the ResultReceiver should be android.app.Activity#RESULT_OK if the refinement succeeded and the supplied intent's target in the chooser should be started, or android.app.Activity#RESULT_CANCELED if the chooser should finish without starting a target.

Used as a boolean extra field with ACTION_INSTALL_PACKAGE or ACTION_UNINSTALL_PACKAGE. Specifies that the installer UI should return to the application the result code of the install/uninstall. The returned result code will be android.app.Activity#RESULT_OK on success or android.app.Activity#RESULT_FIRST_USER on failure.

The name of the extra used to define the icon, as a Bitmap, of a shortcut.

The name of the extra used to define the icon, as a ShortcutIconResource, of a shortcut.

Intent extra: ID of the shortcut used to send the share intent. Will be sent with ACTION_SEND.

The name of the extra used to define the Intent of a shortcut.

The name of the extra used to define the name of a shortcut.

Optional extra for ACTION_SHUTDOWN that allows the sender to qualify that this shutdown is only for the user space of the system, not a complete shutdown. When this is true, hardware devices can use this information to determine that they shouldn't do a complete shutdown of their device since this is not a complete shutdown down to the kernel, but only user space restarting. The default if not supplied is false.

Intent extra: An app split name.

Type: String

A long representing the start timestamp (epoch time in millis) of the permission usage when used with ACTION_VIEW_PERMISSION_USAGE_FOR_PERIOD and ACTION_MANAGE_PERMISSION_USAGE

A content: URI holding a stream of data associated with the Intent, used with ACTION_SEND to supply the data being sent.

A constant string holding the desired subject line of a message.

Intent extra: A Bundle of extras for a package being suspended. Will be sent as an extra with ACTION_MY_PACKAGE_SUSPENDED.

The contents of this Bundle are a contract between the suspended app and the suspending app, i.e. any app with the permission android.permission.SUSPEND_APPS. This is meant to enable the suspended app to better handle the state of being suspended.

The initial data to place in a newly created record. Use with ACTION_INSERT. The data here is a Map containing the same fields as would be given to the underlying ContentProvider.insert() call.

A constant CharSequence that is associated with the Intent, used with ACTION_SEND to supply the literal data to be sent. Note that this may be a styled CharSequence, so you must use Bundle.getCharSequence() to retrieve it.

Optional extra specifying a time in milliseconds. The timebase depends on the Intent including this extra. The value must be non-negative.

Type: long

Extra sent with ACTION_TIMEZONE_CHANGED specifying the new time zone of the device.

Type: String, the same as returned by TimeZone#getID() to identify time zones.

A CharSequence dialog title to provide to the user when used with a ACTION_CHOOSER.

Used as an int extra field in android.content.Intent#ACTION_UID_REMOVED intents to supply the uid the package had been assigned. Also an optional extra in android.content.Intent#ACTION_PACKAGE_REMOVED or android.content.Intent#ACTION_PACKAGE_CHANGED for the same purpose.

The UserHandle carried with intents.

Used as a boolean extra field in android.content.Intent#ACTION_PACKAGE_REMOVED intents to signal that the application was removed with the user-initiated action.

A boolean extra used with ACTION_CREATE_NOTE indicating whether the launched note-taking activity should show a UI that is suitable to use with stylus input.

Use with fillIn to allow the current action value to be overwritten, even if it is already set.

Use with fillIn to allow the current categories to be overwritten, even if they are already set.

Use with fillIn to allow the current ClipData to be overwritten, even if it is already set.

Use with fillIn to allow the current component value to be overwritten, even if it is already set.

Use with fillIn to allow the current data or type value overwritten, even if it is already set.

Use with fillIn to allow the current identifier value to be overwritten, even if it is already set.

Use with fillIn to allow the current package value to be overwritten, even if it is already set.

Use with fillIn to allow the current selector to be overwritten, even if it is already set.

Use with fillIn to allow the current bounds rectangle to be overwritten, even if it is already set.

This flag is not normally set by application code, but set for you by the system as described in the launchMode documentation for the singleTask mode.

If set in an Intent passed to android.content.Context#startActivity, this flag will cause any existing task that would be associated with the activity to be cleared before the activity is started. That is, the activity becomes the new root of an otherwise empty task, and any old activities are finished. This can only be used in conjunction with FLAG_ACTIVITY_NEW_TASK.

If set, and the activity being launched is already running in the current task, then instead of launching a new instance of that activity, all of the other activities on top of it will be closed and this Intent will be delivered to the (now on top) old activity as a new Intent.

For example, consider a task consisting of the activities: A, B, C, D. If D calls startActivity() with an Intent that resolves to the component of activity B, then C and D will be finished and B receive the given Intent, resulting in the stack now being: A, B.

The currently running instance of activity B in the above example will either receive the new intent you are starting here in its onNewIntent() method, or be itself finished and restarted with the new intent. If it has declared its launch mode to be "multiple" (the default) and you have not set FLAG_ACTIVITY_SINGLE_TOP in the same intent, then it will be finished and re-created; for all other launch modes or if FLAG_ACTIVITY_SINGLE_TOP is set then this Intent will be delivered to the current instance's onNewIntent().

This launch mode can also be used to good effect in conjunction with FLAG_ACTIVITY_NEW_TASK: if used to start the root activity of a task, it will bring any currently running instance of that task to the foreground, and then clear it to its root state. This is especially useful, for example, when launching an activity from the notification manager.

See Tasks and Back Stack for more information about tasks.

If set, the new activity is not kept in the list of recently launched activities.

If set and this intent is being used to launch a new activity from an existing one, then the reply target of the existing activity will be transferred to the new activity. This way, the new activity can call android.app.Activity#setResult and have that result sent back to the reply target of the original activity.

This flag is not normally set by application code, but set for you by the system if this activity is being launched from history.

This flag is only used for split-screen multi-window mode. The new activity will be displayed adjacent to the one launching it. This can only be used in conjunction with FLAG_ACTIVITY_NEW_TASK. Also, setting FLAG_ACTIVITY_MULTIPLE_TASK is required if you want a new instance of an existing activity to be created.

If set in an Intent passed to android.content.Context#startActivity, this flag will attempt to launch an instant app if no full app on the device can already handle the intent.

When attempting to resolve instant apps externally, the following Intent properties are supported:

• Intent#setAction(String)
• Intent#addCategory(String)
• Intent#setData(Uri)
• Intent#setType(String)
• Intent#setPackage(String)
• Intent#addFlags(int)

In the case that no instant app can be found, the installer will be launched to notify the user that the intent could not be resolved. On devices that do not support instant apps, the flag will be ignored.

This flag is used to create a new task and launch an activity into it. This flag is always paired with either FLAG_ACTIVITY_NEW_DOCUMENT or FLAG_ACTIVITY_NEW_TASK. In both cases these flags alone would search through existing tasks for ones matching this Intent. Only if no such task is found would a new task be created. When paired with FLAG_ACTIVITY_MULTIPLE_TASK both of these behaviors are modified to skip the search for a matching task and unconditionally start a new task. When used with FLAG_ACTIVITY_NEW_TASK do not use this flag unless you are implementing your own top-level application launcher. Used in conjunction with FLAG_ACTIVITY_NEW_TASK to disable the behavior of bringing an existing task to the foreground. When set, a new task is always started to host the Activity for the Intent, regardless of whether there is already an existing task running the same thing.

Because the default system does not include graphical task management, you should not use this flag unless you provide some way for a user to return back to the tasks you have launched. See FLAG_ACTIVITY_NEW_DOCUMENT for details of this flag's use for creating new document tasks.

This flag is ignored if one of FLAG_ACTIVITY_NEW_TASK or FLAG_ACTIVITY_NEW_DOCUMENT is not also set.

See Tasks and Back Stack for more information about tasks.

This flag is used to open a document into a new task rooted at the activity launched by this Intent. Through the use of this flag, or its equivalent attribute, android.R.attr#documentLaunchMode multiple instances of the same activity containing different documents will appear in the recent tasks list.

The use of the activity attribute form of this, android.R.attr#documentLaunchMode, is preferred over the Intent flag described here. The attribute form allows the Activity to specify multiple document behavior for all launchers of the Activity whereas using this flag requires each Intent that launches the Activity to specify it.

Note that the default semantics of this flag w.r.t. whether the recents entry for it is kept after the activity is finished is different than the use of FLAG_ACTIVITY_NEW_TASK and android.R.attr#documentLaunchMode -- if this flag is being used to create a new recents entry, then by default that entry will be removed once the activity is finished. You can modify this behavior with FLAG_ACTIVITY_RETAIN_IN_RECENTS.

FLAG_ACTIVITY_NEW_DOCUMENT may be used in conjunction with FLAG_ACTIVITY_MULTIPLE_TASK. When used alone it is the equivalent of the Activity manifest specifying android.R.attr#documentLaunchMode="intoExisting". When used with FLAG_ACTIVITY_MULTIPLE_TASK it is the equivalent of the Activity manifest specifying android.R.attr#documentLaunchMode="always". The flag is ignored even in conjunction with FLAG_ACTIVITY_MULTIPLE_TASK when the Activity manifest specifies android.R.attr#documentLaunchMode="never". Refer to android.R.attr#documentLaunchMode for more information.

If set, this activity will become the start of a new task on this history stack. A task (from the activity that started it to the next task activity) defines an atomic group of activities that the user can move to. Tasks can be moved to the foreground and background; all of the activities inside of a particular task always remain in the same order. See Tasks and Back Stack for more information about tasks.

This flag is generally used by activities that want to present a "launcher" style behavior: they give the user a list of separate things that can be done, which otherwise run completely independently of the activity launching them.

When using this flag, if a task is already running for the activity you are now starting, then a new activity will not be started; instead, the current task will simply be brought to the front of the screen with the state it was last in. See FLAG_ACTIVITY_MULTIPLE_TASK for a flag to disable this behavior.

This flag can not be used when the caller is requesting a result from the activity being launched.

If set in an Intent passed to android.content.Context#startActivity, this flag will prevent the system from applying an activity transition animation to go to the next activity state. This doesn't mean an animation will never run -- if another activity change happens that doesn't specify this flag before the activity started here is displayed, then that transition will be used. This flag can be put to good use when you are going to do a series of activity operations but the animation seen by the user shouldn't be driven by the first activity change but rather a later one.

If set, the new activity is not kept in the history stack. As soon as the user navigates away from it, the activity is finished. This may also be set with the noHistory attribute.

If set, android.app.Activity#onActivityResult is never invoked when the current activity starts a new activity which sets a result and finishes.

If set, this flag will prevent the normal android.app.Activity#onUserLeaveHint callback from occurring on the current frontmost activity before it is paused as the newly-started activity is brought to the front.

Typically, an activity can rely on that callback to indicate that an explicit user action has caused their activity to be moved out of the foreground. The callback marks an appropriate point in the activity's lifecycle for it to dismiss any notifications that it intends to display "until the user has seen them," such as a blinking LED.

If an activity is ever started via any non-user-driven events such as phone-call receipt or an alarm handler, this flag should be passed to android.content.Context#startActivity, ensuring that the pausing activity does not think the user has acknowledged its notification.

If set and this intent is being used to launch a new activity from an existing one, the current activity will not be counted as the top activity for deciding whether the new intent should be delivered to the top instead of starting a new one. The previous activity will be used as the top, with the assumption being that the current activity will finish itself immediately.

If set in an Intent passed to android.content.Context#startActivity, this flag will cause the launched activity to be brought to the front of its task's history stack if it is already running.

For example, consider a task consisting of four activities: A, B, C, D. If D calls startActivity() with an Intent that resolves to the component of activity B, then B will be brought to the front of the history stack, with this resulting order: A, C, D, B. This flag will be ignored if FLAG_ACTIVITY_CLEAR_TOP is also specified.

If set in an intent passed to android.content.Context#startActivity, this flag will only launch the intent if it resolves to a single result. If no such result exists or if the system chooser would otherwise be displayed, an ActivityNotFoundException will be thrown.

If set in an intent passed to android.content.Context#startActivity, this flag will only launch the intent if it resolves to a result that is not a browser. If no such result exists, an ActivityNotFoundException will be thrown.

If set, and this activity is either being started in a new task or bringing to the top an existing task, then it will be launched as the front door of the task. This will result in the application of any affinities needed to have that task in the proper state (either moving activities to or from it), or simply resetting that task to its initial state if needed.

By default a document created by FLAG_ACTIVITY_NEW_DOCUMENT will have its entry in recent tasks removed when the user closes it (with back or however else it may finish()). If you would like to instead allow the document to be kept in recents so that it can be re-launched, you can use this flag. When set and the task's activity is finished, the recents entry will remain in the interface for the user to re-launch it, like a recents entry for a top-level application.

The receiving activity can override this request with android.R.attr#autoRemoveFromRecents or by explcitly calling Activity.finishAndRemoveTask().

If set, the activity will not be launched if it is already running at the top of the history stack. See Tasks and Back Stack for more information.

If set in an Intent passed to android.content.Context#startActivity, this flag will cause a newly launching task to be placed on top of the current home activity task (if there is one). That is, pressing back from the task will always return the user to home even if that was not the last activity they saw. This can only be used in conjunction with FLAG_ACTIVITY_NEW_TASK.

A flag you can enable for debugging: when set, log messages will be printed during the resolution of this intent to show you what has been found to create the final resolved list.

Flag used to automatically match intents based on their Direct Boot awareness and the current user state.

Since the default behavior is to automatically apply the current user state, this is effectively a sentinel value that doesn't change the output of any queries based on its presence or absence.

Instead, this value can be useful in conjunction with android.os.StrictMode.VmPolicy.Builder#detectImplicitDirectBoot() to detect when a caller is relying on implicit automatic matching, instead of confirming the explicit behavior they want.

If set, this intent will not match any components in packages that are currently stopped. If this is not set, then the default behavior is to include such applications in the result.

Can be set by the caller to indicate that this Intent is coming from a background operation, not from direct user interaction.

When combined with FLAG_GRANT_READ_URI_PERMISSION and/or FLAG_GRANT_WRITE_URI_PERMISSION, the URI permission grant can be persisted across device reboots until explicitly revoked with Context#revokeUriPermission(Uri, int). This flag only offers the grant for possible persisting; the receiving application must call ContentResolver#takePersistableUriPermission(Uri, int) to actually persist.

When combined with FLAG_GRANT_READ_URI_PERMISSION and/or FLAG_GRANT_WRITE_URI_PERMISSION, the URI permission grant applies to any URI that is a prefix match against the original granted URI. (Without this flag, the URI must match exactly for access to be granted.) Another URI is considered a prefix match only when scheme, authority, and all path segments defined by the prefix are an exact match.

If set, the recipient of this Intent will be granted permission to perform read operations on the URI in the Intent's data and any URIs specified in its ClipData. When applying to an Intent's ClipData, all URIs as well as recursive traversals through data or other ClipData in Intent items will be granted; only the grant flags of the top-level Intent are used.

If set, the recipient of this Intent will be granted permission to perform write operations on the URI in the Intent's data and any URIs specified in its ClipData. When applying to an Intent's ClipData, all URIs as well as recursive traversals through data or other ClipData in Intent items will be granted; only the grant flags of the top-level Intent are used.

If set, this intent will always match any components in packages that are currently stopped. This is the default behavior when FLAG_EXCLUDE_STOPPED_PACKAGES is not set. If both of these flags are set, this one wins (it allows overriding of exclude for places where the framework may automatically set the exclude flag, such as broadcasts).

If set, when sending a broadcast the recipient is allowed to run at foreground priority, with a shorter timeout interval. During normal broadcasts the receivers are not automatically hoisted out of the background priority class.

If this is an ordered broadcast, don't allow receivers to abort the broadcast. They can still propagate results through to later receivers, but they can not prevent later receivers from seeing the broadcast.

If set, when sending a broadcast only registered receivers will be called -- no BroadcastReceiver components will be launched.

If set, when sending a broadcast the new broadcast will replace any existing pending broadcast that matches it. Matching is defined by Intent.filterEquals returning true for the intents of the two broadcasts. When a match is found, the new broadcast (and receivers associated with it) will replace the existing one in the pending broadcast list, remaining at the same position in the list.

This flag is most typically used with sticky broadcasts, which only care about delivering the most recent values of the broadcast to their receivers.

If set, the broadcast will be visible to receivers in Instant Apps. By default Instant Apps will not receive broadcasts. This flag has no effect when used by an Instant App.

Boolean that can be supplied as meta-data with a dock activity, to indicate that the dock should take over the home key when it is active.

Flag for use with toUri and parseUri: allow parsing of unsafe information. In particular, the flags FLAG_GRANT_READ_URI_PERMISSION, FLAG_GRANT_WRITE_URI_PERMISSION, FLAG_GRANT_PERSISTABLE_URI_PERMISSION, and FLAG_GRANT_PREFIX_URI_PERMISSION flags can not be set, so that the generated Intent can not cause unexpected data access to happen.

If you do not trust the source of the URI being parsed, you should still do further processing to protect yourself from it. In particular, when using it to start an activity you should usually add in CATEGORY_BROWSABLE to limit the activities that can handle it.

Flag for use with toUri and parseUri: the URI string always has the "android-app:" scheme. This is a variation of URI_INTENT_SCHEME whose format is simpler for the case of an http/https URI being delivered to a specific package name. The format is:

android-app://{package_id}[/{scheme}[/{host}[/{path}]]][#Intent;{...}]

In this scheme, only the package_id is required. If you include a host, you must also include a scheme; including a path also requires both a host and a scheme. The final #Intent; fragment can be used without a scheme, host, or path. Note that this can not be used with intents that have a setSelector, since the base intent will always have an explicit package name.

Some examples of how this scheme maps to Intent objects:

Flag for use with toUri and parseUri: the URI string always has the "intent:" scheme. This syntax can be used when you want to later disambiguate between URIs that are intended to describe an Intent vs. all others that should be treated as raw URIs. When used with parseUri, any other scheme will result in a generic VIEW action for that raw URI.

Descriptor bit used with describeContents(): indicates that the Parcelable object's flattened representation includes a file descriptor.

Flag for use with writeToParcel: the object being written is a return value, that is the result of a function such as "Parcelable someFunction()", "void someFunction(out Parcelable)", or "void someFunction(inout Parcelable)". Some implementations may want to release resources at this point.