syntax:
:

    ```xml
    <activity android:allowEmbedded=["true" | "false"]
              android:allowTaskReparenting=["true" | "false"]
              android:alwaysRetainTaskState=["true" | "false"]
              android:autoRemoveFromRecents=["true" | "false"]
              android:banner="drawable resource"
              android:canDisplayOnRemoteDevices=["true" | "false"]
              android:clearTaskOnLaunch=["true" | "false"]
              android:colorMode=[ "hdr" | "wideColorGamut"]
              android:configChanges=["colorMode", "density",
                                     "fontScale", "fontWeightAdjustment",
                                     "grammaticalGender", "keyboard",
                                     "keyboardHidden", "layoutDirection", "locale",
                                     "mcc", "mnc", "navigation", "orientation",
                                     "screenLayout", "screenSize",
                                     "smallestScreenSize", "touchscreen", "uiMode"]
              android:directBootAware=["true" | "false"]
              android:documentLaunchMode=["intoExisting" | "always" |
                                      "none" | "never"]
              android:enabled=["true" | "false"]
              android:enableOnBackInvokedCallback=["true" | "false"]
              android:excludeFromRecents=["true" | "false"]
              android:exported=["true" | "false"]
              android:finishOnTaskLaunch=["true" | "false"]
              android:hardwareAccelerated=["true" | "false"]
              android:icon="drawable resource"
              android:immersive=["true" | "false"]
              android:label="string resource"
              android:launchMode=["standard" | "singleTop" |
                                  "singleTask" | "singleInstance" | "singleInstancePerTask"]
              android:lockTaskMode=["normal" | "never" |
                                  "if_whitelisted" | "always"]
              android:maxRecents="integer"
              android:maxAspectRatio="float"
              android:minAspectRatio="float"
              android:multiprocess=["true" | "false"]
              android:name="string"
              android:noHistory=["true" | "false"]  
              android:parentActivityName="string" 
              android:persistableMode=["persistRootOnly" | 
                                       "persistAcrossReboots" | "persistNever"]
              android:permission="string"
              android:process="string"
              android:relinquishTaskIdentity=["true" | "false"]
              android:requireContentUriPermissionFromCaller=["none" | "read" | "readAndWrite" |
                                                             "readOrWrite" | "write"] 
              android:resizeableActivity=["true" | "false"]
              android:screenOrientation=["unspecified" | "behind" |
                                         "landscape" | "portrait" |
                                         "reverseLandscape" | "reversePortrait" |
                                         "sensorLandscape" | "sensorPortrait" |
                                         "userLandscape" | "userPortrait" |
                                         "sensor" | "fullSensor" | "nosensor" |
                                         "user" | "fullUser" | "locked"]
              android:showForAllUsers=["true" | "false"]
              android:stateNotNeeded=["true" | "false"]
              android:supportsPictureInPicture=["true" | "false"]
              android:taskAffinity="string"
              android:theme="resource or theme"
              android:uiOptions=["none" | "splitActionBarWhenNarrow"]
              android:windowSoftInputMode=["stateUnspecified",
                                           "stateUnchanged", "stateHidden",
                                           "stateAlwaysHidden", "stateVisible",
                                           "stateAlwaysVisible", "adjustUnspecified",
                                           "adjustResize", "adjustPan"] >   
        ...
    </activity>
    ```

contained in:
:   [<application>](https://developer.android.com/guide/topics/manifest/application-element)

can contain:
:   [<intent-filter>](https://developer.android.com/guide/topics/manifest/intent-filter-element)

    [<meta-data>](https://developer.android.com/guide/topics/manifest/meta-data-element)

    [<layout>](https://developer.android.com/guide/topics/manifest/layout-element)

description:
:   Declares an activity (an [Activity](https://developer.android.com/reference/android/app/Activity) subclass) that
    implements part of the application's visual user interface. All activities
    must be represented by `<activity>`
    elements in the manifest file. Any that aren't declared there aren't seen
    by the system and never run.

attributes:
:

    `android:allowEmbedded`

    :   Indicates that the activity can be launched as the embedded child of another
        activity, particularly in the case where the child lives in a container,
        such as a `Display` owned by another activity. For example, activities
        that are used for Wear custom notifications declare this so
        Wear can display the activity in its context stream, which resides
        in another process.

        The default value of this attribute is `false`.

    `android:allowTaskReparenting`
    :   Whether the activity can move from the task that started it to
        the task it has an affinity for when that task is next brought to the
        front. It's `"true"` if it can move, and `"false"` if it
        remains with the task where it started.


        If this attribute isn't set, the value set by the corresponding
        [allowTaskReparenting](https://developer.android.com/guide/topics/manifest/application-element#reparent)
        attribute of the [<application>](https://developer.android.com/guide/topics/manifest/application-element) element
        applies to the activity. The default value is `"false"`.


        Normally, when an activity is started it's associated with the task of
        the activity that started it and it stays there for its entire lifetime.
        You can use this attribute to force it to be re-parented to the task it
        has an affinity for when its current task is no longer displayed.
        Typically, this is used to cause the activities of an application to move
        to the main task associated with that application.


        For example, if an email message contains a link to a web page, clicking
        the link brings up an activity that can display the page. That activity
        is defined by the browser application but is launched as part of the email
        task. If it's reparented to the browser task, it shows when the
        browser next comes to the front and is absent when the email task
        again comes forward.


        The affinity of an activity is defined by the
        [taskAffinity](https://developer.android.com/guide/topics/manifest/activity-element#aff) attribute. The affinity
        of a task is determined by reading the affinity of its root activity.
        Therefore, by definition, a root activity is always in a task with the
        same affinity. Since activities with `"singleTask"` or
        `"singleInstance"` launch modes can only be at the root of a task,
        re-parenting is limited to the `"standard"` and `"singleTop"`
        modes. (See also the [launchMode](https://developer.android.com/guide/topics/manifest/activity-element#lmode)
        attribute.)

    `android:alwaysRetainTaskState`
    :   Whether the state of the task that the activity is in is always
        maintained by the system. `"true"` if it is, and
        `"false"` if the system can reset the task to its initial
        state in certain situations. The default value is `"false"`. This
        attribute is meaningful only for the root activity of a task. It's ignored
        for all other activities.


        Normally, the system clears a task, removing all activities from the stack
        above the root activity, in certain situations when the user re-selects that
        task from the home screen. Typically, this is done if the user hasn't visited
        the task for a certain amount of time, such as 30 minutes.


        However, when this attribute is `"true"`, users always return
        to the task in its last state, regardless of how they get there. This is
        useful in an application like a web browser where there is
        a lot of state, such as multiple open tabs, that users don't want to lose.

    `android:autoRemoveFromRecents`
    :   Whether tasks launched by the activity with this attribute remain in the
        [Recents screen](https://developer.android.com/guide/components/recents) until the last activity in the
        task completes. If `true`, the task is
        automatically removed from the Recents screen. This overrides the caller's use of
        [FLAG_ACTIVITY_RETAIN_IN_RECENTS](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_RETAIN_IN_RECENTS). It must be a boolean value, either
        `"true"` or `"false"`.

    `android:banner`
    :   A [drawable resource](https://developer.android.com/guide/topics/resources/drawable-resource)
        providing an extended graphical banner for its associated item. Use with the
        `<activity>` tag to supply a default banner for a specific activity or with the
        [`<application>`](https://developer.android.com/guide/topics/manifest/application-element)
        tag to supply a banner for all application activities.

        The system uses the banner to represent an app in
        the Android TV home screen. Since the banner displays only in the home screen, it
        is only specified by applications with an activity that handles the
        [CATEGORY_LEANBACK_LAUNCHER](https://developer.android.com/reference/android/content/Intent#CATEGORY_LEANBACK_LAUNCHER) intent.


        This attribute is set as a reference to a drawable resource containing
        the image, such as `"@drawable/banner"`. There is no default banner.


        For more information, see [Provide a home screen banner](https://developer.android.com/training/tv/start/start#banner) in Get Started with TV Apps.

    `android:canDisplayOnRemoteDevices`

    :   Indicates whether the activity can be displayed on a remote device which
        may or may not be running Android. It must be a boolean value, either
        `"true"` or `"false"`.

        The default value of this attribute is `"true"`.

    `android:clearTaskOnLaunch`
    :   Whether all activities are removed from the task, except for
        the root activity, when it is re-launched from the home screen.
        `"true"` if the task is always stripped down to its root activity, and
        `"false"` if not. The default value is `"false"`. This attribute
        is meaningful only for activities that start a new task---the root activity.
        It's ignored for all other activities in the task.


        When the value is `"true"`, every time users start the task, they
        are brought to its root activity regardless of what they were last doing in
        the task and regardless of whether they used the Back or Home button to
        leave it. When the value is `"false"`, the task can be cleared of activities in
        some situations, but not always. For more information, see the
        [alwaysRetainTaskState](https://developer.android.com/guide/topics/manifest/activity-element#always) attribute.


        Suppose the user launches activity P from the home screen,
        and from there goes to activity Q. The user next taps Home, and then returns
        to activity P. Normally, the user sees activity Q, since that is what they
        were last doing in P's task. However, if P set this flag to `"true"`, all
        of the activities on top of it---in this case, Q---are removed when the user launches
        activity P from the home screen. So, the user sees only P when returning to the task.


        If this attribute and [allowTaskReparenting](https://developer.android.com/guide/topics/manifest/activity-element#reparent)
        are both `"true"`, any activities that can be re-parented are moved to
        the task they share an affinity with. The remaining activities are then dropped.


        This attribute is ignored if [FLAG_ACTIVITY_RESET_TASK_IF_NEEDED](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) isn't set.

    `android:colorMode`

    :   Specifies the activity's color mode. If specified, can be either `hdr` or
        `wideColorGamut`.

        If `hdr`, requests that the activity be displayed in a high dynamic range if the
        device supports it.
        | **Note:** For performance reasons, we do not recommend turning on HDR in the manifest. Instead, if your app is displaying HDR images, you should call [`setColorMode()`](https://developer.android.com/reference/android/view/Window#setColorMode(int)) to dynamically switch the activity to HDR mode at run time. For more information, see [Display Ultra HDR images](https://developer.android.com/media/grow/ultra-hdr-display).

        If `wideColorGamut`, requests that the activity be displayed in wide color gamut mode
        on compatible devices. In wide color gamut mode, a window can render outside of the
        [SRGB](https://developer.android.com/reference/android/graphics/ColorSpace.Named#SRGB) gamut to
        display more vibrant colors. If the device doesn't support wide color gamut rendering, this
        attribute has no effect. For more information about rendering in wide color mode, see
        [Enhance graphics with wide color content](https://developer.android.com/training/wide-color-gamut).

    `android:configChanges`
    :   Lists configuration changes that the activity handles itself. When a configuration
        change occurs at runtime, the activity shuts down and restarts by default, but declaring a
        configuration with this attribute prevents the activity from restarting. Instead, the
        activity remains running and its [onConfigurationChanged()](https://developer.android.com/reference/android/app/Activity#onConfigurationChanged(android.content.res.Configuration)) method is called.

        **Note:** Use this attribute only in special cases to improve application
        performance and responsiveness. For more information, see [Handle configuration changes](https://developer.android.com/guide/topics/resources/runtime-changes).


        The following strings are valid values for this attribute. Multiple values are
        separated by `|`, such as `"locale|navigation|orientation"`.


        | Value | Description |
        |---|---|
        | `"colorMode"` | The color mode capabilities of the screen (color gamut or dynamic range) have changed. **Note:** The color mode the activity requests with the `colorMode` attribute or at runtime is distinct from the capability for different color modes. An activity changing the color mode it is using does not cause a configuration change, because the color capabilities of the display have not changed. |
        | `"density"` | A change to the display density, such as when the user specifies a different display scale or a different display is now active. *Added in API level 24*. |
        | `"fontScale"` | A change to the font scaling factor, such as when the user selects a new global font size. |
        | `"fontWeightAdjustment"` | The amount of the font weight increase has changed. |
        | `"grammaticalGender"` | The grammatical gender of the language has changed. See [`GrammaticalInflectionManager`](https://developer.android.com/reference/kotlin/android/app/GrammaticalInflectionManager). *Added in API level 34*. |
        | `"keyboard"` | A change to the keyboard type, such as when the user plugs in an external keyboard. |
        | `"keyboardHidden"` | A change to the keyboard accessibility, such as when the user reveals the hardware keyboard. |
        | `"layoutDirection"` | A change to the layout direction, such as from left-to-right (LTR) to right-to-left (RTL). *Added in API level 17*. |
        | `"locale"` | A change to the locale, such as when the user selects a new language that text displays in. |
        | `"mcc"` | A change to the IMSI mobile country code (MCC) when a SIM is detected that updates the MCC. |
        | `"mnc"` | A change to the IMSI mobile network code (MNC) when a SIM is detected that updates the MNC. |
        | `"navigation"` | TA change to the navigation type (trackball or D-pad). Normally, this does not happen. |
        | `"orientation"` | A change to the screen orientation, such as when the user rotates the device. **Note:** If your application targets Android 3.2 (API level 13) or higher, also declare the `"screenLayout"` and `"screenSize"` configurations, because screen layout and screen size can change when a device switches between portrait and landscape orientations. |
        | `"screenLayout"` | A change to the screen layout, such as when a different display becomes active. |
        | `"screenSize"` | A change to the current available screen size. This represents a change in the currently available size, relative to the current aspect ratio, so it changes when the user switches between landscape and portrait. *Added in API level 13*. |
        | `"smallestScreenSize"` | A change to the physical screen size. This represents a change in size regardless of orientation, so it only changes when the actual physical screen size changes, such as switching to an external display. A change to this configuration corresponds to a change in the [`smallestWidth` configuration](https://developer.android.com/guide/topics/resources/providing-resources#SmallestScreenWidthQualifier). *Added in API level 13*. |
        | `"touchscreen"` | A change to touchscreen mode, such as when the user connects or disconnects an input peripheral or moves the app between different displays. |
        | `"uiMode"` | A change to the user interface mode, such as when the user places the device into a desk or car dock, or the night mode changes. For more information about the different UI modes, see [UiModeManager](https://developer.android.com/reference/android/app/UiModeManager). *Added in API level 8*. |


        All these configuration changes can impact the resource values seen by the
        application. Therefore, when
        [onConfigurationChanged()](https://developer.android.com/reference/android/app/Activity#onConfigurationChanged(android.content.res.Configuration))
        is called, it is usually necessary to again
        retrieve all resources, including view layouts and drawables, to correctly handle the change.


        **Note:** To handle [multi-window](https://developer.android.com/guide/topics/ui/multi-window) related configuration changes, use both `"screenLayout"` and `"smallestScreenSize"`. Multi-window is supported in Android 7.0 (API level 24) or higher.

    `android:directBootAware`

    :   Whether the activity is *Direct-Boot aware*---that is,
        whether it can run before the user unlocks the device.

        **Note:** During
        [Direct Boot](https://developer.android.com/training/articles/direct-boot), an activity in
        your application can only access the data that is stored in
        *device protected* storage.

        The default value is `"false"`.

    `android:documentLaunchMode`
    :   Specifies how a new instance of an activity is added to a task each time it is launched.
        This attribute permits the user to have multiple documents from the same application
        appear in the [Recents screen](https://developer.android.com/guide/components/recents).

        This attribute has four values, which produce the following effects when the user opens a document
        with the application:


        | Value | Description |
        |---|---|
        | `"intoExisting"` | The system searches for a task whose base intent's `ComponentName` and data URI match those of the launching intent. If the system finds such a task, the system clears the task and restarts, with the root activity receiving a call to [onNewIntent(android.content.Intent)](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent)). If the system doesn't find such a task, the system creates a new task. |
        | `"always"` | The activity creates a new task for the document, even if the document is already opened. This is the same as setting both the [FLAG_ACTIVITY_NEW_DOCUMENT](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_DOCUMENT) and [FLAG_ACTIVITY_MULTIPLE_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_MULTIPLE_TASK) flags. |
        | `"none"` | The activity doesn't create a new task for the activity. This is the default value, which creates a new task only when [FLAG_ACTIVITY_NEW_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_TASK) is set. The Recents screen treats the activity as it does by default: it displays a single task for the app, which resumes from whatever activity the user last invoked. |
        | `"never"` | The activity isn't launched into a new document even if the intent contains [FLAG_ACTIVITY_NEW_DOCUMENT](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_DOCUMENT). Setting this overrides the behavior of the `FLAG_ACTIVITY_NEW_DOCUMENT` and [FLAG_ACTIVITY_MULTIPLE_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_MULTIPLE_TASK) flags, if either of these are set in the activity, and the Recents screen displays a single task for the app, which resumes from whatever activity the user last invoked. |


        **Note:** For values other than `"none"` and `"never"`, the
        activity is defined with `launchMode="standard"`. If this attribute isn't specified,
        `documentLaunchMode="none"` is used.

    `android:enabled`
    :   Whether the activity can be instantiated by the system. It's
        `"true"` if it can be, and `"false"` if not. The default value
        is `"true"`.


        The [<application>](https://developer.android.com/guide/topics/manifest/application-element)
        element has its own [enabled](https://developer.android.com/guide/topics/manifest/application-element#enabled)
        attribute that applies to all application components, including activities. The
        `<application>`
        and `<activity>` attributes must both be `"true"`, as they both
        are by default, for the system to be able to instantiate the activity. If either
        is `"false"`, it can't be instantiated.

    `android:enableOnBackInvokedCallback`

    :   This flag lets you opt out of predictive system animations at the activity level.


        Set `android:enableOnBackInvokedCallback=false` to turn off predictive back animations at the activity
        level and instruct the system to ignore calls to the `OnBackInvokedCallback` platform API.

    `android:excludeFromRecents`

    :   Whether the task initiated by this activity is excluded from the [Recents screen](https://developer.android.com/guide/components/recents). That is, when this activity is the root activity of a new
        task, this attribute determines whether the task appears in the list of recent apps. It's
        `"true"` if the task is *excluded* from the list; `"false"` if it
        is *included* . The default value is `"false"`.

    `android:exported`

    :   Whether the activity can be launched by components of other
        applications:

        - If `"true"`, the activity is accessible to any app, and is launchable by its exact class name.
        - If `"false"`, the activity can be launched only by components of the same application, applications with the same user ID, or privileged system components. This is the default value when there are no intent filters.


        If an activity in your app includes intent filters, set this element to
        `"true"` to let other apps start it.
        For example, if the activity is the main activity
        of the app and includes the [category](https://developer.android.com/guide/topics/manifest/category-element)
        [android.intent.category.LAUNCHER](https://developer.android.com/reference/android/content/Intent#CATEGORY_LAUNCHER).


        If this element is set to `"false"` and an app tries to start the activity, the system throws an
        [ActivityNotFoundException](https://developer.android.com/reference/android/content/ActivityNotFoundException).


        This attribute isn't the only way to limit an activity's exposure to other
        applications. Permissions are also used to limit the external entities that
        can invoke the activity. See the
        [permission](https://developer.android.com/guide/topics/manifest/activity-element#prmsn)
        attribute.

    `android:finishOnTaskLaunch`
    :   Whether an existing instance of the activity is shut down,
        except for the root activity, when the user re-launches its task by choosing the task on the
        home screen. It's `"true"` if it is shut down, and `"false"`
        if not. The default value is `"false"`.


        If this attribute and
        [allowTaskReparenting](https://developer.android.com/guide/topics/manifest/activity-element#reparent)
        are both `"true"`, this attribute trumps the other. The affinity of the
        activity is ignored. The activity isn't re-parented, but destroyed.


        This attribute is ignored if [FLAG_ACTIVITY_RESET_TASK_IF_NEEDED](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) isn't set.

    `android:hardwareAccelerated`
    :   Whether hardware-accelerated rendering is enabled for this
        activity. `"true"` if it is enabled, and `"false"` if
        not. The default value is `"false"`.


        On Android 3.0 and higher, a hardware-accelerated OpenGL renderer is
        available to applications to improve performance for many common 2D graphics
        operations. When the hardware-accelerated renderer is enabled, most operations
        in Canvas, Paint, Xfermode, ColorFilter, Shader, and Camera are accelerated.


        This results in smoother animations, smoother scrolling, and improved
        responsiveness overall, even for applications that don't explicitly make use
        the framework's OpenGL libraries. Because of the increased resources required to
        enable hardware acceleration, your app consumes more RAM.


        Not all of the OpenGL 2D operations are accelerated. If you enable
        the hardware-accelerated renderer, test whether your application can
        use the renderer without errors.

    `android:icon`

    :   An icon representing the activity. The icon is displayed to users when
        a representation of the activity is required on-screen. For example, icons
        for activities that initiate tasks are displayed in the launcher window.
        The icon is often accompanied by a label; for information about the label, see the [`android:label`](https://developer.android.com/guide/topics/manifest/activity-element#label) attribute.


        This attribute is set as a reference to a drawable resource containing
        the image definition. If it isn't set, the icon specified for the application
        as a whole is used instead. For more information, see the
        [<application>](https://developer.android.com/guide/topics/manifest/application-element)
        element's [icon](https://developer.android.com/guide/topics/manifest/application-element#icon) attribute.


        The activity's icon, whether set here or by the
        `<application>`
        element, is also the default icon for all the activity's intent filters. For more information, see the
        [<intent-filter>](https://developer.android.com/guide/topics/manifest/intent-filter-element) element's
        [icon](https://developer.android.com/guide/topics/manifest/intent-filter-element#icon) attribute.

    `android:immersive`
    :   Sets the immersive mode setting for the current activity. If it's `"true"`, the [ActivityInfo.flags](https://developer.android.com/reference/android/content/pm/ActivityInfo#flags) member always has its
        [FLAG_IMMERSIVE](https://developer.android.com/reference/android/content/pm/ActivityInfo#FLAG_IMMERSIVE) bit set, even if the
        immersive mode changes at runtime using the [setImmersive()](https://developer.android.com/reference/android/app/Activity#setImmersive(boolean)) method.

    `android:label`

    :   A user-readable label for the activity. The label displays on-screen
        when the activity is represented to the user. It's often displayed along
        with the activity icon. If this attribute isn't set, the label set for the application as a whole is
        used instead. see the [<application>](https://developer.android.com/guide/topics/manifest/application-element) element's
        [label](https://developer.android.com/guide/topics/manifest/application-element#label) attribute.


        The activity's label, whether set here or by the
        `<application>` element, is also the
        default label for all the activity's intent filters. For more information, see the
        [<intent-filter>](https://developer.android.com/guide/topics/manifest/intent-filter-element) element's
        [label](https://developer.android.com/guide/topics/manifest/intent-filter-element#label) attribute.


        The label is set as a reference to a string resource so that
        it can be localized like other strings in the user interface.
        However, as a convenience while you're developing the application,
        it can also be set as a raw string.

    `android:launchMode`

    :   An instruction for how the activity launches. There are five modes,
        which work in conjunction with activity flags (`FLAG_ACTIVITY_*` constants)
        in [Intent](https://developer.android.com/reference/android/content/Intent) objects to determine what happens when
        the activity is called upon to handle an intent:

        `"standard"`

        `"singleTop"`

        `"singleTask"`

        `"singleInstance"`

        `"singleInstancePerTask"`


        The default mode is `"standard"`.


        As shown in the following table, the modes fall into two main groups, with
        `"standard"` and `"singleTop"` activities on one side, and
        `"singleTask"`, `"singleInstance"`, and
        `"singleInstancePerTask"` activities on the other. An activity with the
        `"standard"` or `"singleTop"` launch mode
        can be instantiated multiple times.

        The instances can belong to any task
        and can be located anywhere in the activity task. Typically, they're
        launched into the task that called
        [startActivity()](https://developer.android.com/reference/android/content/Context#startActivity(android.content.Intent)), unless the `Intent` object contains a
        [FLAG_ACTIVITY_NEW_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_TASK)
        instruction, in which case a different task is chosen. For more information, see the
        [`taskAffinity`](https://developer.android.com/guide/topics/manifest/activity-element#aff) attribute.


        In contrast, `"singleTask"`, `"singleInstance"`, and
        `"singleInstancePerTask"` activities have different behaviors.
        `"singleInstancePerTask"` is always at the root of the activity task.
        Also, the device can hold only one instance of the
        `"singleInstance"` activity at a time, while the
        `"singleInstancePerTask` activity can be instantiated multiple times
        in different tasks when
        [FLAG_ACTIVITY_MULTIPLE_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_MULTIPLE_TASK)
        or
        [FLAG_ACTIVITY_NEW_DOCUMENT](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_DOCUMENT)
        is set.

        An activity with the `"singleTask"` launch mode combines the
        behaviors of `"singleInstance"` and
        `"singleInstancePerTask"`: the activity can be instantiated multiple
        times and can be located anywhere in a task of the same `taskAffinity`.
        But the device can only hold one task for locating the
        `"singleTask"` activity at the root of the activity task.


        The `"standard"` and `"singleTop"` modes differ from each other
        in one respect: every time there's a new intent for a `"standard"`
        activity, a new instance of the class is created to respond to that intent.
        Each instance handles a single intent.
        Similarly, a new instance of a `"singleTop"` activity can also be
        created to handle a new intent.

        However, if the target task already has an
        existing instance of the activity at the top of its stack, that instance
        receives the new intent, in an
        [onNewIntent()](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent)) call.
        A new instance isn't created.
        Otherwise---if an existing instance of the
        `"singleTop"` activity is in the target task but not at the top of
        the stack, or if it's at the top of a stack, but not in the target task---a new instance is
        created and pushed on the stack.

        Similarly, if the user
        [navigates
        up](https://developer.android.com/training/implementing-navigation/ancestral) to an activity on the current stack, the behavior is determined by the
        parent activity's launch mode. If the parent activity has launch mode `singleTop` (or the `up` intent contains [FLAG_ACTIVITY_CLEAR_TOP](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_CLEAR_TOP)), the parent is brought to the
        top of the stack, and its state is preserved.

        The navigation intent is received
        by the parent activity's [onNewIntent()](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent))
        method. If the parent activity has launch mode `standard`, and the
        `up` intent doesn't contain `FLAG_ACTIVITY_CLEAR_TOP`, the current activity and its
        parent both pop off the stack, and a new instance of the parent activity is created to receive the navigation intent.


        The `"singleInstance"` mode also differs from `"singleTask"`
        and `"singleInstancePerTask"` in only one respect: an activity with the
        `"singleTask"` or `"singleInstancePerTask"` launch mode
        lets other activities, necessarily `"standard"` and
        `"singleTop"` activities, be part of its task.

        A
        `"singleInstance"` activity, on the other hand, permits no other
        activities to be part of its task. It must be the only activity in the task. If it
        starts another activity, that activity is assigned to a different task, as
        if `FLAG_ACTIVITY_NEW_TASK` were in the intent.

        | Use cases | Launch mode | Multiple instances? | Comments |
        |---|---|---|---|
        | Normal launches for most activities | `"standard"` | Yes | Default. The system always creates a new instance of the activity in the target task and routes the intent to it. |
        | Normal launches for most activities | `"singleTop"` | Conditionally | If an instance of the activity already exists at the top of the target task, the system routes the intent to that instance through a call to its [onNewIntent()](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent)) method, rather than creating a new instance of the activity. |
        | Specialized launches *(not recommended for general use)* | `"singleTask"` | Conditionally | The system creates the activity at the root of a new task or locates the activity on an existing task with the same affinity. If an instance of the activity already exists and is at the root of the task, the system routes the intent to existing instance through a call to its [onNewIntent()](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent)) method, rather than creating a new one. |
        | Specialized launches *(not recommended for general use)* | `"singleInstance"` | No | Same as `"singleTask"`, except that the system doesn't launch any other activities into the task holding the instance. The activity is always the single and only member of its task. |
        | Specialized launches *(not recommended for general use)* | `"singleInstancePerTask"` | Conditionally | The activity can only run as the root activity of the task, the first activity that created the task, and therefore there is only one instance of this activity in a task. However, the activity can be instantiated multiple times in different tasks. |

        As shown in the preceding table, `"standard"` is the default mode and is
        appropriate for most types of activities. `"singleTop"` is also a
        common and useful launch mode for many types of activities. The other modes,
        `"singleTask"` , `"singleInstance"`, and `"singleInstancePerTask"`, are
        *not appropriate* for most applications.
        They result in an interaction model that is likely to be unfamiliar to
        users and is very different from most other applications.

        Regardless of the launch mode that you choose, make sure to test the usability
        of the activity during launch and when navigating back to it from
        other activities and tasks using the Back button.

        For more information about launch modes and their interaction with `Intent`
        flags, see
        [Tasks and the back stack](https://developer.android.com/guide/components/tasks-and-back-stack).

    `android:lockTaskMode`
    :   Determines how the system presents this activity when the device is running in
        [lock task mode](https://developer.android.com/work/dpc/dedicated-devices/lock-task-mode).

        Android can run tasks in an immersive, kiosk-like fashion called lock task mode. When the system
        runs in lock task mode, device users typically can't see notifications, access non-allowlisted apps,
        or return to the home screen, unless the Home app is allowlisted.

        Only apps that are
        allowlisted by a device policy controller (DPC) can run when the system is in lock task mode. System
        and [privileged apps](https://source.android.com/devices/tech/config/perms-allowlist),
        however, can run in lock task mode without being allowlisted.


        The value can be any one of the following
        [`R.attr.lockTaskMode`](https://developer.android.com/reference/android/R.attr#lockTaskMode) string values:


        | Value | Description |
        |---|---|
        | `"normal"` | **Default value.** This is the default value. Tasks don't launch into lock task mode but can be placed there by calling [`startLockTask()`](https://developer.android.com/reference/android/app/Activity#startLockTask()). |
        | `"never"` | Tasks don't launch into `lockTask` mode, and the device user can't pin these tasks from the Recents screen. **Note:** This mode is only available to system and privileged applications. Non-privileged apps with this value are treated as `normal`. |
        | `"if_whitelisted"` | If the DPC authorizes this package using [`DevicePolicyManager.setLockTaskPackages()`](https://developer.android.com/reference/android/app/admin/DevicePolicyManager#setLockTaskPackages(android.content.ComponentName,%20java.lang.String[])), then this mode is identical to `always`, except that the activity needs to call [`stopLockTask()`](https://developer.android.com/reference/android/app/Activity#stopLockTask()) before being able to finish if it is the last locked task. If the DPC doesn't authorize this package then this mode is identical to `normal`. |
        | `"always"` | Tasks rooted at this activity always launch into lock task mode. If the system is already in lock task mode when this task is launched, then the new task is launched on top of the current task. Tasks launched in this mode can exit lock task mode by calling [`finish()`](https://developer.android.com/reference/android/app/Activity#finish()). **Note:** This mode is only available to system and privileged applications. Non-privileged apps with this value are treated as `normal`. |


        This attribute was introduced in API level 23.

    `android:maxRecents`
    :   The maximum number of tasks rooted at this activity in the [Recents screen](https://developer.android.com/guide/components/recents). When this number of entries is reached, the system removes the least-recently
        used instance from the Recents screen. Valid values are integers from 1 through 50, or 1 through 25 on low-memory devices.
        Zero is invalid. The default value is 16.

    `android:maxAspectRatio`

    :   The maximum aspect ratio the activity supports.

        | **Warning:** To improve the layout of apps on form factors with smallest width \>= 600dp, the system ignores this attribute for apps that target Android 16 (API level 36). Your app can opt out of the Android 16 behavior, but the opt out will be eliminated in a future release. See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode#android_16).

        If the app runs on a device with a wider aspect ratio, the system automatically letterboxes the app,
        leaving portions of the screen unused so the app can run at its specified maximum aspect ratio.

        Maximum aspect ratio is expressed as the decimal form of the quotient of the device's longer
        dimension divided by its shorter dimension. For example, if the maximum aspect ratio is 7:3,
        set the value of this attribute to 2.33.

        On non-wearable devices, the value of this attribute needs to be 1.33 or greater.
        On wearable devices, it must be 1.0 or greater. Otherwise, the system ignores the
        set value.
        | **Note:**
        |
        | - This attribute is ignored if the activity has [`resizeableActivity`](https://developer.android.com/reference/android/R.attr#resizeableActivity) set to true, since that means your activity supports any aspect ratio.
        | - Device manufacturers can override this attribute to improve the layout of apps.
        | - On devices with Android 16 (API level 36) or higher installed, virtual device owners (select trusted and privileged apps) can configure devices they manage to override (ignore) this attribute to improve app layout. See also [Companion app
        |   streaming](https://source.android.com/docs/core/permissions/app-streaming).
        |
        | See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode).


        For more information about this attribute, see
        [R.attr.maxAspectRatio](https://developer.android.com/reference/android/R.attr#maxAspectRatio).

    `android:minAspectRatio`

    :   The minimum aspect ratio the activity supports.

        | **Warning:** To improve the layout of apps on form factors with smallest width \>= 600dp, the system ignores this attribute for apps that target Android 16 (API level 36). Your app can opt out of the Android 16 behavior, but the opt out will be eliminated in a future release. See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode#android_16).

        If the app runs on a device with a narrower aspect ratio, the system automatically letterboxes the app, leaving
        portions of the screen unused so the app can run at its specified minimum aspect ratio.

        Minimum aspect ratio is expressed as the decimal form of the quotient of the device's longer dimension divided by
        its shorter dimension. For example, if the display aspect ratio is 4:3, set the minimum aspect ratio value to 1.33.

        The value must be greater or equal to 1.0, otherwise the system ignores the set value.
        | **Note:**
        |
        | - This attribute is ignored if the activity has [`resizeableActivity`](https://developer.android.com/reference/android/R.attr#resizeableActivity) set to true, since that means your activity supports any aspect ratio.
        | - Device manufacturers can override this attribute to improve the layout of apps.
        | - On devices with Android 16 (API level 36) or higher installed, virtual device owners (select trusted and privileged apps) can configure devices they manage to override (ignore) this attribute to improve app layout. See also [Companion app
        |   streaming](https://source.android.com/docs/core/permissions/app-streaming).
        |
        | See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode).

        For more information about this attribute, see
        [R.attr.minAspectRatio](https://developer.android.com/reference/android/R.attr#minAspectRatio).

    `android:multiprocess`
    :   Whether an instance of the activity can be launched into the process of the component
        that started it. It's `"true"` if it can be, and `"false"` if not.
        The default value is `"false"`.


        Normally, a new instance of an activity is launched into the process of the
        application that defined it, so all instances of the activity run in the same
        process. However, if this flag is set to `"true"`, instances of the
        activity can run in multiple processes, letting the system create instances
        wherever they are used, provided permissions let it---something that is almost
        never necessary or desirable.

    `android:name`
    :   The name of the class that implements the activity, a subclass of
        [Activity](https://developer.android.com/reference/android/app/Activity). The attribute value is
        normally a fully qualified
        class name, such as, `"com.example.project.ExtracurricularActivity"`.
        However, as a shorthand, if the first character of the name is a period,
        such as `".ExtracurricularActivity"`, it is appended to the
        [namespace](https://developer.android.com/studio/build/configure-app-module#set-namespace) specified in the
        `build.gradle` file.

        Once you publish your application, [don't
        change this name](http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html), unless you set [android:exported](https://developer.android.com/guide/topics/manifest/activity-element#exported)`="false"`. There is no default. The name must be specified.

    `android:noHistory`
    :   Whether the activity is removed from the activity stack and
        finished, by calling its [finish()](https://developer.android.com/reference/android/app/Activity#finish())
        method, when the user navigates away from it and it's no longer
        visible on screen. It's`"true"` if it is finished, and
        `"false"` if not. The default value is `"false"`.


        A value of `"true"` means that the activity doesn't leave a
        historical trace. It doesn't remain in the activity stack for the task,
        so the user isn't able to return to it. In this case,
        [onActivityResult()](https://developer.android.com/reference/android/app/Activity#onActivityResult(int, int, android.content.Intent)) is never called if you
        start another activity for a result from this activity.


        This attribute was introduced in API level 3.

    `android:parentActivityName`
    :   The class name of the logical parent of the activity. The name here must match the class
        name given to the corresponding `<activity>` element's
        [`android:name`](https://developer.android.com/guide/topics/manifest/activity-element#nm) attribute.

        The system reads this attribute to determine which activity to start when
        the user taps the Up button in the action bar. The system can also use this information to
        synthesize a back stack of activities with [TaskStackBuilder](https://developer.android.com/reference/android/app/TaskStackBuilder).


        To support API levels 4 - 16, you can also declare the parent activity with a `<meta-data>` element that specifies a value for `"android.support.PARENT_ACTIVITY"`:

        ```xml
        <activity
            android:name="com.example.app.ChildActivity"
            android:label="@string/title_child_activity"
            android:parentActivityName="com.example.app.MainActivity" >
            <!-- Parent activity meta-data to support API level 4+ -->
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.example.app.MainActivity" />
        </activity>
        ```


        For more information about declaring the parent activity to support Up navigation,
        read [Providing Up
        Navigation](https://developer.android.com/training/implementing-navigation/ancestral).


        This attribute was introduced in API level 16.

    `android:persistableMode`

    :   Defines how an instance of an activity is preserved within a containing
        task across device restarts.

        If the root activity of a task sets this attribute's value to
        `persistRootOnly`, then only the root activity is preserved.
        Otherwise, the activities that are higher up the task's
        [back stack](https://developer.android.com/guide/components/activities/tasks-and-back-stack)
        are examined; any of these activities that set this attribute's value to
        `persistAcrossReboots` are preserved.

        If you use this attribute, you must set its value to one of the
        following:

        | Value | Description |
        |---|---|
        | `persistRootOnly` | **Default value.**When the system restarts, the activity task is preserved, but only the root activity's launching intent is used. When your app's launching intent loads your app's root activity, the activity doesn't receive a [PersistableBundle](https://developer.android.com/reference/android/os/PersistableBundle) object. Therefore, don't use [onSaveInstanceState()](https://developer.android.com/reference/android/app/Activity#onSaveInstanceState(android.os.Bundle, android.os.PersistableBundle)) to preserve the state of your app's root activity across a device restart. **Note:**This attribute value affects your app's behavior only if it's set on your app's root activity. |
        | `persistAcrossReboots` | This activity's state is preserved, along with the state of each activity higher up the [back stack](https://developer.android.com/guide/components/activities/tasks-and-back-stack) that has its own `persistableMode` attribute set to `persistAcrossReboots`. If an activity doesn't have a `persistableMode` attribute that is set to `persistAcrossReboots`, or if it's launched using the [Intent.FLAG_ACTIVITY_NEW_DOCUMENT](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_DOCUMENT) flag, then that activity, along with all activities higher up the back stack, aren't preserved. When an intent loads an activity whose `persistableMode` attribute is set to `persistAcrossReboots` in your app, the activity receives a [PersistableBundle](https://developer.android.com/reference/android/os/PersistableBundle) object in its [onCreate()](https://developer.android.com/reference/android/app/Activity#onCreate(android.os.Bundle, android.os.PersistableBundle)) method. Therefore, you can use [onSaveInstanceState()](https://developer.android.com/reference/android/app/Activity#onSaveInstanceState(android.os.Bundle, android.os.PersistableBundle)) to preserve the state of an activity across a device restart as long as its `persistableMode` attribute is set to `persistAcrossReboots`. **Note:**This attribute value affects your app's behavior even if it's set on an activity other than your app's root activity. |
        | `persistNever` | The activity's state isn't preserved. **Note:**This attribute value affects your app's behavior only if it's set on your app's root activity. |

        This attribute was introduced in API level 21.

    `android:permission`
    :   The name of a permission that clients must have to launch the activity
        or otherwise get it to respond to an intent. If a caller of
        [startActivity()](https://developer.android.com/reference/android/content/Context#startActivity(android.content.Intent)) or
        [startActivityForResult()](https://developer.android.com/reference/android/app/Activity#startActivityForResult(android.content.Intent, int))
        isn't granted the specified permission, its intent isn't delivered to the activity.


        If this attribute isn't set, the permission set by the
        [<application>](https://developer.android.com/guide/topics/manifest/application-element)
        element's
        [permission](https://developer.android.com/guide/topics/manifest/application-element#prmsn)
        attribute applies to the activity. If neither attribute is set, the activity isn't protected by a
        permission.


        For more information on permissions, see the
        [Permissions](https://developer.android.com/guide/topics/manifest/manifest-intro#perms)
        section of the App manifest overview and
        [Security tips](https://developer.android.com/guide/topics/security/security).

    `android:process`

    :   The name of the process in which the activity runs. Normally, all components of an
        application run in a default process name created for the application, and you don't
        need to use this attribute. But if necessary, you can override the default process
        name with this attribute, letting you spread your app components across
        multiple processes.


        If the name assigned to this attribute begins with a colon (`:`), a new
        process, private to the application, is created when it's needed and
        the activity runs in that process.


        If the process name begins with a lowercase character, the activity runs
        in a global process of that name, provided that it has permission to do so.
        This lets components in different applications share a process, reducing
        resource usage.

        The [<application>](https://developer.android.com/guide/topics/manifest/application-element) element's
        [process](https://developer.android.com/guide/topics/manifest/application-element#proc)
        attribute can set a different default process name for all components.

    `android:relinquishTaskIdentity`

    :   Whether the activity relinquishes its task identifiers to an activity above it in the
        task stack. A task whose root activity has this attribute set to `"true"` replaces the base
        `Intent` with that of the next activity in the task.

        If the next activity also has this attribute set
        to `"true"` then it yields the base `Intent` to any activity that it launches in the same
        task. This continues for each activity until an activity is encountered which has this attribute set
        to `"false"`. The default value is `"false"`.

        This attribute set to `"true"` also permits the activity's use of the
        [ActivityManager.TaskDescription](https://developer.android.com/reference/android/app/ActivityManager.TaskDescription) to change labels, colors,
        and icons in the [Recents screen](https://developer.android.com/guide/components/recents).

    `android:requireContentUriPermissionFromCaller`

    :   Specifies permissions necessary to launch this activity when passing
        content URIs. The default value is `none`, meaning no specific
        permissions are required. Setting this attribute restricts activity
        invocation based on the invoker's permissions. If the invoker doesn't have
        the required permissions, the activity start will be denied via a `
        `[SecurityException](https://developer.android.com/reference/java/lang/SecurityException)`
        `.

        Note that the enforcement works for content URIs inside
        [`Intent.getData()`](https://developer.android.com/reference/android/content/Intent#getData()),
        [`Intent.EXTRA_STREAM`](https://developer.android.com/reference/android/content/Intent#EXTRA_STREAM),
        and
        [`Intent.getClipData()`](https://developer.android.com/reference/android/content/Intent#getClipData()).

        May be a string value, using '\\\\;' to escape characters such as '\\\\n' or
        '\\\\uxxxx' for a unicode character;

        Must be one of the following constant values.

        | Constant | Value | Description |
        |---|---|---|
        | none | 0 | Default, no specific permissions are required. |
        | read | 1 | Enforces the invoker to have read access to the passed content URIs. |
        | readAndWrite | 4 | Enforces the invoker to have both read and write access to the passed content URIs. |
        | readOrWrite | 3 | Enforces the invoker to have either read or write access to the passed content URIs. |
        | write | 2 | Enforces the invoker to have write access to the passed content URIs. |

    `android:resizeableActivity`

    :
        Specifies whether the app supports [multi-window mode](https://developer.android.com/guide/topics/ui/multi-window).

        | **Warning:** To improve the layout of apps on form factors with smallest width \>= 600dp, the system ignores this attribute for apps that target Android 16 (API level 36). Your app can opt out of the Android 16 behavior, but the opt out will be eliminated in a future release. See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode#android_16).


        You can set this attribute in either the `<activity>` or
        [`<application>`](https://developer.android.com/guide/topics/manifest/application-element)
        element.


        If you set this attribute to `"true"`, the user can launch the activity in
        split-screen and free-form modes. If you set the attribute to `"false"`, the app
        can't be tested or optimized for a multi-window environment. The system can
        still put the activity in multi-window mode with compatibility mode applied.


        Setting this attribute to `"false"` doesn't guarantee that there are no
        other apps in multi-window mode visible on screen, such as in a picture-in-picture, or
        on other displays. Therefore, setting this flag doesn't mean that your app
        has exclusive resource access.


        If your app targets API level 24 or higher and you do not specify a value
        for this attribute, the attribute's value defaults to `"true"`.


        If your app targets API level 31 or higher, this attribute works differently on small and large
        screens:

        - Large screens (sw \>= 600dp): all apps support multi-window mode. The attribute indicates whether an app can be resized, not whether the app supports multi-window mode. If `resizeableActivity="false"`, the app is put into compatibility mode when necessary to conform to display dimensions.
        - Small screens (sw \< 600dp): if `resizeableActivity="true"` and the minimum width and minimum height of the activity are within the multi-window requirements, the app supports multi-window mode. If `resizeableActivity="false"`, the app doesn't support multi-window mode regardless of the activity minimum width and height.

        | **Note:**
        |
        | - Device manufacturers can override the API level 31 behavior to improve the layout of apps.
        | - On devices with Android 16 (API level 36) or higher installed, virtual device owners (select trusted and privileged apps) can configure devices they manage to override (ignore) this attribute to improve app layout. See also [Companion app
        |   streaming](https://source.android.com/docs/core/permissions/app-streaming).
        |
        | See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode).


        A task's root activity value is applied to all additional activities launched in the task. That is, if the root
        activity of a task is resizable, then the system treats all other activities in the task as resizable. If the root
        activity isn't resizable, the other activities in the task aren't resizable.


        **Note:** A task's root activity value is applied to all
        additional activities launched in the task. That is, if the root activity of
        a task is resizable, then the system treats all other activities in the
        task as resizable. If the root activity isn't resizable, the other
        activities in the task aren't resizable.

    `android:screenOrientation`

    :   The requested orientation of the activity.

        | **Warning:** To improve the layout of apps on form factors with smallest width \>= 600dp, the system ignores the following values of this attribute for apps that target Android 16 (API level 36):
        |
        | - `portrait`
        | - `landscape`
        | - `reversePortrait`
        | - `reverseLandscape`
        | - `sensorPortrait`
        | - `sensorLandscape`
        | - `userPortrait`
        | - `userLandscape`
        |
        | Your app can opt out of the Android 16 behavior, but the opt out will be eliminated in a future release. See
        | [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode#android_16).
        | **Note:**
        |
        | - Device manufacturers can configure devices to override (ignore) this attribute to improve the layout of apps.
        | - On devices with Android 16 (API level 36) or higher installed, virtual device owners (select trusted and privileged apps) can configure devices they manage to override (ignore) this attribute to improve app layout. See also [Companion app
        |   streaming](https://source.android.com/docs/core/permissions/app-streaming).
        |
        | See [Device compatibility mode](https://developer.android.com/guide/practices/device-compatibility-mode).

        When an activity fills the entire screen, the requested orientation acts as a suggestion to
        change the orientation on that screen to match the requested value. This can result in an
        orientation that differs from the screen's physical orientation in space, requiring
        the user to rotate the device to continue using the app.
        On [Android 12 (API level
        31)](https://developer.android.com/about/versions/12/12L/summary#dev-device-orientation-request) and higher, device manufacturers can configure individual device
        screens (such as the tablet-sized screen of a foldable) to ignore this suggestion, and instead
        force an activity to be letterboxed within the user's preferred orientation of the device. This
        results in the activity's orientation matching the requested one without needing the user to
        physically rotate their device.

        In multi-window mode, the requested orientation does not act as a suggestion for the overall
        orientation. If the activity is
        [letterboxed](https://developer.android.com/guide/practices/device-compatibility-mode#letterboxing), the requested
        orientation impacts the letterboxing applied to the activity.

        The value can be any one of the following strings:

        |---|---|
        | `"unspecified"` | The default value. The system chooses the orientation. The policy it uses, and therefore the choices made in specific contexts, might differ from device to device. |
        | `"behind"` | The same orientation as the activity that's immediately beneath it in the activity stack. |
        | `"landscape"` | Landscape orientation (the display is wider than it is tall). |
        | `"portrait"` | Portrait orientation (the display is taller than it is wide). |
        | `"reverseLandscape"` | Landscape orientation in the opposite direction from normal landscape. *Added in API level 9.* |
        | `"reversePortrait"` | Portrait orientation in the opposite direction from normal portrait. *Added in API level 9.* |
        | `"sensorLandscape"` | Landscape orientation, but can be either normal or reverse landscape based on the device sensor. The sensor is used even if the user has locked sensor-based rotation. *Added in API level 9.* |
        | `"sensorPortrait"` | Portrait orientation, but can be either normal or reverse portrait based on the device sensor. The sensor is used even if the user has locked sensor-based rotation. However, depending on the device configuration, upside-down rotation might not be allowed. *Added in API level 9.* |
        | `"userLandscape"` | Landscape orientation, but can be either normal or reverse landscape based on the device sensor and the user's preference. *Added in API level 18.* |
        | `"userPortrait"` | Portrait orientation, but can be either normal or reverse portrait based on the device sensor and the user's preference. However, depending on the device configuration, upside-down rotation might not be allowed. *Added in API level 18.* |
        | `"sensor"` | The device orientation sensor determines the orientation. The orientation of the display depends on how the user is holding the device. It changes when the user rotates the device. Some devices, though, don't rotate to all four possible orientations, by default. To use all four orientations, use `"fullSensor"`. The sensor is used even if the user locked sensor-based rotation. |
        | `"fullSensor"` | The device orientation sensor determines the orientation for any of the four orientations. This is similar to `"sensor"`, except this allows for any of the four possible screen orientations regardless of what the device normally supports. For example, some devices don't normally use reverse portrait or reverse landscape, but this enables those orientations. *Added in API level 9.* |
        | `"nosensor"` | The orientation is determined without reference to a physical orientation sensor. The sensor is ignored, so the display doesn't rotate based on how the user moves the device. |
        | `"user"` | The user's current preferred orientation. |
        | `"fullUser"` | If the user has locked sensor-based rotation, this behaves the same as `user`, otherwise it behaves the same as `fullSensor` and allows any of the four possible screen orientations. *Added in API level 18.* |
        | `"locked"` | Locks the orientation to its current rotation, whatever that is. *Added in API level 18.* |

        **Note:** When you declare one of the landscape or portrait values,
        it is considered a hard requirement for the orientation in which the activity runs.
        The value you declare enables filtering by services such as Google Play, so your application is
        available only to devices that support the orientation required by your activities. For
        example, if you declare either `"landscape"`, `"reverseLandscape"`, or
        `"sensorLandscape"`, then your application is available only to devices that support
        landscape orientation.

        Also explicitly declare that
        your application requires either portrait or landscape orientation with the [`<uses-feature>`](https://developer.android.com/guide/topics/manifest/uses-feature-element)
        Element, such as `<uses-feature
        android:name="android.hardware.screen.portrait"/>`. This is a filtering behavior
        provided by Google Play and other services that support it, and the platform itself doesn't
        control whether your app can install when a device supports only certain orientations.

    `android:showForAllUsers`

    :   Whether the activity is shown when the device's current user is
        different than the user who launched the activity. You can set this attribute
        to a literal value, like `"true"` or `"false"`, or
        you can set the attribute to a resource or theme attribute that contains a
        boolean value.

        This attribute was added in API level 23.

    `android:stateNotNeeded`
    :   Whether the activity can be terminated and successfully restarted
        without having saved its state. It's `"true"` if it can be restarted
        without reference to its previous state, and `"false"` if its previous
        state is required. The default value is `"false"`.


        Normally, before an activity is temporarily shut down to save resources, its
        [onSaveInstanceState()](https://developer.android.com/reference/android/app/Activity#onSaveInstanceState(android.os.Bundle))
        method is called. This method stores the current state of the activity in a
        [Bundle](https://developer.android.com/reference/android/os/Bundle) object, which is then passed to
        [onCreate()](https://developer.android.com/reference/android/app/Activity#onCreate(android.os.Bundle)) when the activity
        is restarted. If this attribute is set to `"true"`,
        `onSaveInstanceState()` might not be called, and `onCreate()` is passed
        `null` instead of the `Bundle`, as it is when the
        activity starts for the first time.


        A `"true"` setting means that the activity can be restarted without
        retained state. For example, the activity that displays the
        Home screen uses this setting to make sure that it doesn't get removed if it
        crashes for some reason.

    `android:supportsPictureInPicture`

    :
        Specifies whether the activity supports [picture-in-picture](https://developer.android.com/training/tv/playback/picture-in-picture) display.

    `android:taskAffinity`

    :   The task that the activity has an affinity for. Activities with
        the same affinity conceptually belong to the same task, to the same
        "application" from the user's perspective. The affinity of a task
        is determined by the affinity of its root activity.


        The affinity determines two things: the task that the activity is re-parented
        to (see the [allowTaskReparenting](https://developer.android.com/guide/topics/manifest/activity-element#reparent)
        attribute) and the task that houses the activity when it launches
        with the [FLAG_ACTIVITY_NEW_TASK](https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_NEW_TASK)
        flag.


        By default, all activities in an application have the same affinity. You
        can set this attribute to group them differently, and even place
        activities defined in different applications within the same task. To
        specify that the activity doesn't have an affinity for any task, set
        it to an empty string.


        If this attribute isn't set, the activity inherits the affinity set
        for the application. See the
        [<application>](https://developer.android.com/guide/topics/manifest/application-element)
        element's
        [taskAffinity](https://developer.android.com/guide/topics/manifest/application-element#aff)
        attribute. The name of the default affinity for an application is
        the [namespace](https://developer.android.com/studio/build/configure-app-module#set-namespace) set in the
        `build.gradle` file.

    `android:theme`
    :   A reference to a style resource defining an overall theme for the activity.
        This automatically sets the activity's context to use this
        [theme](https://developer.android.com/reference/android/content/Context#setTheme(int)) and might also
        cause "starting" animations prior to the activity being launched, to better
        match what the activity actually looks like.


        If this attribute isn't set, the activity inherits the theme set for the
        application as a whole, from the
        [<application>](https://developer.android.com/guide/topics/manifest/application-element)
        element's
        [theme](https://developer.android.com/guide/topics/manifest/application-element#theme)
        attribute. If that attribute is also not set, the default system theme is used. For more
        information, see [Styles and themes](https://developer.android.com/guide/topics/ui/themes).

    `android:uiOptions`

    :   Extra options for an activity's UI. Must be one of the following values.

        | Value | Description |
        |---|---|
        | `"none"` | No extra UI options. This is the default. |
        | `"splitActionBarWhenNarrow"` | Adds a bar at the bottom of the screen to display action items in the *app bar* , also known as the *action bar*, when constrained for horizontal space, such as when in portrait mode on a handset. Instead of a small number of action items appearing in the app bar at the top of the screen, the app bar is split into the top navigation section and the bottom bar for action items. This means a reasonable amount of space is made available not only for the action items, but also for navigation and title elements at the top. Menu items are not split across the two bars. They always appear together. |

        For more information about the app bar, see [Add the app bar](https://developer.android.com/training/appbar).

        This attribute was added in API level 14.

    `android:windowSoftInputMode`
    :   How the main window of the activity interacts with the window containing
        the on-screen soft keyboard. The setting for this attribute affects two
        things:

        - Whether the soft keyboard is hidden or visible when the activity becomes the focus of user attention.
        - Whether the activity's main window is resized smaller to make room for the soft keyboard or its contents pan to make the current focus visible when part of the window is covered by the soft keyboard.


        The setting must be one of the values listed in the following table or a
        combination of one `"state..."` value plus one `"adjust..."`
        value. Setting multiple values in either group, such as multiple
        `"state..."` values, has undefined results.
        Individual values are separated by a vertical bar (`|`), as shown in the following example:


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


        Values set here (other than `"stateUnspecified"` and
        `"adjustUnspecified"`) override values set in the theme.


        | Value | Description |
        |---|---|
        | `"stateUnspecified"` | Whether the soft keyboard is hidden or visible isn't specified. The system chooses an appropriate state or relies on the setting in the theme. This is the default setting for the behavior of the soft keyboard. |
        | `"stateUnchanged"` | The soft keyboard is kept in whatever state it was last in, visible or hidden, when the activity comes to the fore. |
        | `"stateHidden"` | The soft keyboard is hidden when the user chooses the activity---that is, when the user affirmatively navigates forward to the activity, rather than backing into it when leaving another activity. |
        | `"stateAlwaysHidden"` | The soft keyboard is always hidden when the activity's main window has input focus. |
        | `"stateVisible"` | The soft keyboard is made visible when the user chooses the activity---that is, when the user affirmatively navigates forward to the activity, rather than backing into it when leaving another activity. |
        | `"stateAlwaysVisible"` | The soft keyboard is visible when the window receives input focus. |
        | `"adjustUnspecified"` | Whether the activity's main window resizes to make room for the soft keyboard or the contents of the window pan to make the current focus visible on-screen is unspecified. The system automatically selects one of these modes depending on whether the content of the window has any layout views that can scroll their contents. If there is such a view, the window resizes, on the assumption that scrolling can make all of the window's contents visible within a smaller area. This is the default setting for the behavior of the main window. |
        | `"adjustResize"` | The activity's main window is always resized to make room for the soft keyboard on screen. |
        | `"adjustPan"` | The activity's main window isn't resized to make room for the soft keyboard. Rather, the contents of the window automatically pan so that the current focus is never obscured by the keyboard, and users can always see what they are typing. This is generally less desirable than resizing, because the user might need to close the soft keyboard to get at and interact with obscured parts of the window. |
        | `"adjustNothing"` | The activity's main window isn't resized or panned to make room for the soft keyboard. The activity is responsible for making room for the soft keyboard using the window insets. For activities that handle window insets correctly this gives the most control over how the window's contents are displayed on the screen. |


        This attribute was introduced in API level 3.

introduced in:
:   API level 1 for all attributes except
    [noHistory](https://developer.android.com/guide/topics/manifest/activity-element#nohist) and
    [windowSoftInputMode](https://developer.android.com/guide/topics/manifest/activity-element#wsoft), which were added in API
    level 3.

see also:
:   [<application>](https://developer.android.com/guide/topics/manifest/application-element)

    [<activity-alias>](https://developer.android.com/guide/topics/manifest/activity-alias-element)