深入AMS源碼（一）——ActivityManagerService的基礎知識

自從讀過Android內核剖析這本書之後，對整個安卓的系統有了更深的認識和理解，前面寫了3篇文章（深入PMS源碼）分析了PMS的相關代碼，之後會將相關知識都整理在博客上，本篇開始將從源碼角度分析AMS的執行邏輯，AMS作爲Android的核心服務，瞭解其內部流程會讓開發者對程序的執行有更深刻的認識，主要的流程邏輯放在下一篇中分析，這裏先分析下基礎部分便於更好的理解之後的內容；

1、AMS重要數據結構

• Activity棧模型
  

1. 每個活動Activity在AMS中都會創建對應的ActivityRecord對象；
2. 這些ActivityRecord對象被管理在各自的任務棧中，每個TaskStack可以添加多了任務對象；
3. 所有的TaskStack都被ActivityStack統一管理，負責TaskStack的順序、入棧和出棧；

• ActivityRecord：記錄所有Activity的信息，屬性如下：

1. service：ActivityManagerService的引用
2. info：Activity註冊的全部信息
3. appInfo：此活動對應的應用程序信息
4. launchedFromPackage：啓動此Activity程序對應的包名
5. app：所在進程信息ProcessRecord對象
6. launchMode：啓動模式
7. task：此Activity所屬的任務棧，TaskRecord
8. taskAffinity：Activity設置的歸屬棧名稱
9. packageName：包含Activity的包名
10. processName：程序的進程名稱
11. userId：當前活動運行所在的用戶ID
12. ActivityRecord resultTo：此活動需要回複數據的ActivityRecord對象
13. requestCode：請求的狀態碼
14. Bundle icicle：保存Activity的數據
15. state：Activity的當前狀態
16. icon：應用程序圖標Icon
17. logo：應用程序圖標Logo
18. theme：應用程序圖標theme
19. labelRes：應用程序圖標labelRes

• TaskRecord：Activity所屬的任務棧

1. AMS中使用任務棧記錄每個Activity的狀態和啓動順序，使每個Activity都有各自的任務棧，在執行啓動和退出時可以在棧中有序進行；
2. 默認A啓動新的ActivityB，那新的B就加入A所在的任務棧中；

• TaskRecord屬性：

1. taskId：任務棧的Id，唯一標誌
2. affinity：任務棧的傾向性名稱
3. intent：啓動這個棧的Intent意圖
4. userId：此棧所屬的用戶ID
5. mActivities：任務棧中所有的Activity信息
6. mStack：當前的棧所屬的管理類ActivityStack對象
7. mService：保存AMS引用

• ActivityStack：Activity的棧管理類，管理進程中所有的TaskRecord對象

1. mService：AMS引用
2. mWindowManager：WMS引用
3. ArrayList mTaskHistory：所有的活動歷史記錄棧，集合中最頂的棧爲當前棧
4. mLRUActivities：保存最近最少使用的活動
5. mPausingActivity：保存正在暫停的Activity
6. mLastPausedActivity：最近一個已經Paused狀態的活動
7. mResumedActivity：當前正在運行的活動
8. mLastNoHistoryActivity：最近一個NoHistory的活動
9. mStackId：棧管理的id
10. mHandler：ActivityStackHandler對象，執行Handler消息事件

2、AMS的啓動過程

AMS作爲系統的主要服務，也是在Android系統啓動後由系統來啓動，由Android系統啓動過程知道系統啓動服務通過SystemServer完成，在SystemServer中調用startBootstrapServices（）啓動核心服務，AMS也是在此方法中完成啓動

private void startBootstrapServices() {
559        mActivityManagerService = mSystemServiceManager.startService(
560                ActivityManagerService.Lifecycle.class).getService(); //1、使用SystemServiceManager創建AMS對象
561        mActivityManagerService.setSystemServiceManager(mSystemServiceManager); //賦值AMS中mSystemServiceManager
562        mActivityManagerService.setInstaller(installer); //賦值AMS中的installer
}

上面的代碼也是在Android系統啓動過程中出現過的，使用SystemServiceManager.startService()方法，傳入ActivityManagerService.Lifecycle.class啓動服務，由前面的學習知道startService（）方法中會創建Lifecycle對象，並調用onStart（）方法

public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;
    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityManagerService(context); // 1、創建AMS對象
    }
    @Override
    public void onStart() {
        mService.start(); // 2、執行start（）方法
    }
    public ActivityManagerService getService() { // 3、返回AMS對象
        return mService;
    }
}

在Lifecycle的構造函數中直接創建ActivityManagerService對象，然後調用ActivityManagerService.start()方法

• ActivityManagerService構造函數

public ActivityManagerService(Context systemContext) {
mSystemThread = ActivityThread.currentActivityThread(); // 1、獲取ActivityThread實例
mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();

mHandler = new MainHandler(mHandlerThread.getLooper()); // 2、使用HandlerThread初始化一個線程和Handler對象
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart”, // 3、初始化用於進程啓動的ProcStartHandle對象
        THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();

mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
if (sKillHandler == null) {
    sKillThread = new ServiceThread(TAG + ":kill",
            THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
    sKillThread.start();
    sKillHandler = new KillHandler(sKillThread.getLooper()); // 4、初始化用於殺死進程的sKillHandler對象
}

mServices = new ActiveServices(this);
mProviderMap = new ProviderMap(this); // 初始化屬性
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system”); // 創建/system/文件夾
systemDir.mkdirs();
mLifecycleManager = new ClientLifecycleManager();//初始化ClientLifecycleManager對象
mProcessCpuThread = new Thread("CpuTracker") {。。。。。。} // 創建mProcessCpuThread線程
}

在實例化ActivityManagerService對象時，主要執行以下操作：

1. 調用ActivityThread.currentActivityThread()獲取ActivityThread對象，此對象在ActivityThread中創建；
2. 使用HandlerThread初始化工作線程和Handler對象；
3. 初始化用於進程啓動的線程和ProcStartHandle對象；
4. 創建用於殺死進程的sKillHandler對象；
5. 初始化屬性信息和創建文件夾；
6. 創建用於生命週期管理的ClientLifecycleManager對象；
7. 創建mProcessCpuThread線程；

• AMS.start()

private void start() {
    mProcessCpuThread.start(); // 1、
    mBatteryStatsService.publish();
    mAppOpsService.publish(mContext); //
    LocalServices.addService(ActivityManagerInternal.class, new LocalService()); // 2、
    try {
        mProcessCpuInitLatch.await(); //3、
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

在start（）方法中，首先啓動mProcessCpuThread線程，使用LocalServices註冊ActivityManagerInternal類型的LocalService對象，關於LocalServices它功能類似於ServiceManager，在內部使用靜態變量保存註冊的Class和對象的關係，在使用時直接獲取使用，不過它只能在相同線程中使用，最後調用使用CountDownLatch同步線程，等待mProcessCpuThread線程啓動完成；

3、AMS對Activity生命週期的管理

第二個部分主要介紹AMS是如何管理生命週期，如何回調生命週期方法的，在Android內核剖析書中主要針對Android 2.3版本，從其源碼中可以看出，當時的AMS中功能是十分臃腫的，而且對生命週期的回調也是直接調用的，代碼從理解上來說會不較容易，筆者在看完Android 2.3源碼後又學習的Android P的源碼，在Android P中將對生命週期的管理單獨抽取封裝成模塊，本片文章就看下Android P中的源碼，在AndroidP中執行程序的onPause（）方法的過程被封裝成

mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
        PauseActivityItem.obtain(prev.finishing, userLeaving,
                prev.configChangeFlags, pauseImmediately));

使用模版模式，將所有對生命週期的回調都封裝成統一的樣式，通過創建不同的對象達到不同的效果，在介紹上述代碼執行前先介紹下主要的幾個類；

• ActivityLifecycleItem

public abstract class ActivityLifecycleItem extends ClientTransactionItem {
    @IntDef(prefix = { "UNDEFINED", "PRE_", "ON_" }, value = {
            UNDEFINED,
            PRE_ON_CREATE,
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_RESTART
    })
    @Retention(RetentionPolicy.SOURCE)
    public @interface LifecycleState{}  // 定義了生命週期狀態的註解
    
    public static final int UNDEFINED = -1;
    public static final int PRE_ON_CREATE = 0;
    public static final int ON_CREATE = 1;
    public static final int ON_START = 2;
    public static final int ON_RESUME = 3;
    public static final int ON_PAUSE = 4;
    public static final int ON_STOP = 5;
    public static final int ON_DESTROY = 6;
    public static final int ON_RESTART = 7;
    @LifecycleState
    public abstract int getTargetState(); // 返回相應的狀態
    @Override
    public void recycle() { // 生命空的recycle（）方法
    }
}

在Android系統中將每個生命週期都抽象成單獨的Item，然後創建抽象的ActivityLifecycleItem類，在其中聲明方法週期註解、抽象方法和對應的常量，另外ActivityLifecycleItem繼承了ClientTransactionItem類，如果說ActivityLifecycleItem類是統一所有生命週期Item的Base類，那ClientTransactionItem就是定義瞭如何使用每個Item 的框架類；

• ClientTransactionItem

public class ClientTransaction implements Parcelable, ObjectPoolItem {
    private List<ClientTransactionItem> mActivityCallbacks;
    private ActivityLifecycleItem mLifecycleStateRequest; // 要執行的lifecycle
    private IApplicationThread mClient; // 發起請求的Client
    private IBinder mActivityToken; 
// 1、獲取ClientTransaction對象
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
        ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
        if (instance == null) {
            instance = new ClientTransaction();
        }
        instance.mClient = client;
        instance.mActivityToken = activityToken;
        return instance;
    }
public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
        mLifecycleStateRequest = stateRequest; // 2、設置執行生命週期對應的 Item
    }
// 3、執行ClientTransaction對象的方法
public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this); // 
}
}

 @Override
    public void recycle() { //4、
        if (mActivityCallbacks != null) {
            int size = mActivityCallbacks.size();
            for (int i = 0; i < size; i++) {
                mActivityCallbacks.get(i).recycle();
            }
            mActivityCallbacks.clear();
        }
        if (mLifecycleStateRequest != null) {
            mLifecycleStateRequest.recycle();
            mLifecycleStateRequest = null;
        }
        mClient = null;
        mActivityToken = null;
        ObjectPool.recycle(this);
    }

上述代碼爲ClientTransaction中主要的功能部分：

1. 獲取ClientTransaction對象，ClientTransaction內部使用對象緩存池ObjectPool緩存對象，同時保存mClient對象；
2. 使用setLifecycleStateRequest（）設置內部要執行的生命週期的Item對象，這裏類似於Okhttp中的Reuqest；
3. 在schedule（）方法中調用mClient.scheduleTransaction()中方法並傳入this對象，執行具體的任務；
4. 在recycle（）方法中清除當前對象的所有狀態和信息，然後緩存ClientTransaction對象；

上面的執行過程中除了創建對象、設置請求Request、回收對象真正執行任務是在Client中，這裏的Client是ApplicaitonThread對象中方法

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this); // 1、執行preExecute（）
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); //2、發送事件執行transaction，在ActivityThread中
}

在scheduleTransaction（）方法中首先調用transaction.preExecute()方法，preExecute會回調每個Item.preExecute（）,主要做執行前的準備工作，然後調用sendMessage（）發送時間消息，處理事件是在ActivityThread中

case EXECUTE_TRANSACTION:
    final ClientTransaction transaction = (ClientTransaction) msg.obj;
    mTransactionExecutor.execute(transaction) ; // 調用TransactionExecutor執行transaction對象
    if (isSystem()) {
        transaction.recycle(); // 釋放、回收資源
    }
    break;

在獲取到消息事件中的ClientTransaction對象後，調用TransactionExecutor中方法執行transaction對象，在execute（）方法中會調用executeLifecycleState（）

private void executeLifecycleState(ClientTransaction transaction) {
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); // 1、獲取傳入的LifecycleItem
  
    final IBinder token = transaction.getActivityToken();
    final ActivityClientRecord r = mTransactionHandler.getActivityClient(token); // 2、獲取要執行的ActivityRecord
    if (r == null) {
        return;
    }
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions); // 3、執行LifecycleItem的execute（） 
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions); // 4、執行postExecute（）回調通知執行結果
}

在executeLifecycleState（）中首先獲取要執行的Request，其實獲取的就是要執行的生命週期的Item，然後執行Item的execute（）和postExecute（）方法，execute主要執行任務而postExecute在執行任務結束後回到結果，下面以Activity的onPause爲例

• PauseActivityItem

public class PauseActivityItem extends ActivityLifecycleItem { // 
    private boolean mFinished;
    private boolean mUserLeaving;
    private int mConfigChanges;
    private boolean mDontReport;
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                "PAUSE_ACTIVITY_ITEM”); // 1、
    }
    @Override
    public int getTargetState() {
        return ON_PAUSE;
    }
    @Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        if (mDontReport) {
            return;
        }
        try {
            ActivityManager.getService().activityPaused(token); // 2
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }

    private PauseActivityItem() {}
    public static PauseActivityItem obtain(boolean finished, boolean userLeaving, int configChanges,
            boolean dontReport) {
        PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);//使用對象池複用對象
        if (instance == null) {
            instance = new PauseActivityItem();
        }
        instance.mFinished = finished;
        instance.mUserLeaving = userLeaving;
        instance.mConfigChanges = configChanges;
        instance.mDontReport = dontReport;
        return instance;
    }
@Override
public void recycle() {
    super.recycle();
    mFinished = false;
    mUserLeaving = false;
    mConfigChanges = 0;
    mDontReport = false;
    ObjectPool.recycle(this); // 回收對象
}
}

在PauseItem中主要執行以下邏輯：
1、生命週期回調框架會調用其execute（），在execute（）中調用I ApplicationThread.handlePauseActivity()方法，處理方法暫停
2、在執行完Activity的pause之後會調用postExecute（），在postExecute中回調通知AMS.activityPaused()，通知AMS方法暫停完成；

mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
        PauseActivityItem.obtain(prev.finishing, userLeaving,
                prev.configChangeFlags, pauseImmediately));

現在來解釋下開始時給出的代碼，使用的執行架構就是上面分析的內容，那getLifecycleManager()獲取的是什麼呢？獲取的其實是ClientLifecycleManager對象，就是AMS在構造函數中初始化的，ClientLifecycleManager的作用封裝了ClientTransaction
對象的創建、設置請求Request、schedule（）執行、recycle（）回收部分；

• ClientLifecycleManager

class ClientLifecycleManager {

// 使用此方法可以實現回調生命週期中的方法
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
        @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
    scheduleTransaction(clientTransaction);
}

//根據請求的參數，封裝ClientTransaction對象
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
        @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
    final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
    clientTransaction.setLifecycleStateRequest(stateRequest);
    return clientTransaction;
}

// 執行具體的ClientTransaction對象
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule(); // 調用schedule（）
    if (!(client instanceof Binder)) {
        transaction.recycle();//調用recycle（）
    }
}
}

在調用scheduleTransaction（）傳入參數後，首先調用transactionWithState（）使用參數創建ClientTransaction對象，然後調用scheduleTransaction（），在scheduleTransaction中觸發schedule的執行，然後系統就會執行相應的Item，在執行結束後調用recycle（）回收對象；

上面就是AMS中數據結構和兩個基礎模塊的分析，下一篇文章將帶着這些基礎去分析AMS如何管理和調度Activity的。