Android Activity的理解和使用

Activity解析

1、什么是Activity

Activity是一个Android的应用组件，它提供屏幕进行交互。每个Activity都会获得一个用于绘制其用户界面的窗口，窗口可以充满哦屏幕也可以小于屏幕并浮动在其他窗口之上。

一个应用通常是由多个彼此松散联系的Activity组成，一般会指定应用中的某个Activity为主活动，也就是说首次启动应用时给用户呈现的Activity。将Activity设为主活动的方法，如下面代码所示需要在AndroidManifest文件中添加以下内容

<application>
     ....
    <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
     </activity>
     ....
</application>      

当然Activity之间可以进行互相跳转，以便执行不同的操作。每当新Activity启动时，旧的Activity便会停止，但是系统会在堆栈也就是返回栈中保留该Activity。当新Activity启动时，系统也会将其推送到返回栈上，并取得用户的操作焦点。当用户完成当前Activity并按返回按钮是，系统就会从堆栈将其弹出销毁，然后回复前一Activity

当一个Activity因某个新Activity启动而停止时，系统会通过该Activity的生命周期回调方法通知其这一状态的变化。Activity因状态变化每个变化可能有若干种，每一种回调都会提供执行与该状态相应的特定操作的机会

2、创建Activity

要创建Activity，必须创建Activity的子类。在子类中实现Activity在生命周期的各种状态之间转变时例如创建 Activity、停止 Activity、恢复 Activity 或销毁 Activity 时）系统调用的回调方法。Android Studio中新建项目默认创建的代码为

public class MainActivity extends AppCompatActivity {

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

onCreate()方法：必须实现的方法，系统在创建Activity时调用此方法。您应该在实现内初始化Activity的必要组件，必须在此方法调用setContentView(),用来定义Activity用户界面布局（XML文件）

3、在清单文件中声明Activity

每次新建的Activity都需要在AndroidManifest文件中添加如下内容，并将元素添加为元素的子项

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

4、启动Activity

该部分用于描述如何启动Activity。作为主活动，在应用开启的时候就会系统创建，而用户不仅仅只需要主活动界面，用户需要界面的跳转，而界面的跳转也是其他活动界面（Activity）启动。
在该部分仅仅只提及利用显示Intent方式跳转活动，代码如下

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);
//this,为本Acitivity的上下文；第二个参数为你要跳转的目的Activity.class

4.1、Android任务栈

Activity是可以层叠摆放的，没启动一个新的Activity就会覆盖原有的Activity之上，如果单击返回，则最上面的Activity会被销毁，下面的Activity重新显示。Activity之所以这样显示，是因为Android系统是通过任务栈的方式来管理Activity实例的。

栈是一种先进后出的数据结构。在Android中，采用任务栈的形式来管理Activity，栈中Activity的顺序是按照它们被打开的顺序依次存放的。

通常一个应用程序对应一个任务栈。默认情况下没启动一个Activity都会入栈，并处于栈顶的位置，用户操作的永远都是栈顶的Activity。在栈中的Activity只有压入和弹出两种操作，被当前Activity启动时压入，用户单击返回按钮时弹出。

4.2、Activity的启动模式

Activity为什么需要启动模式？

我们都知道启动一个Activity后，这个Activity实例就会被放入任务栈中，当点击返回键的时候，位于任务栈顶层的Activity就会被清理出去，当任务栈中不存在任何Activity实例后，系统就回去回收这个任务栈，也就是程序退出了。这只是对任务栈的基本认识，深入学习，笔者会在之后文章中提到。那么问题来了，既然每次启动一个Activity就会把对应的要启动的Activity的实例放入任务栈中，假如这个Activity会被频繁启动，那岂不是会生成很多这个Activity的实例吗？对内存而言这可不是什么好事，明明可以一个Activity实例就可以应付所有的启动需求，为什么要频繁生成新的Activity实例呢？杜绝这种内存的浪费行为，所以Activity的启动模式就被创造出来去解决上面所描述的问题。

4.2.1、Activity的启动模式有哪些？

细谈Activity四种启动模式

Activity 一共有以下四种 launchMode：

1.standard
2.singleTop
3.singleTask
4.singleInstance

可以在 AndroidManifest.xml 配置的 android:launchMode 属性为以上四种之一即可。

也可以在代码中指定：

Intent pack = new Inten(MCPersonalCenterActivity.this,MCGiftsCenterActivity.class);
pack.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(pack);

1、standard：默认的启动模式

默认启动模式，每次激活Activity时都会创建Activity，并放入任务栈中。

standard 模式是默认的启动模式，不用为配置 android:launchMode 属性即可，当然也可以指定值 为 standard。

原理如下：

标准模式，这也是系统的默认模式。每次启动一个Activity都会重新创建一个新的实例，不管这个实例是否存在。被创建的实例的生命周期符合典型情况下的Activity的生命周期。在这种模式下，谁启动了这个Activity,那么这个Activity就运行在启动它的那个Activity的任务栈中。比如Activity A启动了Activity B(B是标准模式)，那么B就会进入到A所在的任务栈中。有个注意的地方就是当我们用ApplicationContext 去启动standard模式的Activity就会报错，这是因为standard模式的Actiivty默认会进入启动它的Activity所属的任务栈中，但是由于非Activity类型的Context(如ApplicationContext)并没有所谓的任务栈，所以这就会出现错误。解决这个问题的方法就是为待启动的Activity指定FLAG_ACTIVITY_NEW_TASK标记位，这样启动的时候就会为它创建一个新的任务栈，这个时候启动Activity实际上以singleTask模式启动的，读者可以自己仔细体会。

如图所示，每次跳转系统都会在 task 中生成一个新的 FirstActivity 实例，并且放于栈结构的顶部，当我们按下后退键时，才能看到原来的 FirstActivity 实例。

2 singleTop：栈顶复用模式

在这种模式下，如果新的Activity已经位于任务栈的栈顶，那么此Activity不会被重新创建，同时它的onNewIntent方法被回调，通过此方法的参数我们可以取出当前请求的信息。需要注意的是，这个Activity的onCreate,onStart不会被系统调用，因为它并没有发生改变。如果新的Activity已经存在但不是位于栈顶，那么新的Activity仍然会重新重建。举个例子，假设目前栈内的情况为ABCD,其中ABCD为四个Activity,A位于栈低，D位于栈顶，这个时候假设要再次启动D,如果D的启动模式为singleTop,那么栈内的情况依然为ABCD;如果D的启动模式为standard,那么由于D被重新创建，导致栈内的情况为ABCDD。

3.栈内复用模式：SingTask
这是一种单例实例模式，在这种模式下，只要Activity在一个栈中存在，那么多次启动此Activity都不会重新创建实例，和singleTop一样，系统也会回调其onNewIntent。具体一点，当一个具有singleTask模式的Activity请求启动后，比如Activity A，系统首先寻找任务栈中是否已存在Activity A的实例，如果已经存在，那么系统就会把A调到栈顶并调用它的onNewIntent方法，如果Activity A实例不存在，就创建A的实例并把A压入栈中。举几个栗子：

• 比如目前任务栈S1的情况为ABC,这个时候ActivityD以singleTask模式请求启动，其所需的任务栈为S2，由于S2和D的实例均不存在，所以系统会先创建任务栈S2,然后再创建D的实例并将其投入到S2任务栈中。
• 另外一种情况是，假设D所需的任务栈为S1,其他情况如同上面的例子所示，那么由于S1已经存在，所以系统会直接创建D的实例并将其投入到S1。
• 如果D所需的任务栈为S1,并且当前任务栈S1的情况为ADBC,根据栈内复用的原则，此时D不会重新创建，系统会把D切换到栈顶并调用其onNewIntent方法，同时由于singleTask默认具有clearTop的效果，会导致栈内所有在D上面的Activity全部出栈，于是最终S1中的情况为AD。
  
  在图中的下半部分是 SecondActivity 跳转到 FirstActivity 后的栈结构变化的结果，我们注意到，SecondActivity消失了，没错，在这个跳转过程中系统发现有存在的 FirstActivity 实例，于是不再生成新的实例，而是将 FirstActivity之上的 Activity 实例统统出栈，将 FirstActivity 变为栈顶对象，显示到幕前。
  

4.单实例模式：SingleInstance
  这是一种加强的singleTask模式，它除了具有singleTask模式所有的特性外，还加强了一点，那就是具有此种模式的Activity只能单独位于一个任务栈中，换句话说，比如Activity A是singleInstance模式，当A启动后，系统会为它创建一个新的任务栈，然后A独自在这个新的任务栈中，由于栈内复用的特性，后续的请求均不会创建新的Activity,除非这个独特的任务栈被系统销毁了。

对于SingleInstance,面试时你有说明它的以下几个特点：

（1）以singleInstance模式启动的Activity具有全局唯一性，即整个系统中只会存在一个这样的实例。

（2）以singleInstance模式启动的Activity在整个系统中是单例的，如果在启动这样的Activiyt时，已经存在了一个实例，那么会把它所在的任务调度到前台，重用这个实例。

（3）以singleInstance模式启动的Activity具有独占性，即它会独自占用一个任务，被他开启的任何activity都会运行在其他任务中。

（4）被singleInstance模式的Activity开启的其他activity，能够在新的任务中启动，但不一定开启新的任务，也可能在已有的一个任务中开启。

换句话说，其实SingleInstance就是我们刚才分析的SingleTask中，分享Activity为栈底元素的情况。

总结
上面介绍了4种启动模式，这里需要指出一种情况，我们假设目前有2个任务栈，前台任务栈的情况为AB,而后台任务栈的情况为CD，这里假设CD的启动模式均为singleTask。现在请求启动D,那么整个后台任务栈都会被切换到前台，这个时候整个后退列表变成了ABCD。当用户按back键的时候，列表中的Activity会一一出栈，如下图1所示：

注意：
前台任务栈：就是指和用户正在交互的应用程序所在的任务栈。
后台任务栈：就是指处于后台的应用程序所在的任务栈。

如果不是请求的D而是请求的C,那么情况就不一样了，如下图2所示：

5、结束Activity

通过调用Activity的finish()方法来结束Activity还可以通过调用finishActivity()结束之前启动的活动

关于finishActivity()的理解：

你通过 MainActivity 来启动 ActivityA （使用 startActivityForResult 方法），那么你在 MainActivity 这个类中需要重写 onActivityResult() 这个方法，
然后，你可以在 onActivityResult() 中通过 finishActivity() 方法去结束掉 ActivityA

5.1、异常情况下的生命周期

情况1：资源相关的系统配置发生改变导致Activity被杀死并重新创建。

可以从图中看出当Activity发生意外的情况的时候，这里的意外指的就是系统配置发生改变，Activity会被销毁，其onPause,OnStop,onDestory函数均会被调用，同时由于Actiivty是在异常情况下终止的，系统会调用onSaveInstanceState来保存当前Activity状态。调用onSaveInstanceState的时机总会发生在onStop之前，至于会不会调用时机发生在onPause方法之前，那就说不定了，这个没有固定的顺序可言，正常情况下一般onSaveInstanceState不会被调用。当Activity被重新创建后，系统会调用onRestoreInstanceState,并且把Actiivty销毁时onSaveInstanceState方法所保存的Bundle对象作为参数传递给onRestoreInstanceState和onCreate方法。所以我们可以通过onRestoreInstanceState和onCreate方法来判断Actiivty是否被重建了，如果被重建了，那么我们就可以取出之前保存的数据并恢复，从时序上来看，onRestoreInstanceState的调用时机发生在onStart之后。

同时，在onSaveInstanceState和onRestoreInstanceState方法中，系统自动为我们做了一定的恢复工作。当Activity在异常情况下需要重新创建时，系统会默认为我们保存当前Activity的视图结构。当Activity在异常情况下需要重新创建时，系统会默认为我们保存当前Activity的视图结构，并且在Activity重启后为我们恢复这些数据，比如：文本框中用户输入的数据,ListView滚动的位置等，这些View相关的状态系统都能够默认为我们恢复。具体针对某一个特定的View系统 能为我们恢复哪些数据，我们可以查看View的源码。和Activity一样，每个View都有onSaveInstanceState和onRestoreInstanceState这两个方法，看一下它们的具体实现，就能知道系统能够自动为每个View恢复哪些数据。

关于保存和恢复View层次结构，系统的工作流程是这样的：

首先Activity被意外终止时，Activity会调用onSaveInstanceState去保存数据，然后Activity会委托Window去保存数据，接着Window在委托它上面的顶级容器去保存数据。顶级容器是一个ViewGroup，一般来说它很可能是DecorView。最后顶层容器再去一一通知它的子元素来保存数据，这样整个数据保存过程就完成了。可以发现，这是一个典型的委托思想，上层委托下层，父容器去委托子元素去处理一件事情，这种思想在Android中有很多应用，比如：View的绘制过程，事件分发等都是采用类似的思想。至于数据恢复过程也是类似的，这样就不再重复介绍了。

情况2：资源内存不足导致低优先级的Activity被杀死。

首先，Activity有优先级？你肯定怀疑，代码中都没设置过啊！优先级从何而来，其实这里的Activity的优先级是指一个Activity对于用户的重要程度，比如：正在与用户进行交互的Activity那肯定是最重要的。我们可以按照重要程度将Activity分为以下等级：

优先级最高： 与用户正在进行交互的Activity，即前台Activity。

优先级中等：可见但非前台的Activity,比如：一个弹出对话框的Activity,可见但是非前台运行。

优先级最低：完全存在与后台的Activity,比如：执行了onStop。

当内存严重不足时，系统就会按照上述优先级去kill掉目前Activity所在的进程，并在后续通过onSaveInstanceState和onRestoreInstanceState来存储和恢复数据。如果一个进程中没有四大组件的执行，那么这个进程将很快被系统杀死，因此，一些后台工作不适合脱离四大组件独立运行在后台中，这样进程更容易被杀死。比较好的方法就是将后台工作放入Service中从而保证进程有一定的优先级，这样就不会轻易地被系统杀死。

6、管理Activity生命周期

周期即活动从开始到结束所经历的各种状态。生命周期即活动从开始到结束所经历的各个状态。从一个状态到另一个状态的转变，从无到有再到无，这样一个过程中所经历的状态就叫做生命周期。

Activity本质上有四种状态：

• 1.运行（Active/Running）:Activity处于活动状态，此时Activity处于栈顶，是可见状态，可以与用户进行交互
• 2.暂停（Paused）:当Activity失去焦点时，或被一个新的非全面屏的Activity，或被一个透明的Activity放置在栈顶时，Activity就转化为Paused状态。此刻并不会被销毁，只是失去了与用户交互的能力，其所有的状态信息及其成员变量都还在，只有在系统内存紧张的情况下，才有可能被系统回收掉
• 3.停止（Stopped）:当Activity被系统完全覆盖时，被覆盖的Activity就会进入Stopped状态，此时已不在可见，但是资源还是没有被收回
• 4.系统回收（Killed）:当Activity被系统回收掉，Activity就处于Killed状态

如果一个活动在处于停止或者暂停的状态下，系统内存缺乏时会将其结束（finish）或者杀死（kill）。这种非正常情况下，系统在杀死或者结束之前会调用onSaveInstance()方法来保存信息，同时，当Activity被移动到前台时，重新启动该Activity并调用onRestoreInstance()方法加载保留的信息，以保持原有的状态。

正常情况下的生命周期

Activity启动–>onCreate()–>onStart()–>onResume()

  点击home键回到桌面–>onPause()–>onStop()

  再次回到原Activity时–>onRestart()–>onStart()–>onResume()

  退出当前Activity时–>onPause()–>onStop()–>onDestroy()

在上面的四中常有的状态之间，还有着其他的生命周期来作为不同状态之间的过度，用于在不同的状态之间进行转换，生命周期的具体说明见下。

• Activity 的整个生命周期发生在 onCreate() 调用与 onDestroy() 调用之间。您的 Activity 应在 onCreate()中执行“全局”状态设置（例如定义布局），并释放 onDestroy()中的所有其余资源。例如，如果您的Activity 有一个在后台运行的线程，用于从网络上下载数据，它可能会在onCreate() 中创建该线程，然后在onDestroy()
  中停止该线程。
• Activity 的可见生命周期发生在 onStart() 调用与 onStop() 调用之间。在这段时间，用户可以在屏幕上看到Activity 并与其交互。例如，当一个新 Activity 启动，并且此 Activity不再可见时，系统会调用onStop()。您可以在调用这两个方法之间保留向用户显示 Activity 所需的资源。例如，您可以在onStart() 中注册一个 BroadcastReceiver 以监控影响UI的变化，并在用户无法再看到您显示的内容时在 onStop()中将其取消注册。在 Activity 的整个生命周期，当 Activity在对用户可见和隐藏两种状态中交替变化时，系统可能会多次调用 onStart() 和 onStop()。
• Activity 的前台生命周期发生在 onResume() 调用与 onPause() 调用之间。在这段时间，Activity位于屏幕上的所有其他 Activity 之前，并具有用户输入焦点。Activity 可频繁转入和转出前台 — 例如，当设备转入休眠状态或出现对话框时，系统会调用onPause()。由于此状态可能经常发生转变，因此这两个方法中应采用适度轻量级的代码，以避免因转变速度慢而让用户等待。

处于运行状态的Activity即将执行onPause()函数，什么情况下促使Activity执行onPause()方法呢？
 
 [1]启动了一个新的Activity
 [2]返回上一个Activity
 
 可以理解为当需要其他Activity，当前的Activity必须先把手头的工作暂停下来，再来把当前的界面空间交给下一个需要界面的Activity，而onPause()方法可以看作是一个转接工作的过程，因为屏幕空间只有那么一个，每次只允许一个Activity出现在前台进行工作。通常情况下onPause()函数不会被单独执行，执行完onPause()方法后会继续执行onStop()方法，执行完onStop()方法才真正意味着当前的Activity已经退出前台，存在于后台。
 
Activity即将执行onStop()函数，当Activity要从前台切换至后台的时候会执行，比如：用户点击了返回键，或者用户切换至其他Activity等。

何时调用onRestart

在 Activity 被 onStop 后，但是没有被 onDestroy，在再次启动此 Activity 时就调用 onRestart（而不再调用 onCreate）方法；如果被 onDestroy 了，则是调用 onCreate 方法。

onPause vs onStop

(a) 只要activity还可见，就不会调用onStop。所以我们可以知道onStop调用时机是：当一个activity对用户已经不可见的时候就会调用。
(b) 官方说明：onStop可能永远不会被调用：当处于低内存状态下，系统没有足够的内存保持你的activity的处理运行在activity的onPause调用之后。
© 从(b)知道onStop在低内存情况下不会被调用，但是：onPause一定会被调用。

7、例子验证Activity活动周期

接下来就用一个小例子进行函数回调的验证

代码很简单创建两个Activity以及相应的界面，每个界面只有一个按钮和TextView,按钮设置用来进行页面跳转的点击事件。每个回调函数内都有一个Log输出，所以验证的结果也是通过查看Logcat来进行查看，下面贴出MainActivity代码,所跳转的SecondActivity代码与之类似，故不贴出，只需在MainActivity代码上进行修改。

package com.example.martinzou.android_exp_2;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {
    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("MainActivity","onCreate()被调用");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button=(Button)findViewById(R.id.button1);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent=new Intent(MainActivity.this,SecondActivity.class);
                startActivity(intent);
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("MainActivity","onStart()被调用");
    }


    @Override
    protected void onResume() {
        super.onResume();
        Log.d("MainActivity","onResume()被调用");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("MainActivity","onPause()被调用");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("MainActivity","onStop()被调用");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("MainActivity","onDestroy()被调用");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("MainActivity","onRestart()被调用");
    }
}

设计的两个布局文件如下所示

1.在手机上运行起来打开，查看Logcat如下图所示

手机加载应用至显示界面时，Activity启动–>onCreate()–>onStart()–>onResume()依次被调用。此时MainActivity处于可交互的状态。

2.当我按下Home键时回到主界面时Logcat为

点击Home键回到主界面(Activity不可见)–>onPause()–>onStop()依次被调用。

3.当点击Home键回到主界面后，再次点击App回到Activity时，Logcat结果如下

我们可以发现重新回到Activity时，调用了onRestart方法，onStart方法，onResume方法。因此，

当我们再次回到原Activity时–>onRestart()–>onStart()–>onResume()依次被调用。

4.当我按下返回键时，应用退出，MainActivity被销毁（Destroyed）

onPause()->onStop()->onDestroy()依次被调用，MainActivity被销毁。

5.当加载应用进入主界面，并点击按钮进行页面跳转时，查看Logcat为

在原Activity调用了onPause()和onStop()方法，同时我们也发现了，在进行MainActivity进行完onPause()之后SecondActivity的生命周期方法才能被回调，所以这就是为什么onPause()方法不能操作耗时任务的原因了。

6.当我们点击Back键回退时，Logcat结果为

点击之后SecondActivity的onPause()方法，onStop()方法，onDestroy()方法依次调用，MainActivity的onRestart(),onStart(),onResume()会依次调用。在进行SecondActivity进行完onPause()之后MainActivity的生命周期方法才能被回调。

7.当我们点击SecondActivity界面中的按钮跳到MainActivity，Logcat为下图所示

会发现MainActivity并不会调用onRestart(),而是直接进行onCreate(),onStart(),onResume()的调用，跳转完毕之后SecondActivity并没有被销毁卫视处于onStop()状态，这表明SecondActivity()并没有被销毁。

小结:当Activity启动时，依次会调用onCreate(),onStart(),onResume()，而当Activity退居后台时（不可见，点击Home或者被新的Activity完全覆盖），onPause()和onStop()会依次被调用。当Activity重新回到前台（从桌面回到原Activity或者被覆盖后又回到原Activity）时，onRestart()，onStart()，onResume()会依次被调用。当Activity退出销毁时（点击back键），onPause()，onStop()，onDestroy()会依次被调用，到此Activity的整个生命周期方法回调完成。

参考

1、https://blog.csdn.net/fjnu_se/article/details/80703815
2、https://blog.csdn.net/ClAndEllen/article/details/79257489?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=1328655.12207.16158978659132473&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control
3、https://blog.csdn.net/qq_35507234/article/details/82718794?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-6.control&dist_request_id=1328655.12207.16158978659132473&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-6.control