【我的Android开发】AMS中Activity栈管理

概述

Activity栈管理是AMS的另一个重要功能，栈管理又和Activity的启动模式和startActivity时所设置的Flag息息相关，Activity栈管理的主要处理逻辑是在ActivityStarter#startActivityUnchecked方法中，本文也会围绕着这个方法进进出出，反复摩擦，直到脑海中都是它的形状。goolge的工程师起名还是很讲究的，为什么要带Unchecked呢? Unchecked-不确定，是因为在执行这个方法时，我要启动哪个Activity还没决定呢，具体为什么，我想看过这篇文章你就明白了。

Activity栈管理相关类

ActivityStackSupervisor

Activity栈的管理人

ActivityDisplay

表示一个屏幕，Android支持三种屏幕，主屏幕，外接屏幕，虚拟屏幕（投屏）【这个介绍是从其他地方看来的，并不确定】。一般在手机上只有主屏幕，此时ActivityStackSupervisor与ActivityDisplay都是系统唯一的

TaskRecord

是ActivityTask的记录，TaskRecord是Activity栈的重要管理单元。形象一点理解，记得启动模式的 singleTask 吧？意思就是让这个Activity在单独的TaskRecord中启动。“Task":任务。

ActivityRecord

记录着每个Activity的信息，ActivityRecord和Activity一一对应。

ActivityStack

是ActivityRecord和TaskRecord两者的统一上司，记录着ActivityRecord和TaskRecord的状态。

如果在只有主屏幕的设备上，他们之间的关系大概是这样子的：

可以理解为一个屏幕上，可能会有很多个APP进程，每个APP进程对应一个ActivityStack，也就是activity栈，其中由于Activity的启动模式不同，又形成了若干个TaskRecord，其中包含着若干个ActivityRecord。

Activity 的四种启动模式，以及启动标识符

Standard

标准启动模式，启动Activity的时候向发起人的Task顶直接添加即可，返回时依次退出。

SingleTop

栈顶唯一，如果栈顶Activity不是要启动的Activity，则会创建一个新的Activity实例，但如果栈顶Activity就是我们要启动的Activity，就只会调用onNewIntent，而不去再重新创建一个实例。相比Standard，Standard不论如何，都会创建一个新的实例。

SingleTask

栈内唯一。如果发起启动的ActivityRecord所在的TaskRecord中，有要启动的Activity对应的ActivityRecord，则首先将TaskRecord中，目标Activity之上的所有ActivityRecord全都弹出，然后将所在TaskRecord变为ActivityStack的栈顶。

如果发起启动的ActivityRecord所在的TaskRecord中，没有要启动的Activity对应的ActivityRecord，则会在栈顶新建一个TaskRecord，并向其中实例化一个需要启动的Activity对应的ActivityRecord。

SingleInstance

独占一个TaskRecord。启动时，在ActivityStack中查找是否有相同的Activity，如果有，则用这个独占TaskRecord的ActivityRecord对应的Activity。否则新建一个TaskRecord，里面只有它存在。由singleInstance发起的启动，不论是谁，都会在另一个task中启动。

代码实现

通过对"android.app.ActivityThread"进行反射。获取android系统的activity栈

遍历activity栈能够得到当前应用中的全部存活的activity。

        Log.e("Baseactivty", this.getClass().getName() +":oncreate");
        Class activityThreadClass = null;
 
        try {
            activityThreadClass = Class.forName("android.app.ActivityThread");
            Object activityThread = activityThreadClass.getMethod("currentActivityThread").invoke(null);
            Field activitiesField = activityThreadClass.getDeclaredField("mActivities");
            activitiesField.setAccessible(true);
            Map activities = (Map) activitiesField.get(activityThread);
            int i = 0;
            for (Object activityRecord : activities.values()) {
                Class activityRecordClass = activityRecord.getClass();
                Field activityField = activityRecordClass.getDeclaredField("activity");
                activityField.setAccessible(true);
                Activity activity = (Activity) activityField.get(activityRecord);
 
                Log.e("activityThreadClass", "index:" + i + ",sum:" + activities.size()+ ", class name:" + activity.getClass().getName());
                i++;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

当你在Activity的oncreate中调用上述方法时。你会发现activity列表activities中没有当前的activity，这是由于当前activity还没有被增加栈中。可是onResume中调用上面的函数。就发现当前activity已经被增加栈中。

2.2 重写Instrumentation

监听activity的声明周期。现实自己想要的操作。

首先"绕庄"操作，即在当前project的src文件夹以下新建anroid.app包，然后声明ActivityThread、Instrumentation、LoadedApk三个文件。

ActivityThread类

package android.app;
 
import android.content.pm.ApplicationInfo;
 
public final class ActivityThread {
 
    /**
     * NOTICE: 必须在UI线程调用本方法,否则返回NULL
     *
     * @return
     */
    public static ActivityThread currentActivityThread() {
        return null;
    }
 
    public final LoadedApk getPackageInfoNoCheck(ApplicationInfo ai) {
        return null;
    }
}

Instrumentation类

package android.app;
 
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.os.IBinder;
import android.view.KeyEvent;
import android.view.MotionEvent;
 
public class Instrumentation {
 
    public void onCreate(Bundle arguments) {
 
    }
 
    public void start() {
 
    }
 
    public void onStart() {
 
    }
 
    public boolean onException(Object obj, Throwable e) {
 
        return false;
    }
 
    public void sendStatus(int resultCode, Bundle results) {
 
    }
 
    public void finish(int resultCode, Bundle results) {
 
    }
 
    public void setAutomaticPerformanceSnapshots() {
 
    }
 
    public void startPerformanceSnapshot() {
 
    }
 
    public void endPerformanceSnapshot() {
 
    }
 
    public void onDestroy() {
 
    }
 
    public Context getContext() {
        return null;
    }
 
    public ComponentName getComponentName() {
        return null;
    }
 
    public Context getTargetContext() {
        return null;
    }
 
    public boolean isProfiling() {
        return false;
    }
 
    public void startProfiling() {
 
    }
 
    public void stopProfiling() {
 
    }
 
    public void setInTouchMode(boolean inTouch) {
 
    }
 
    public void waitForIdle(Runnable recipient) {
 
    }
 
    public void waitForIdleSync() {
 
    }
 
    public void runOnMainSync(Runnable runner) {
 
    }
 
    public Activity startActivitySync(Intent intent) {
 
        return null;
    }
 
    public void addMonitor(ActivityMonitor monitor) {
 
    }
 
    public Instrumentation.ActivityMonitor addMonitor(IntentFilter filter, ActivityResult result, boolean block) {
        return null;
    }
 
    public ActivityMonitor addMonitor(String cls, ActivityResult result, boolean block) {
        return null;
    }
 
    public boolean checkMonitorHit(ActivityMonitor monitor, int minHits) {
        return false;
    }
 
    public Activity waitForMonitor(ActivityMonitor monitor) {
        return null;
    }
 
    public Activity waitForMonitorWithTimeout(ActivityMonitor monitor, long timeOut) {
        return null;
    }
 
    public void removeMonitor(ActivityMonitor monitor) {
 
    }
 
    public boolean invokeMenuActionSync(Activity targetActivity, int requestCode, int flag) {
        return false;
    }
 
    public boolean invokeContextMenuAction(Activity targetActivity, int requestCode, int flag) {
        return false;
    }
 
    public void sendStringSync(String text) {
 
    }
 
    public void sendKeySync(KeyEvent event) {
 
    }
 
    public void sendKeyDownUpSync(int key) {
 
    }
 
    public void sendCharacterSync(int keyCode) {
 
    }
 
    public void sendPointerSync(MotionEvent event) {
 
    }
 
    public void sendTrackballEventSync(MotionEvent event) {
 
    }
 
    public Application newApplication(ClassLoader cl, String className, Context who) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return null;
    }
 
    public void callApplicationOnCreate(Application app) {
 
    }
 
    public Activity newActivity(Class<?> clazz, Context who, IBinder token, Application application, Intent intent, ActivityInfo info, CharSequence title, Activity parent, String id, Object lastNonConfigurationInstance) throws InstantiationException, IllegalAccessException {
        return null;
    }
 
    public Activity newActivity(ClassLoader cl, String className, Intent intent