1.前言

• 最近一直在看 《Android進(jìn)階解密》 的一本書(shū)，這本書(shū)編寫(xiě)邏輯、流程都非常好，而且很容易看懂，非常推薦大家去看看（沒(méi)有收廣告費(fèi)，單純覺(jué)得作者寫(xiě)的很好）。
• 上一篇簡(jiǎn)單的介紹了Android進(jìn)階（三）：Application啟動(dòng)過(guò)程(最詳細(xì)&最簡(jiǎn)單)。
• 今天就介紹Application啟動(dòng)之后，是如何啟動(dòng)應(yīng)用程序中的 第一個(gè)Activity （基于Android 8.0 系統(tǒng)）。
• 文章中實(shí)例 linhaojian的Github

2.Activity啟動(dòng)過(guò)程的時(shí)序圖

Activity啟動(dòng)流程.png

3.源碼分析

3.1 ActivityManagerService：

private final boolean attachApplicationLocked(IApplicationThread thread,
      int pid, int callingUid, long startSeq) {
    //...
    //通知ActivityThread啟動(dòng)application
    thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
                    null, null, null, testMode,
                    mBinderTransactionTrackingEnabled, enableTrackAllocation,
                    isRestrictedBackupMode || !normalMode, app.persistent,
                    new Configuration(getGlobalConfiguration()), app.compat,
                    getCommonServicesLocked(app.isolated),
                    mCoreSettingsObserver.getCoreSettingsLocked(),
                    buildSerial, isAutofillCompatEnabled);// 1
     // 啟動(dòng)第一個(gè)Activity
    if (normalMode) {
        try {
            //Application初始化之后，初始化&啟動(dòng)第一個(gè)Activity
            if (mStackSupervisor.attachApplicationLocked(app)) {// 2
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }     
}

• 注釋1：通知ActivityThread啟動(dòng)application；
• 注釋2：調(diào)用ActivityStackSupervisor，啟動(dòng)第一個(gè)Activity；

3.2 ActivityStackSupervisor 啟動(dòng)Activity：

    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
        //獲取應(yīng)用的進(jìn)行名稱(chēng)
        final String processName = app.processName;
        boolean didSomething = false;
        for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
            final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
            for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
                final ActivityStack stack = display.getChildAt(stackNdx);
                if (!isFocusedStack(stack)) {
                    continue;
                }
                stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
                final ActivityRecord top = stack.topRunningActivityLocked();
                final int size = mTmpActivityList.size();
                for (int i = 0; i < size; i++) {
                    final ActivityRecord activity = mTmpActivityList.get(i);
                    if (activity.app == null && app.uid == activity.info.applicationInfo.uid
                            && processName.equals(activity.processName)) {
                        try {
                            // Application初始化之后，啟動(dòng)第一個(gè)Activity
                            if (realStartActivityLocked(activity, app,
                                    top == activity /* andResume */, true /* checkConfig */)) { // 1
                                didSomething = true;
                            }
                        } catch (RemoteException e) {
                            Slog.w(TAG, "Exception in new application when starting activity "
                                    + top.intent.getComponent().flattenToShortString(), e);
                            throw e;
                        }
                    }
                }
            }
        }
        if (!didSomething) {
            ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
        }
        return didSomething;
    }

• 注釋1：調(diào)用自身的realStartActivityLocked()，真正的啟動(dòng)Activity；

    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
                //...
                // Create activity launch transaction.
                //通知ActivityThread創(chuàng)建activity的實(shí)例 ；調(diào)用Activity的OnCreate； 創(chuàng)建對(duì)應(yīng)PhoneWindow實(shí)例
                final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                        r.appToken);
                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        System.identityHashCode(r), r.info,
                        // TODO: Have this take the merged configuration instead of separate global
                        // and override configs.
                        mergedConfiguration.getGlobalConfiguration(),
                        mergedConfiguration.getOverrideConfiguration(), r.compat,
                        r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                        r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                        profilerInfo)); // 2
                // Set desired final state.
                final ActivityLifecycleItem lifecycleItem;
                if (andResume) {
                    lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward()); // 3
                } else {
                    lifecycleItem = PauseActivityItem.obtain(); // 4
                }
                clientTransaction.setLifecycleStateRequest(lifecycleItem);
                // 編制啟動(dòng)Activity實(shí)例的事務(wù)，并按順序調(diào)用onCreate();onStart();onResume();
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);// 5
    }

• 注釋2：封裝啟動(dòng)Activity的相關(guān)數(shù)據(jù)與Activity的啟動(dòng)流程（LaunchActivityItem 下面會(huì)介紹該類(lèi)）；
• 注釋3：封裝Activity啟動(dòng)之后生命周期變化為Resume的流程（ResumeActivityItem下面會(huì)介紹該類(lèi)）；
• 注釋4：封裝Activity啟動(dòng)之后生命周期變化為Pause的流程；
• 注釋5：真正開(kāi)始啟動(dòng)Activity與調(diào)用相關(guān)的生命周期方法；

3.3 ClientLifecycleManager管理ClientTransaction：

    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();// 1
        transaction.schedule();// 2
        if (!(client instanceof Binder)) {
            // If client is not an instance of Binder - it's a remote call and at this point it is
            // safe to recycle the object. All objects used for local calls will be recycled after
            // the transaction is executed on client in ActivityThread.
            transaction.recycle();
        }
    }

• 注釋1：獲取需要啟動(dòng)Activity進(jìn)程的代理對(duì)象IApplicationThread；
• 注釋2：調(diào)用ClientTransaction中的schedule()；

3.4 ClientTransaction中schedule函數(shù)：

    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);// 1
    }

• 注釋1：mClient就是與ActivityThread通訊的代理對(duì)象(IApplicationThread)，所以這里其實(shí)是調(diào)用ActivityThread類(lèi)中ApplicationThread內(nèi)部類(lèi)的scheduleTransaction()；

3.5 ApplicationThread的scheduleTransaction函數(shù)：

    private class ApplicationThread extends IApplicationThread.Stub {
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);// 1
        }    
    }

• 注釋1：這里其實(shí)最后還是調(diào)用了ActivityThread的scheduleTransaction()，而這個(gè)scheduleTransaction()其實(shí)真正的實(shí)現(xiàn)是ClientTransactionHandler，因?yàn)锳ctivityThread是繼承ClientTransactionHandler類(lèi)的；

public abstract class ClientTransactionHandler {
    /** Prepare and schedule transaction for execution. */
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);// 2
    }
}

• 注釋2：調(diào)用ActivityThread的sendMessage()，將ClientTransaction參數(shù)通過(guò)Handler機(jī)制切換至主線程進(jìn)行處理；

3.6 ActivityThread的H類(lèi)：

    class H extends Handler {
        //...
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EXECUTE_TRANSACTION: // 1
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;// 2
                    mTransactionExecutor.execute(transaction);// 3
                    if (isSystem()) {
                        // Client transactions inside system process are recycled on the client side
                        // instead of ClientLifecycleManager to avoid being cleared before this
                        // message is handled.
                        transaction.recycle();
                    }
                    // TODO(lifecycler): Recycle locally scheduled transactions.
                    break;              
            }        
        }
    }

• 注釋1：接收ClientTransactionHandler發(fā)送的EXECUTE_TRANSACTION事件；
• 注釋2：接收ClientTransactionHandler發(fā)送的ClientTransaction參數(shù)；
• 注釋3：通過(guò)TransactionExecutor真正處理ClientTransaction中封裝的Activity相關(guān)信息；

3.7 TransactionExecutor處理ClientTransaction：

    public void execute(ClientTransaction transaction) {
        final IBinder token = transaction.getActivityToken();
        log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
        executeCallbacks(transaction);
        executeLifecycleState(transaction);
        mPendingActions.clear();
        log("End resolving transaction");
    }

3.8 executeCallbacks()啟動(dòng)Activity：

    @VisibleForTesting
    public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        if (callbacks == null) {
            // No callbacks to execute, return early.
            return;
        }
        log("Resolving callbacks");
        final IBinder token = transaction.getActivityToken();
        ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        // In case when post-execution state of the last callback matches the final state requested
        // for the activity in this transaction, we won't do the last transition here and do it when
        // moving to final state instead (because it may contain additional parameters from server).
        final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
        final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
                : UNDEFINED;
        // Index of the last callback that requests some post-execution state.
        final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
        final int size = callbacks.size();
        for (int i = 0; i < size; ++i) {
            final ClientTransactionItem item = callbacks.get(i);// 1
            log("Resolving callback: " + item);
            final int postExecutionState = item.getPostExecutionState();
            final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                    item.getPostExecutionState());
            if (closestPreExecutionState != UNDEFINED) {
                cycleToPath(r, closestPreExecutionState);
            }
            item.execute(mTransactionHandler, token, mPendingActions);// 2
            item.postExecute(mTransactionHandler, token, mPendingActions);
            if (r == null) {
                // Launch activity request will create an activity record.
                r = mTransactionHandler.getActivityClient(token);
            }
            if (postExecutionState != UNDEFINED && r != null) {
                // Skip the very last transition and perform it by explicit state request instead.
                final boolean shouldExcludeLastTransition =
                        i == lastCallbackRequestingState && finalState == postExecutionState;
                cycleToPath(r, postExecutionState, shouldExcludeLastTransition);
            }
        }
    }

• 注釋1：獲取ClientTransaction中的ClientTransactionItem對(duì)象（其實(shí)這里的對(duì)象就上面3.2介紹中的LaunchActivityItem）；
• 注釋2：調(diào)用LaunchActivityItem類(lèi)的execute()，下面我們看看LaunchActivityItem；

public class LaunchActivityItem extends ClientTransactionItem {
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,// 1
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
                mPendingResults, mPendingNewIntents, mIsForward,
                mProfilerInfo, client);
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);// 2
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }
}

• 注釋1：剛剛說(shuō)了ClientTransactionHandler是被ActivityThread繼承，所以這里傳入進(jìn)來(lái)就是ActivityThread;
• 注釋2：看到了吧，經(jīng)過(guò)多次不同層次相互調(diào)用，最終真正調(diào)用ActivityThread的handleLaunchActivity()，啟動(dòng)應(yīng)用的第一個(gè)Activity;

3.8 executeLifecycleState()改變Activity的生命周期：

    private void executeLifecycleState(ClientTransaction transaction) {
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();// 1
        if (lifecycleItem == null) {
            // No lifecycle request, return early.
            return;
        }
        log("Resolving lifecycle state: " + lifecycleItem);
        final IBinder token = transaction.getActivityToken();
        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        if (r == null) {
            // Ignore requests for non-existent client records for now.
            return;
        }
        // Cycle to the state right before the final requested state.
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
        // Execute the final transition with proper parameters.
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions); // 2
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }

• 注釋1：獲取ClientTransaction中的ActivityLifecycleItem 對(duì)象（其實(shí)這里的對(duì)象就上面3.2介紹中的ResumeActivityItem）；
• 注釋2：調(diào)用ResumeActivityItem的execute()，下面我們看看ResumeActivityItem；

public class ResumeActivityItem extends ActivityLifecycleItem {
    //...
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
        client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward, // 1
                "RESUME_ACTIVITY");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }
}

• 注釋1：其實(shí)就是調(diào)用Activity的handleResumeActivity()，最終就會(huì)調(diào)用Activity的onStart()與onResume()；

4.類(lèi)關(guān)系

Activity啟動(dòng)類(lèi)結(jié)構(gòu).png

• 通過(guò)上圖發(fā)現(xiàn)，Activity啟動(dòng)過(guò)程就是AMS與ActivityThread不同的進(jìn)程交互實(shí)現(xiàn)的。

5.總結(jié)

• 到此，Activity啟動(dòng)過(guò)程介紹完畢。
• 如果喜歡我的分享，可以點(diǎn)擊 關(guān)注 或者 贊，你們支持是我分享的最大動(dòng)力 。
• linhaojian的Github

歡迎關(guān)注linhaojian_CSDN博客或者linhaojian_簡(jiǎn)書(shū)！

不定期分享關(guān)于安卓開(kāi)發(fā)的干貨。

寫(xiě)技術(shù)文章初心

• 技術(shù)知識(shí)積累
• 技術(shù)知識(shí)鞏固
• 技術(shù)知識(shí)分享
• 技術(shù)知識(shí)交流