Activity的5种启动模式详解(新增singleInstancePerTask类型)

最新推荐文章于 2024-02-29 20:58:19 发布
最新推荐文章于 2024-02-29 20:58:19 发布
阅读量4.4k 收藏 31
点赞数 15
分类专栏： 安卓 文章标签： android activity 启动模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzleilei/article/details/128799630
版权

前言

看到这个标题的时候，也许你会认为我写错了，Activity不是只有四种启动模式吗？分别为startard,singleTop,singleTask,singleInstance这四种。

一般来说是四种，但是android12的时候新加入了singleInstancePerTask类型，所以就有5种了。

介绍这五种类型之前，我们先略微介绍一下这五种类型在源码中的定义。

首先，我们先看一下官方注释的位置下，这五种类型的注释在attrs_manifest.xml文件中：

<attr name="launchMode">
        <!-- The default mode, which will usually create a new instance of
             the activity when it is started, though this behavior may change
             with the introduction of other options such as
             {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK
             Intent.FLAG_ACTIVITY_NEW_TASK}. -->
        <enum name="standard" value="0" />
        <!-- If, when starting the activity, there is already an
            instance of the same activity class in the foreground that is
            interacting with the user, then
            re-use that instance.  This existing instance will receive a call to
            {@link android.app.Activity#onNewIntent Activity.onNewIntent()} with
            the new Intent that is being started. -->
        <enum name="singleTop" value="1" />
        <!-- If, when starting the activity, there is already a task running
            that starts with this activity, then instead of starting a new
            instance the current task is brought to the front.  The existing
            instance will receive a call to {@link android.app.Activity#onNewIntent
            Activity.onNewIntent()}
            with the new Intent that is being started, and with the
            {@link android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT
            Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT} flag set.  This is a superset
            of the singleTop mode, where if there is already an instance
            of the activity being started at the top of the stack, it will
            receive the Intent as described there (without the
            FLAG_ACTIVITY_BROUGHT_TO_FRONT flag set).  See the
            <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
            Stack</a> document for more details about tasks.-->
        <enum name="singleTask" value="2" />
        <!-- Only allow one instance of this activity to ever be
            running.  This activity gets a unique task with only itself running
            in it; if it is ever launched again with the same Intent, then that
            task will be brought forward and its
            {@link android.app.Activity#onNewIntent Activity.onNewIntent()}
            method called.  If this
            activity tries to start a new activity, that new activity will be
            launched in a separate task.  See the
            <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
            Stack</a> document for more details about tasks.-->
        <enum name="singleInstance" value="3" />
        <!-- The activity can only be running as the root activity of the task, the first activity
            that created the task, and therefore there will only be one instance of this activity
            in a task. In constrast to the {@code singleTask} launch mode, this activity can be
            started in multiple instances in different tasks if the
            {@code FLAG_ACTIVITY_MULTIPLE_TASK} or {@code FLAG_ACTIVITY_NEW_DOCUMENT} is set.-->
        <enum name="singleInstancePerTask" value="4" />
    </attr>

其次，在看一下这五种模式在Java文件中的定义，在ActivityInfo类中，如下：

    /**
     * Constant corresponding to <code>standard</code> in
     * the {@link android.R.attr#launchMode} attribute.
     /
    public static final int LAUNCH_MULTIPLE = 0;
    /*
     * Constant corresponding to <code>singleTop</code> in
     * the {@link android.R.attr#launchMode} attribute.
     /
    public static final int LAUNCH_SINGLE_TOP = 1;
    /*
     * Constant corresponding to <code>singleTask</code> in
     * the {@link android.R.attr#launchMode} attribute.
     /
    public static final int LAUNCH_SINGLE_TASK = 2;
    /*
     * Constant corresponding to <code>singleInstance</code> in
     * the {@link android.R.attr#launchMode} attribute.
     /
    public static final int LAUNCH_SINGLE_INSTANCE = 3;
    /*
     * Constant corresponding to <code>singleInstancePerTask</code> in
     * the {@link android.R.attr#launchMode} attribute.
     */
    public static final int LAUNCH_SINGLE_INSTANCE_PER_TASK = 4;

接下来，我们就依次讲解这五种类型的定义和作用。

一.standard类型

首先讲解standard类型，这也是一个最基本最常用的一种类型。

官方解释

先看官方注释中的描述：

        <!-- The default mode, which will usually create a new instance of
             the activity when it is started, though this behavior may change
             with the introduction of other options such as
             {@link android.content.Intent#FLAG_ACTIVITY_NEW_TASK
             Intent.FLAG_ACTIVITY_NEW_TASK}. -->

翻译后：

默认的类型，每次使用时通常创建一个新的活动对象，虽然这样的行为会因为引入其它参数配置而发生改变，比如Intent.FLAG_ACTIVITY_NEW_TASK。

实验验证

我们再来通过实验进行验证，创建三个Activity，分别为Test1Activity，Test2Activity，Test3Activity，如下：

        <activity android:name="com.xt.client.activitys.test.Test1Activity" />
        <activity android:name="com.xt.client.activitys.test.Test2Activity" />
        <activity android:name="com.xt.client.activitys.test.Test3Activity" />

然后我们在代码中设置如下跳转顺序：Test1->Test2->Test3->Test1

接下来就是实验，按照上面流程跳转后，使用adb命令捕获当前Activity的栈状态如下：

adb命令：adb shell dumpsys activity activities

      Application tokens in top down Z order:
      * Task{54bb09b #190 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=4}
        bounds=[0,0][1080,2340]
        * ActivityRecord{75f3f53 u0 com.xt.client/.activitys.test.Test1Activity} t190}
        * ActivityRecord{f91f056 u0 com.xt.client/.activitys.test.Test3Activity} t191}
        * ActivityRecord{777cf91 u0 com.xt.client/.activitys.test.Test2Activity} t190}
        * ActivityRecord{83d9d17 u0 com.xt.client/.activitys.test.Test1Activity} t190}

整个流程如下图所示，Test3跳转Test1的时候，会直接在Test3上面入栈一个新的Test1。所以Task中有4条ActivityRecrod，从下往上的顺序为：Test1，Test2，Test3，Test1。

总结：

首先这里我们就不验证添加参数的类型了。

standard类型的启动方式，是不断的往一个Task栈上面添加新的Activity，哪怕有同样的Activity，也会重新创建一个添加到栈里面。

二.singleInstance类型

为什么把singleInstance拿到前面来说呢？因为后面singleTop类型中的验证会涉及到singleInstance类型的知识点，所以就拿到前面提前来讲了。

官方解释

<!-- Only allow one instance of this activity to ever be
    running.  This activity gets a unique task with only itself running
    in it; if it is ever launched again with the same Intent, then that
    task will be brought forward and its
    {@link android.app.Activity#onNewIntent Activity.onNewIntent()}
    method called.  If this
    activity tries to start a new activity, that new activity will be
    launched in a separate task.  See the
    <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
    Stack</a> document for more details about tasks.-->

翻译后：

只允许一个Activity的实例运行。这个Activity会有唯一的task栈只允许它自身在其中运行，每次被加载的时候都被会把这个栈带到前台，同时会调用Activity的onNewIntent方法进行通知。如果这个Activity尝试去启动一个新的Activity，那么新创建的Activity和当前Activity必须是不同的Task栈。

实验验证

我们仍然是三个Activity，其中Test2Activity设置为singleInstance的模式，

        <activity android:name="com.xt.client.activitys.test.Test1Activity" />
        <activity
            android:name="com.xt.client.activitys.test.Test2Activity"
            android:launchMode="singleInstance" />
        <activity android:name="com.xt.client.activitys.test.Test3Activity" />

设置跳转顺序： Test1->Test2->Test3->Test1->Test2->Test3

执行操作，结果如下，我们可以发现Test2单独占用一个Task

      Application tokens in top down Z order:
      * Task{40cbc68 #196 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=5}
        bounds=[0,0][1080,2340]
        * ActivityRecord{cd9b41f u0 com.xt.client/.activitys.test.Test3Activity} t196}
        * ActivityRecord{9e73f05 u0 com.xt.client/.activitys.test.Test1Activity} t196}
        * ActivityRecord{8fcaaee u0 com.xt.client/.activitys.test.Test3Activity} t196}
        * ActivityRecord{5e3a630 u0 com.xt.client/.activitys.test.Test1Activity} t196}
        * ActivityRecord{9768990 u0 com.xt.client/.MainActivity} t196}
      * Task{17dfc90 #197 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=1}
        bounds=[0,0][1080,2340]
        * ActivityRecord{e147b53 u0 com.xt.client/.activitys.test.Test2Activity} t197}

我们发现区别于第一种类型，这种类型下会有两个Task栈，这两个Task的taskAffinity是一样的。

Test2启动Test3的时候，流程图如下所示。首先前台任务栈从Task2切换到了Task1，Task1中也增加了一条Test3的Activity记录，此时显示在前台的就是Test3了。

总结：

singleInstance类型的启动方式中，

如果不存在包含目标Activity的栈，则创建一个新的Task，这个Task中是目标Activity所独有的，并且只会创建一次，后续如果在启动其它的Activity，这些新的Acitivty属于其parent的task栈。

如果存在包含目标Activity的栈，则直接把包含目标Activity的Task栈挪到前台进行显示。

三.singleTop类型

singleTop相对于startard多了一个复用的概念，就是说某些场景下，会复用已有的Activity而不是每次都新建。

官方解释

        <!-- If, when starting the activity, there is already an
            instance of the same activity class in the foreground that is
            interacting with the user, then
            re-use that instance.  This existing instance will receive a call to
            {@link android.app.Activity#onNewIntent Activity.onNewIntent()} with
            the new Intent that is being started. -->

翻译后：

在启动Activity的时候，如果前台中存在一个相同Activity类的实例与用户交互，则直接使用这个实例。这个存在的实例在启动的时候会通过onNewIntent方法收到通知。

实验验证

这里为了体现singleTop的作用，我们做一个对比实验。

首先，我们设置Test3为singleInstance模式，其他的都是默认的standard模式。

        <activity android:name="com.xt.client.activitys.test.Test1Activity" />
        <activity android:name="com.xt.client.activitys.test.Test2Activity" />
        <activity
            android:name="com.xt.client.activitys.test.Test3Activity"
            android:launchMode="singleInstance" />

然后设置跳转顺序：Test1->Test2->Test3->Test2

结果如下：

      Application tokens in top down Z order:
      * Task{54bb09b #190 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=4}
        bounds=[0,0][1080,2340]
        * ActivityRecord{75f3f53 u0 com.xt.client/.activitys.test.Test2Activity} t190}
        * ActivityRecord{777cf91 u0 com.xt.client/.activitys.test.Test2Activity} t190}
        * ActivityRecord{83d9d17 u0 com.xt.client/.activitys.test.Test1Activity} t190}
        * ActivityRecord{6979f3f u0 com.xt.client/.MainActivity} t190}
      * Task{e1b8d7 #191 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=1}
        bounds=[0,0][1080,2340]
        * ActivityRecord{f91f056 u0 com.xt.client/.activitys.test.Test3Activity} t191}

我们可以看到有两个Task栈，Task1中有3个Activity记录，分别是Test1，Test2，Test2。而Task2中则只有一个Test3的记录。

此时，我们做一个改动，把Test2设置为singleTop类型，如下：

        <activity android:name="com.xt.client.activitys.test.Test1Activity" />
        <activity android:name="com.xt.client.activitys.test.Test2Activity"
            android:launchMode="singleTop" />
        <activity
            android:name="com.xt.client.activitys.test.Test3Activity"
            android:launchMode="singleInstance" />

同样的跳转顺序：Test1->Test2->Test3->Test2

结果如下：

      Application tokens in top down Z order:
      * Task{54bb09b #190 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=4}
        bounds=[0,0][1080,2340]
        * ActivityRecord{777cf91 u0 com.xt.client/.activitys.test.Test2Activity} t190}
        * ActivityRecord{83d9d17 u0 com.xt.client/.activitys.test.Test1Activity} t190}
      * Task{e1b8d7 #191 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=1}
        bounds=[0,0][1080,2340]
        * ActivityRecord{f91f056 u0 com.xt.client/.activitys.test.Test3Activity} t191}

我们发现，只有Task2仍然只有一条Test3的记录，但是Task1中，只有两条记录了，分别为Test1和Test2。相对于上一次实验，这次少了一个Test2的记录。

Test3跳转Test2的流程图如下，前台任务栈从Task1切换到了Task2，并且Test2没有新建，而是直接复用栈顶的实例对象。

总结：

总结一下，singleTop类型的启动方式，当从别的Task任务栈切换回当前任务栈时，如果栈顶实例就是同样的Activity，则直接进行复用，并且通过onNewIntent方法进行通知。

四.singleTask类型

singleTask类型其实就是singleTop类型的增强版，我们来看下他们的区别。

官方解释

        <!-- If, when starting the activity, there is already a task running
            that starts with this activity, then instead of starting a new
            instance the current task is brought to the front.  The existing
            instance will receive a call to {@link android.app.Activity#onNewIntent
            Activity.onNewIntent()}
            with the new Intent that is being started, and with the
            {@link android.content.Intent#FLAG_ACTIVITY_BROUGHT_TO_FRONT
            Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT} flag set.  This is a superset
            of the singleTop mode, where if there is already an instance
            of the activity being started at the top of the stack, it will
            receive the Intent as described there (without the
            FLAG_ACTIVITY_BROUGHT_TO_FRONT flag set).  See the
            <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
            Stack</a> document for more details about tasks.-->

翻译后：

在启动Activity的时候，如果栈中存在一个这样的Activity，会通过在当前栈中把Activity对象带到前台的方式来替代新创建一个对象。启动的时候那个已存在的实例对象中onNewIntent方法会收到通知，并且会有Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT的标记。这是singleTop类型的扩展，如果目标Activity就处于栈顶部，则不会有FLAG_ACTIVITY_BROUGHT_TO_FRONT标记。

实验验证

我们采取和singeTop类似的方式，仍然进行对比实验。

仍然是三个Activity，其中Test1Activity设置为singleTask的模式，如下：

        <activity android:name="com.xt.client.activitys.test.Test1Activity" />
        <activity android:name="com.xt.client.activitys.test.Test2Activity" />
        <activity android:name="com.xt.client.activitys.test.Test3Activity"
            android:launchMode="singleInstance" />

区别于singeTop中的方式，我们这里设置Test3跳转回Test1。

设置如下跳转顺序：Test1->Test2->Test3->Test1

进行操作，使用adb命令捕获栈结构如下：

      Application tokens in top down Z order:
      * Task{d44dd11 #198 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=4}
        bounds=[0,0][1080,2340]
        * ActivityRecord{5902bb5 u0 com.xt.client/.activitys.test.Test1Activity} t198}
        * ActivityRecord{46c4832 u0 com.xt.client/.activitys.test.Test2Activity} t198}
        * ActivityRecord{6e48322 u0 com.xt.client/.activitys.test.Test1Activity} t198}
      * Task{9bdbdf4 #199 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=1}
        bounds=[0,0][1080,2340]
        * ActivityRecord{f0693c7 u0 com.xt.client/.activitys.test.Test3Activity} t199}

Task1中有Test1，Test2，Test1三条记录，Task2中只有Test3一条记录。

我们再把Test1改为singleTask类型，如下：

        <activity android:name="com.xt.client.activitys.test.Test1Activity" 
            android:launchMode="singleTask" />
        <activity android:name="com.xt.client.activitys.test.Test2Activity" />
        <activity android:name="com.xt.client.activitys.test.Test3Activity"
            android:launchMode="singleInstance" />

同样的跳转顺序：Test1->Test2->Test3->Test1，再次进行实验，结果如下：

      Application tokens in top down Z order:
      * Task{9de4b6a #200 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=2}
        bounds=[0,0][1080,2340]
        * ActivityRecord{4bdcfd7 u0 com.xt.client/.activitys.test.Test1Activity} t200}
      * Task{af6f1f0 #201 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=1}
        bounds=[0,0][1080,2340]
        * ActivityRecord{66c6a33 u0 com.xt.client/.activitys.test.Test3Activity} t201}

这时候我们发现区别于上一个实验，这时Task1中只有一条Test1的记录了。

整个流程如下图所示，Test3中启动Test1的时候，前台任务栈从Task2切换到Task1，并且直接把Task1中Test2记录进行出栈操作，此时显示在前台的就是Test1了。

总结：

使用singleTask类型后，如果发现目标任务栈Task中存在相同的Activity实例时，则会出栈该实例上面的所有其它类型的实例，从而让该实例展示到前台。

六.singleInstancePerTask

singleInstancePerTask由其名可知，是singleInstance类型的增强版，其实在我看来，更像是singleInstance和singleTask的结合体，接下来我们来看下区别。

官方解释

<!-- The activity can only be running as the root activity of the task, the first activity
    that created the task, and therefore there will only be one instance of this activity
    in a task. In constrast to the {@code singleTask} launch mode, this activity can be
    started in multiple instances in different tasks if the
    {@code FLAG_ACTIVITY_MULTIPLE_TASK} or {@code FLAG_ACTIVITY_NEW_DOCUMENT} is set.-->

翻译后：

Activity只能作为Task栈的根结点（第一个被创建）运行，因此栈中只可能有一个该Activity的实例。对比singleTask类型，如果设置了FLAG_ACTIVITY_MULTIPLE_TASK标记该Activity可以在不同的栈生成多个不同的实例。

实验验证

设置三个Activity，其中Test3Activity设置为singleInstancePerTask的模式，如下：

<activity android:name="com.xt.client.activitys.test.Test1Activity" />
<activity android:name="com.xt.client.activitys.test.Test2Activity" />
<activity
    android:name="com.xt.client.activitys.test.Test3Activity"
    android:launchMode="singleInstancePerTask" />

设置如下跳转顺序：Test1->Test2->Test3->Test1->Test2->Test3->Test1

进行操作，使用adb命令捕获栈结构如下：

      Application tokens in top down Z order:
      * Task{e77ae1e #206 type=standard A=10234:com.xt.client U=0 visible=true visibleRequested=true mode=fullscreen translucent=false sz=2}
        bounds=[0,0][1080,2340]
        * ActivityRecord{a818f11 u0 com.xt.client/.activitys.test.Test1Activity} t206}
        * ActivityRecord{632e259 u0 com.xt.client/.activitys.test.Test3Activity} t206}
      * Task{6ef6ec0 #205 type=standard A=10234:com.xt.client U=0 visible=false visibleRequested=false mode=fullscreen translucent=true sz=3}
        bounds=[0,0][1080,2340]
        * ActivityRecord{9918e35 u0 com.xt.client/.activitys.test.Test2Activity} t205}
        * ActivityRecord{25df40c u0 com.xt.client/.activitys.test.Test1Activity} t205}

可以看到，虽然启动了两次Test3，但是仍然只有两个Task栈，可以证明singleInstancePerTask类型是栈单例的，一个被声明的Activity只会拥有唯一的一个栈（不设置标记的前提下）。

如下图所示，区别于singleInstance类型的是，在这个归属Test3的栈中，是可以放入其它的Activity的，比如这里的Test1。

总结

singleInstancePerTask类型的启动方式中，

如果不存在包含目标Activity的栈，则创建一个新的Task，这个Task中是目标Activity所独有的，并且只会创建一次，后续如果在启动其它的Activity，这些新的Acitivty仍然当前的task栈。

如果存在包含目标Activity的栈，则把包含目标Activity的Task栈挪到前台，并且把该栈中目标Activity上面的所有Activity进行出栈操作，从而实现目标Activity显示在前台的效果。

当然，如官方文档所描述，如果启动singleInstancePerTask类型的Activity时，同时设置FLAG_ACTIVITY_MULTIPLE_TASK标记，应该是可以启动多个包含目标Activity的Task栈的，这里就不做实验了。

扩展性问题：

问题1：如果一个Task中的Activity全部出栈，会退到哪里？

答：假设Task1启动了Task2，那么Task2中的Activity如果全部出栈，就会把Task1推到前台，Task1中栈顶的Activity就会被显示。

我们以singleInstance类型中的流程为例，假设启动流程如下：

MainActivity(Task1)->Test1(Task2)->Test2(Task2)->Test3(Task3)->Test1(Task2)->Test2(Task3)->Test3(Task2)。

最终Test3属于Task2的栈，所以Task2中的4个Activity记录全部出栈后，会返回Task1的MainActivity，而不是Test2。

问题2：如何区分是首次创建还是从栈中返回的？

答：这个注释中就告诉我们了，栈中复用的回调用onNewIntent方法。

问题3：如何区分是从栈顶复用还是栈中复用的？

答：首先解释下栈顶复用还是栈中复用。如下图所示，如果启动的是Test3，就是栈顶复用，如果启动的是Test2或者Test1，那么就是栈中复用。

这个其实官方文档的注释中也告诉我们结果了，如果是栈中复用，则onNewIntent方法中，其flags参数中会包含Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT标记，可以通过这个来区别。

失落夏天
关注
  • 15
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
如何正确理解和使用Activity的4种启动模式
01-04
关于Activity启动模式的文章已经很多，但有的文章写得过于简单，有的则过于注重细节，本文想取一个折中，只关注最重要和最常用的概念，原理和使用方法，便于读者正确应用。 Activity的启动模式有4种，分别是standard.singleTop. SingleTask. singleInstance，可以在AndroidMainifest.xml文件中指定每一个Activity的启动模式。一个Android应用一般都会有多个Activity，系统会通过任务栈来管理这些Activity，栈是一种后进先出的集合，当前的Activity就在栈顶，按返回键，栈顶Activity就会退出。Activi
简单介绍Android中Activity的四种启动模式
09-02
在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。本文给大家介绍Android中Activity的四种启动模式，需要的朋友参考下吧
详解Android中Activity的四大启动模式实验简述
01-20
作为Android四大组件之一，Activity可以说是最基本也是最常见的组件，它提供了一个显示界面，从而实现与用户的交互，作为初学者，必须熟练掌握。今天我们就来通过实验演示，来帮助大家理解Activity的四大启动模式。 演示效果如下： 第一步：实验前准备，相关配置文件以及Activity的建立 （1）AndroidMainfest.xml配置文件 <?xml version=1.0 encoding=utf-8?> <manifest xmlns:android=http://schemas.android.com/apk/res/android package=
Android Activity启动模式详解
最新发布
一起coding，一起嗨。
02-29 594
Android Activity启动模式详解
Activity四种启动模式详解
05-07
在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。 本文档讲解Android中Activity的启动模式
Activity 四种启动模式详细介绍
01-05
Activity 四种启动模式详细介绍 在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。 Android总Activity的启动模式分为四种： Activity启动模式设置： <activity android:name=.MainActivity android:launchMode=standard> <activity android:name=.MainActivity android:launchMode
LaunchMode的使用
02-12
Activity是Android最常用的组件之一，也是最直观的组件，Activity启动时有四种模式，分别是： “standard” "singleTop" "singleTask" "singleInstance" 其中"standard"是默认模式。
android中singleInstancePerTask和taskAffinity介绍以及singleInstance和singleInstancePerTask区别
分享技术与经验的博客
05-13 3961
singleInstance和taskAffinity launchermode优先处理再考虑需不需要taskAffinity taskAffinity和singleTask搭配使用
Android新启动模式之singleInstancePerTask
虎哥LoveDroid
02-21 3061
taskAffinity是指Activity的任务栈亲和度，即任务归属，代表该Activity属于哪个任务栈。使用场景：1.一般根据taskAffinity重新为Activity选择宿主任务栈（与allowTaskReparenting属性配合使用）2.启动一个Activity过程中Intent使用了FLAG_ACTIVITY_NEW_TASK标记，根据taskAffinity查找或创建一个新的具有对应taskAffinity的任务栈。
Activity的四种启动模式
Ai1114的博客
06-10 4万+
系统默认的启动模式，栈结构，先进后出，打开一个activity入栈，再打开下个activity,接着入栈，我们平时直接创建的Activity都是这种模式的Activity这种模式的Activity的特点是：只要你创建了Activity实例，一旦激活该Activity，则会向任务栈中加入新创建的实例，退出Activity则会在任务栈中销毁该实例。如果某个Activity自己激活自己，即任务栈栈顶就是该Activity，则不需要创建，其余情况都要创建Activity实例；如果要激活的那个Activity在任务栈
【Android Activity】Activity的启动模式
dev晴天的博客
03-28 5818
安卓是采用任务栈来管理activity的，默认情况下多次启动同一个activity系统会重复创建这个activity的实例，并把每个实例依次入栈。为了避免activity实例的重复创建、应付特殊的场景、安卓为activity设计了启动模式。
Android Activity启动模式之singleTask实例详解
09-02
主要介绍了Android Activity启动模式之singleTask,结合实例形式较为详细的分析了singleTask模式的功能、使用方法与相关注意事项,需要的朋友可以参考下
Android 两种启动模式的实例详解
01-04
Android 两种启动模式的实例详解 Intent的FLAG_ACTIVITY_CLEAR_TOP和FLAG_ACTIVITY_REORDER_TO_FRONT Activity的两种启动模式：FLAG_ACTIVITY_CLEAR_TOP和FLAG_ACTIVITY_REORDER_TO_FRONT 1. 如果已经启动了四个Activity：A，B，C和D。在D Activity里，我们要跳到B Activity，同时希望C finish掉，可以在startActivity(intent)里的intent里添加flags标记，如下所示： Intent intent = new Inte
AndroidActivity的四大启动模式详解
02-02
在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。Activity启动模式设置：1.standard模式启动模式，每次激活Activity时都会创建Activity，并放入任务栈中。2.singleTop如果在任务的栈顶正好存在该Activity的实例，就重用该实例，否者就会创建新的实例并放入栈顶(即使栈中已经存在该Activity实例，只要不在栈顶，都会创建实例)。3.singleTask如果在栈中已经有该Activity的实例，就重用该实例(会调用
Android编程中Activity的四种启动模式
09-02
主要介绍了Android编程中Activity的四种启动模式,较为详细的分析了Activity四种启动模式的原理与功能,需要的朋友可以参考下
android源码学习-Handler机制及其六个核心点
热门推荐
分享+记录
02-28 6万+
安卓Handler源码全面讲解
解决各版本安卓读写SD卡的问题-java.io.IOException: Operation not permitted问题（兼容到android13）
分享+记录
01-26 1万+
前言： 本文的核心是解决安卓上面读写SD卡目录的问题。 众所周知，安卓上面对于应用来说可以读写的有三块区域： 1.data/data/包名； 2.sdcard/Android/data/包名； 3.sdcard目录。 前两块区域读写一般是没有什么限制的，可以直接读写。但是第三块区域，因为各个APP都可以申请对这块区域进行读写，所以就会很乱，因此安卓也在不断的加强对这块区域管控的力度。 但是我们对SD卡根目录直接读写的需求是一直存在的，所以本文将会记录每个安卓版本对这块权限的变化，以及相对应的解
安卓插件化框架Shadow原理分析
分享+记录
02-23 1万+
Shadow核心原理： Shadow号称无Hook点。核心原理是运用代理的方式，把原本的acitivty编译期间改成一个代理类，去代理宿主activity的所有生命周期。 Demo流程： 原理流程： 改造点：
Activity启动的四种模式
03-27
1. 标准模式 (Standard Mode)：默认的启动模式。每次启动 Activity 都会创建一个新的实例，无论该 Activity 是否已经存在。 2. 单例模式 (SingleTop Mode)：如果要启动的 Activity 已经处于栈顶，那么不会创建新的实例，而是直接使用已有的实例。如果不在栈顶，就会创建新的实例。 3. 单任务模式 (SingleTask Mode)：如果要启动的 Activity 已经存在于栈中，会将该 Activity 之上的所有 Activity 全部弹出栈，使其成为栈顶的 Activity。如果不存在，就会创建新的实例。 4. 单实例模式 (SingleInstance Mode)：该模式下的 Activity 只允许存在一个实例。如果要启动的 Activity 已经存在于栈中，会将该 Activity 移动到栈顶，但不会创建新的实例。如果不存在，就会创建新的实例，并将它放到新的任务栈中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

失落夏天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值