Android-Activity所应该了解的大概就这样。（下）

最新推荐文章于 2020-05-24 17:10:01 发布

阿敏其人

最新推荐文章于 2020-05-24 17:10:01 发布

阅读量401

点赞数

分类专栏： Android笔划文章标签： android activity 任务栈启动顺序

本文链接：https://blog.csdn.net/icoollike/article/details/50239691

版权

Android笔划专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Android-Activity所应该了解的大概就这样。（上）

Android-Activity所应该了解的大概就这样。（中）

六、FLAG

我们知道，Android给Activity设定启动模式的方式有有两种。一种是在manifest里面设置，另一种是在通过Intent的FLAG设置。
FLAG，在安卓里面是 标记位 的意思，Flag有很多种，下面我们记录主要使用的几种。

代码指定Flag（使用全部FLAG），使得Activity启动模式可变，而且最后一次指定的Flag就是该Activity在任务栈中最终启动模式。

Intent.FLAG_ACTIVITY_NEW_TASK
注：Intent.FLAG_ACTIVITY_NEW_TASK单独使用并无任何效果，需要和taskAffinity一起配合着使用。
- 当和taskAffinity一起配合着使用时：Intent.FLAG_ACTIVITY_NEW_TASK + android:taskAffinity 指定非程序包名的任务栈名，与清单文件里面指定 android:launchMode=”singleInstance”效果一致真心一致 （情况2示例）
- 这个Flag常用于在服务中启动Activity，因为服务没有Activity的任务栈，所以只能用一个新的任务栈来启动这个Activity创建实例。
Intent.FLAG_ACTIVITY_SINGLE_TOP
与清单文件里面指定 android:launchMode=”singleTop”效果一致。真心一致。
可尝试作用采用FLAG_ACTIVITY_CLEAR_TOP退出整个程序（多activity）
Intent.FLAG_ACTIVITY_CLEAR_TOP
Intent.FLAG_ACTIVITY_CLEAR_TOP与清单文件里面指定 android:launchMode=”singleTask”效果类似，只是类似。因为当位于任务栈顶部的时候和android:launchMode=”singleTask”产生很大的差别
设置次标记位的Activity，当它启动的时候，同一个任务栈里面位于他上方的Activity会全部出栈，上方全部清掉。
在一个打开时已经被标记为FLAG_ACTIVITY_CLEAR_TOP的界面（现正处于前台任务栈的栈顶），如果我们在此界面打开自己，并且一样标记为FLAG_ACTIVITY_CLEAR_TOP，那么这个时候会经历一次建新毁旧的过程，任务栈里面从结果的来说没什么变化，但是生命周期的着眼于过程的角度来却经历非常大的变化。（下面的情况5有示例）

mark下，这个标记位通常是和FLAG_ACTIVITY_NEW_TASK配合着使用的。在这种情况下被启动的Activty如果已经存在，那么系统就会调用它的onNewIntent方法。如果被调用的Activity使用默认的standrad模式，那么它连同它之上的Activity都要出栈，系统会创建新的实例并入栈置为栈顶。还未尝试

Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS

具有这个标记的Activity不会出现在Activity的历史列表中.
他等同于在xml里面设定 android:excludeFromRecents=”true” 。

情景实测：

准备工作

我们弄一个程序，一共有4个界面，分别是
FirstActivity，这个作为启动页，接下的描述我们用A代替
SecondActivity 页面2，接下的描述我们用B代替
ThirdActivity 页面3 ，接下的描述我们用C代替
FourthActivity 页面4，接下的描述我们用D代替

界面布局类似，每一个页面都有TextView写清楚当前是哪一个界面，并且每一个界面都会有三个Button，都是可以用于启动页面2，页面3和页面4.

就是上面那个样子。

准备工作至此完成

情景1：我们把所有按钮的打开的Activity都设置为Intent.FLAG_ACTIVITY_NEW_TASK，只有默认的启动页是Standard。

完整过程是：然后启动app，打开B，在B打开C，在C打开D，然后在D打开B。
这个过程我们分两步进行。

结论先上：单独给Activity的Intent设置Intent.FLAG_ACTIVITY_NEW_TASK没有作用。

如果说Intent.FLAG_ACTIVITY_NEW_TASK直接等同于在xml将来启动模式设置为singleTask的话，那么在我们 “在D打开B” 个操作中，应该此时任务栈就应该会清掉B以上的C和D，然后只剩下BA，但是结果是任务栈变成了BDCBA，B只是相当于一个普通的实例入栈。所以这个说法不成立。

注：网上有人直接说Intent.FLAG_ACTIVITY_NEW_TASK就相当于singleTask，这是错误的。

贴一下代码，其实要是这么设置Flag特别傻逼，不用这么每个都设置的，这里为了演示需要，大概怎么设置后面会提到的

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.amqr.flagtest" >

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".FirstActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".SecondActivity"/>
        <activity android:name=".ThirdActivity"/>
        <activity android:name=".FourthActivity"/>
    </application>

</manifest>

接下来是四份代码：
FirstActivity

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FirstActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FirstActivity.this, ThirdActivity.class);

                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FirstActivity.this, FourthActivity.class);

                openFourth.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openFourth);
            }
        });

    }
}

.
.
SecondActivity

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(SecondActivity.this, SecondActivity.class);
                openSecond.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(SecondActivity.this,ThirdActivity.class);
                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(SecondActivity.this,FourthActivity.class);

                openFourth.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openFourth);
            }
        });
    }
}

.
.
FourthActivity

public class FourthActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fourth);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FourthActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FourthActivity.this, ThirdActivity.class);
                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FourthActivity.this, FourthActivity.class);
                openFourth.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openFourth);
            }
        });

    }
}

分两个步骤，

第一步：
启动app后A就启动，A打开B，B打开C，C打开D
这是我们来看一下终端的信息：

    Running activities (most recent first):
      TaskRecord{52a650dc #6 A=com.amqr.flagtest U=0 sz=4}
        Run #3: ActivityRecord{529b46e4 u0 com.amqr.flagtest/.FourthActivity t6}
        Run #2: ActivityRecord{52983354 u0 com.amqr.flagtest/.ThirdActivity t6}
        Run #1: ActivityRecord{5295f8c8 u0 com.amqr.flagtest/.SecondActivity t6}
        Run #0: ActivityRecord{52958028 u0 com.amqr.flagtest/.FirstActivity t6}

这是任务栈里面有4个Activity，然后里面分别是DCBA，D为栈顶。

第二步：
我们在D界面打开B

然后重新看一下终端的信息：

    Running activities (most recent first):
      TaskRecord{52a650dc #6 A=com.amqr.flagtest U=0 sz=5}
        Run #4: ActivityRecord{52a3efe8 u0 com.amqr.flagtest/.SecondActivity t6}
        Run #3: ActivityRecord{529b46e4 u0 com.amqr.flagtest/.FourthActivity t6}
        Run #2: ActivityRecord{52983354 u0 com.amqr.flagtest/.ThirdActivity t6}
        Run #1: ActivityRecord{5295f8c8 u0 com.amqr.flagtest/.SecondActivity t6}
        Run #0: ActivityRecord{52958028 u0 com.amqr.flagtest/.FirstActivity t6}

情况1再验证.gif

我们发现，这是在D界面打开的这个B并没有把复用位于A上方的B并且把自己上方的CD清掉，而是像一个普通的任务栈入栈了。
现在任务栈里面有五个Activity，分别是BDCBA，栈顶是第二次打开的B。

证明结论：单独给Activity的Intent设置Intent.FLAG_ACTIVITY_NEW_TASK没有作用。

.
.

情景2

我们给A打开的B设置为Intent.FLAG_ACTIVITY_NEW_TASK，给B打开的C设置为Intent.FLAG_ACTIVITY_NEW_TASK，给C里面要打开的B和C设定为Intent.FLAG_ACTIVITY_NEW_TASK。
然后重点在这里，在清单文件里面给B和C都属性taskAffinity属性。
我们给B设置了 android:taskAffinity=”com.amqr.second222”
给C设置了 android:taskAffinity=”com.amqr.third333”

结论先上：Intent.FLAG_ACTIVITY_NEW_TASK + android:taskAffinity 指定非程序包名的任务栈名，与清单文件里面指定 android:launchMode=”singleInstance”效果一致
完整操作：A打开B，B打开C，C再打开C(这里是打不开的)，C打开B

附上代码：

manifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.amqr.flagtest" >

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".FirstActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".SecondActivity"
            android:taskAffinity="com.amqr.second222"
            />
        <activity android:name=".ThirdActivity"
            android:taskAffinity="com.amqr.third333"
            />
        <activity android:name=".FourthActivity"/>
    </application>

</manifest>

接下来是代码
FirstActivity

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FirstActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FirstActivity.this, ThirdActivity.class);


                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FirstActivity.this, FourthActivity.class);


                startActivity(openFourth);
            }
        });

    }
}

.
.

SecondActivity

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);


        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(SecondActivity.this, SecondActivity.class);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(SecondActivity.this, ThirdActivity.class);

                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(SecondActivity.this, FourthActivity.class);

                startActivity(openFourth);
            }
        });
    }
}

.
.
ThirdActivity

public class ThirdActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_third);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(ThirdActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(ThirdActivity.this, ThirdActivity.class);

                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(ThirdActivity.this, FourthActivity.class);


                startActivity(openFourth);
            }
        });
    }
}

操作分4步：

提醒：这里B和C被打开时都被指定 Intent.FLAG_ACTIVITY_NEW_TASK，而且各自都指定了 android:taskAffinity 名称为非程序包名的自定义任务栈名称

步骤1：A打开B，

    Running activities (most recent first):
      TaskRecord{52a6e690 #54 A=com.amqr.second222 U=0 sz=1}
        Run #1: ActivityRecord{529b601c u0 com.amqr.flagtest/.SecondActivity t54}
      TaskRecord{52928e18 #53 A=com.amqr.flagtest U=0 sz=1}
        Run #0: ActivityRecord{5297ded0 u0 com.amqr.flagtest/.FirstActivity t53}

我们发现此时程序里面有2个任务栈，一个是程序自带的名字为包名的任务栈amqr.flagtest，一个是我们自定义名字的任务栈com.amqr.second222。

步骤2：B打开C

    Running activities (most recent first):
      TaskRecord{52b6a93c #55 A=com.amqr.third333 U=0 sz=1}
        Run #2: ActivityRecord{52a8d5f8 u0 com.amqr.flagtest/.ThirdActivity t55}
      TaskRecord{52a6e690 #54 A=com.amqr.second222 U=0 sz=1}
        Run #1: ActivityRecord{529b601c u0 com.amqr.flagtest/.SecondActivity t54}
      TaskRecord{52928e18 #53 A=com.amqr.flagtest U=0 sz=1}
        Run #0: ActivityRecord{5297ded0 u0 com.amqr.flagtest/.FirstActivity t53}

此时有三个任务栈，其中自定义名字的任务栈com.amqr.third333是前台任务栈，其他两个都是后台任务栈。

步骤3：C打开C
我们发现，C没有办法打开C。所以任务栈里面没有什么变化

      TaskRecord{52b6a93c #55 A=com.amqr.third333 U=0 sz=1}
        Run #2: ActivityRecord{52a8d5f8 u0 com.amqr.flagtest/.ThirdActivity t55}
      TaskRecord{52a6e690 #54 A=com.amqr.second222 U=0 sz=1}
        Run #1: ActivityRecord{529b601c u0 com.amqr.flagtest/.SecondActivity t54}
      TaskRecord{52928e18 #53 A=com.amqr.flagtest U=0 sz=1}
        Run #0: ActivityRecord{5297ded0 u0 com.amqr.flagtest/.FirstActivity t53}

也就是说，在步骤二的时候我们的页面3，也就是ThirdActivity在这个地方已经是存放com.amqr.third333任务栈里面，而且com.amqr.third333是前台任务栈，在这种情况下我们进行步骤三，在页面3再打开一次页面3，这是没有任何作用的。复用顶部，没有新的实例产生，需要注意的是，这种方式产生的任务栈只能存放一个Activity。

步骤4：C打开B

    Running activities (most recent first):
      TaskRecord{52a6e690 #54 A=com.amqr.second222 U=0 sz=1}
        Run #2: ActivityRecord{529b601c u0 com.amqr.flagtest/.SecondActivity t54}
      TaskRecord{52b6a93c #55 A=com.amqr.third333 U=0 sz=1}
        Run #1: ActivityRecord{52a8d5f8 u0 com.amqr.flagtest/.ThirdActivity t55}
      TaskRecord{52928e18 #53 A=com.amqr.flagtest U=0 sz=1}
        Run #0: ActivityRecord{5297ded0 u0 com.amqr.flagtest/.FirstActivity t53}

发现没有产生新的任务栈，也有添加任务Activity。但是前台任务栈改变了，几个任务栈的顺序和前后台关系产生了变化，com.amqr.second222由后台任务栈变成了前台任务栈。

每一个任务栈里面一个Activity，不增不减。

结论：Intent.FLAG_ACTIVITY_NEW_TASK + android:taskAffinity 指定非程序包名的任务栈名，与清单文件里面指定 android:launchMode=”singleInstance”效果一致

.
.

情景3：把所有的按钮点击事件的Intent的全部设定为Intent.FLAG_ACTIVITY_SINGLE_TOP。

没什么区别，这里就只贴一份FirstActivity的代码就好了，其他类似。反正改变的都是四份代码的里面的全部的点击事件的Intent的addFlag从Intent.FLAG_ACTIVITY_NEW_TASK改成Intent.FLAG_ACTIVITY_SINGLE_TOP。

结论先上： * 设定Intent.FLAG_ACTIVITY_SINGLE_TOP与清单文件里面指定 android:launchMode=”singleTop”效果一致。*

操作：A打开B，再打开（复用，无新实例），B打开C，再代开C（复用，无新实例），C打开D，D再开D（复用，无新实例）

FirstActivity代码


public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FirstActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FirstActivity.this, ThirdActivity.class);

                openThird.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FirstActivity.this, FourthActivity.class);

                openFourth.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(openFourth);
            }
        });

    }
}

情景3.gif

这里我们就不贴终端了。一个gif说明一切。

从图中我们可以看到，（我们的B，C和D页面都是每次打开的都是Intent.FLAG_ACTIVITY_SINGLE_TOP的），当我们打开页面B，之后，想再次打次B，就没有新的实例产生了，而是复用了顶部的B。
C和D也是这种情况发生。图中也做了演示。

而且在最后，我们发现当我们从A打开B，从B打开C，再从C打开D，最后D打开B的时候，就又可以打开B了，又有一个B的实例产生并且位于栈顶了。所以这一切的一切都是跟xml设定launchMode为singleTop完全一致的。

证明结论：设定Intent.FLAG_ACTIVITY_SINGLE_TOP与清单文件里面指定 android:launchMode=”singleTop”效果一致。

情景4 把A、B和C页面的按钮的打开页面的Intent都不设置addFlag，即ABC打开的页面都是standard，然后页面D的打开页面B的Intent的addFlag都设定的Intent.FLAG_ACTIVITY_CLEAR_TOP，其他两个按钮不设置Flag。

先上结论：
结论1：Intent.FLAG_ACTIVITY_CLEAR_TOP与清单文件里面指定 android:launchMode=”singleTask”效果类似，只是类似。因为当初顶部的时候和android:launchMode=”singleTask”产生很大的差别
（参考情景5我们就知道是区别在哪里了）

结论2： 代码指定Flag（不单指FLAG_ACTIVITY_CLEAR_TOP），使得Activity启动模式可变，而且最后一次指定的Flag就是该Activity在任务栈中最终启动模式。

这个上代码吧，因为后面还要描述一些事情。

FirstActivity

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FirstActivity.this, SecondActivity.class);

                //openSecond.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FirstActivity.this, ThirdActivity.class);


                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FirstActivity.this, FourthActivity.class);


                startActivity(openFourth);
            }
        });

    }
}

.
.
SecondActivity

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);


        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(SecondActivity.this, SecondActivity.class);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(SecondActivity.this, ThirdActivity.class);


                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(SecondActivity.this, FourthActivity.class);

                startActivity(openFourth);
            }
        });
    }
}

.
.
ThirdActivity

public class ThirdActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_third);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(ThirdActivity.this, SecondActivity.class);


                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(ThirdActivity.this, ThirdActivity.class);


                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(ThirdActivity.this, FourthActivity.class);


                startActivity(openFourth);
            }
        });
    }
}

.
.
FourthActivity

public class FourthActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fourth);

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FourthActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FourthActivity.this, ThirdActivity.class);

                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FourthActivity.this, FourthActivity.class);

                startActivity(openFourth);
            }
        });

    }
}

就是这样，其实目前只有在页面D里面的用于打开页面B的按钮设置了Intent.FLAG_ACTIVITY_CLEAR_TOP的Flag

操作：我们启动A，A启动B，B启动B，B在启动C，C启动D，再从D启动B。

分两步走：

第一步：
我们启动A，A启动B，B在启动C，C启动D，此时任务栈的里面的情况是DCBA，其中D为栈顶。

    Running activities (most recent first):
      TaskRecord{52938abc #36 A=com.amqr.flagtest U=0 sz=4}
        Run #3: ActivityRecord{52978c64 u0 com.amqr.flagtest/.FourthActivity t36}
        Run #2: ActivityRecord{52946268 u0 com.amqr.flagtest/.ThirdActivity t36}
        Run #1: ActivityRecord{52a8fd24 u0 com.amqr.flagtest/.SecondActivity t36}
        Run #0: ActivityRecord{52a0a8b4 u0 com.amqr.flagtest/.FirstActivity t36}

第二步：再从D启动B。
这时我们会发现，任务栈变成BA，其中B为栈顶，C和D都被B给干掉了。

    Running activities (most recent first):
      TaskRecord{52938abc #36 A=com.amqr.flagtest U=0 sz=2}
        Run #1: ActivityRecord{52969568 u0 com.amqr.flagtest/.SecondActivity t36}
        Run #0: ActivityRecord{52a0a8b4 u0 com.amqr.flagtest/.FirstActivity t36}

证明结论：Intent.FLAG_ACTIVITY_CLEAR_TOP与清单文件里面指定 android:launchMode=”singleTask”效果类似。（当位于栈内没什么确实效果一致，当位于栈顶就很不一样了）

我们这里做了个实验。

我们看到代码里我们的FirstActivity打SecondActivity的时候（就是A打开B的时候），并没有设定Intent的Flag，即可A打开B的时候B在任务栈里面是属于Standard模式的，但是在D打开C的时候，因为我们指定打开B的时候B需要使用FLAG_ACTIVITY_CLEAR_TOP模式，所以这个时候就从Standard变成了FLAG_ACTIVITY_CLEAR_TOP（singleTask效果）了。

可见，代码设定最大Flag好处就是启动模式可变，而XML则是定死的。

这里如果我们反过来，把上面代码稍作修改，把在A页面打开B的时候把B设为FLAG_ACTIVITY_CLEAR_TOP，然后D打开B不添加任何Flag（即为D打开的B为Standard），发现这样设定之后，我们D打开B，结果是多产生了一个B的实例，而是不是B把D和C都给清掉。这就再一次证明最后设定开启该Activity的模式其最终的启动模式。

结论证明 代码指定Flag使得Activity启动模式可变，而且最后一次指定的Flag就是该Activity在任务栈中最终的模式。

情景5，把A打开B，B打开B的界面都设定为Intent.FLAG_ACTIVITY_CLEAR_TOP，然后A启动B，B启动B。

结论：在一个打开时已经被标记为FLAG_ACTIVITY_CLEAR_TOP的界面（现正处于前台任务栈的栈顶），如果我们在此界面打开自己，并且一样标记为FLAG_ACTIVITY_CLEAR_TOP，那么这个时候会经历一次建新毁旧的过程，任务栈里面从结果的来说没什么变化，但是从生命周期的着眼于过程的角度来却经历非常大的变化。

步骤一：A打开B:

终端


    Running activities (most recent first):
      TaskRecord{52ac1a08 #61 A=com.amqr.flagtest U=0 sz=2}
        Run #1: ActivityRecord{529e1994 u0 com.amqr.flagtest/.SecondActivity t61}
        Run #0: ActivityRecord{529ca8e0 u0 com.amqr.flagtest/.FirstActivity t61}

生命周期

12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onCreate
12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onStart
12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onResume
// A打开B
12-06 01:09:25.694 5768-5768/com.amqr.flagtest D/Cur: FirstActivity  onPause
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onCreate
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onStart
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onResume
12-06 01:09:26.090 5768-5768/com.amqr.flagtest D/Cur: FirstActivity  onStop

在这里位置一切正常，下面发生的事情比较诡异

步骤二：B打开B，这个是否发生的比较诡异，不是复用，而是建立一个新的，毁灭旧的。

这里贴代码非常有必要：
manifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.amqr.flagtest" >

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".FirstActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".SecondActivity"
            />
        <activity android:name=".ThirdActivity"
            />
        <activity android:name=".FourthActivity"/>
    </application>

</manifest>

FirstActivity

public class FirstActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);
        Log.d("Cur", "FirstActivity  onCreate");

        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(FirstActivity.this, SecondActivity.class);

                openSecond.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(FirstActivity.this, ThirdActivity.class);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(FirstActivity.this, FourthActivity.class);
                startActivity(openFourth);
            }
        });

    }


    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Cur", "FirstActivity  onStart");
    }



    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Cur", "FirstActivity  onResume");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Cur", "FirstActivity  onPause");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Cur", "FirstActivity  onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Cur", "FirstActivity  onDestroy");
    }


    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Cur", "FirstActivity  onRestart");
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        Log.d("Cur", "FirstActivity  onNewIntent");
    }
}

SecondActivity

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Log.d("Cur","SecondActivity  onCreate");


        findViewById(R.id.mBtOpen2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openSecond = new Intent(SecondActivity.this, SecondActivity.class);
                openSecond.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                startActivity(openSecond);
            }
        });

        findViewById(R.id.mBtOpen3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openThird = new Intent(SecondActivity.this, ThirdActivity.class);
                startActivity(openThird);
            }
        });

        findViewById(R.id.mBtOpen4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent openFourth = new Intent(SecondActivity.this, FourthActivity.class);
                startActivity(openFourth);
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Cur", "SecondActivity  onStart");
    }



    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Cur", "SecondActivity  onResume");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Cur", "SecondActivity  onPause");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Cur", "SecondActivity  onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Cur", "SecondActivity  onDestroy");
    }


    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Cur", "SecondActivity  onRestart");
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        Log.d("Cur", "SecondActivity  onNewIntent");
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.d("Cur", "SecondActivity  onSaveInstanceState");
    }
}

.
.

看完了代码，我们先来看一下gif图。

诡异的FLAG_ACTIVITY_CLEAR_TOP.gif

当我们在 B 界面打开B的时候，根据的页面的闪一下的反馈我们感觉这时候一个重新创建了B的一个实例，那么按道理任务这时候的情况就是BBA，B为栈顶，A为栈底，如果照着这种想法那么我们此时按下back键应该是返回到B界面，任务栈变成BA，B为栈顶。
但是实际上发生的却不是这个样子的，实际上发生的事情却是：
按下back键，直接返回A界面。
再按一次back键就退出了程序了。

这意味着什么？这意味我们的眼睛欺骗了我们，屏幕闪的那一下是创建的一个B的实例没有错，但是我们看不到的事情是在新建新的实例入栈的同时那么旧的B就被销毁掉了。所以，当我们屏幕闪一下之后，任务栈存在的是BA，B为栈顶，而不是BBA。

终端显示的是每没打开之前一样，没有变化（因为它只是记录最后的结果，不管过程）
（此时显示的是B打开B之后的状态，还没按下back）

    Running activities (most recent first):
      TaskRecord{52ac1a08 #61 A=com.amqr.flagtest U=0 sz=2}
        Run #1: ActivityRecord{52a0fb5c u0 com.amqr.flagtest/.SecondActivity t61}
        Run #0: ActivityRecord{529ca8e0 u0 com.amqr.flagtest/.FirstActivity t61}

从生命周期的变化我们大概明白这一切是怎么发生的了。


12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onCreate
12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onStart
12-06 01:09:22.978 5768-5768/? D/Cur: FirstActivity  onResume
//  A打开B
12-06 01:09:25.694 5768-5768/com.amqr.flagtest D/Cur: FirstActivity  onPause
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onCreate
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onStart
12-06 01:09:25.698 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onResume
12-06 01:09:26.090 5768-5768/com.amqr.flagtest D/Cur: FirstActivity  onStop

// B打开B  从生命周期我们发生了原因，B在这里灭掉了自己，然后重建一个自己
12-06 01:11:50.390 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onPause
12-06 01:11:50.410 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onCreate
12-06 01:11:50.410 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onStart
12-06 01:11:50.410 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onResume
12-06 01:11:50.786 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onStop
12-06 01:11:50.786 5768-5768/com.amqr.flagtest D/Cur: SecondActivity  onDestroy

结论：设定为Intent.FLAG_ACTIVITY_CLEAR_TOP的Activity处于前台任务栈栈顶时，如果在当前页面打开自己，经历了一个建新毁旧的过程，算不上复用。
（这个过程会创建一个新的实例，然后把旧的自己给销毁掉，这个结果在任务栈的最终结果看来是没变化的，但是实际上生命周期却发生了很大的变化。）

结论：在一个打开时已经被标记为FLAG_ACTIVITY_CLEAR_TOP的界面（现正处于前台任务栈的栈顶），如果我们在此界面打开自己，并且一样标记为FLAG_ACTIVITY_CLEAR_TOP，那么这个时候会经历一次建新毁旧的过程，没有复用，任务栈里面从结果的来说没什么变化，但是生命周期的着眼于过程的角度来却经历非常大的变化。

本篇完。

阿敏其人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android-Activity所应该了解的大概就这样。（下）

版权声明：本文出自阿敏其人的专栏，转载或使用请注明出处。Android-Activity所应该了解的大概就这样。（上）Android-Activity所应该了解的大概就这样。（中）六、FLAG我们知道，Android给Activity设定启动模式的方式有有两种。一种是在manifest里面设置，另一种是在通过Intent的FLAG设置。 FLAG，在安卓里面是标记位的意思，Flag有很多
复制链接

扫一扫