開局一張圖

涉及到的類

1、Activity.java

1.1 startActivity()

1.2 startActivityForResult()

2、Instrumentation.java

2.1 execStartActivity()

3、ActivityTaskManage.java

3.1 getService()

3.2 IActivityTaskManagerSingleton

4、ActivityTaskManagerService.java

4.1 startActivity()

4.2 startActivityAsUser()

4.3 startActivityAsUser() 比上面多個引數

4.4 getActivityStartController()

5、ActivityStartController.java

5.1 obtainStarter();

6、ActivityStarter.java

6.1 execute()

6.2 executeRequest()

6.3 startActivityUnchecked()

6.4 startActivityInner()

7、RootWindowContainer.java

7.1 resumeFocusedTasksTopActivities()

8、Task.java

8.1 resumeTopActivityUncheckedLocked()

8.2 resumeTopActivityInnerLocked()

9、ActivityTaskSupervisor.class

9.1 startSpecificActivity()

9.2 行程已啟動

9.2.1 realStartActivityLocked()

9.2.2 ClientLifecycleManager.scheduleTransaction()

9.2.3 ClientTransaction.schedule()

9.2.4 ApplicationThread.scheduleTransaction()

9.2.5 ClientTransactionHandler.scheduleTransaction()

9.2.6 ActivityThread.H.handleMessage()

9.2.7 TransactionExecutor.execute()

9.2.8 TransactionExecutor.executeCallbacks()

9.2.9 TransactionExecutor.cycleToPath()

9.2.10 TransactionExecutor.performLifecycleSequence()

9.2.11 ClientTransactionHandler.handleLaunchActivity()

9.2.12 ActivityThread.handleLaunchActivity()

9.2.13 ActivityThread.performLaunchActivity()

9.2.14 Instrumentation.newActivity()

9.2.15 Instrumentation.callActivityOnCreate()

9.3 行程未啟動

9.3.1 ATMS.startProcessAsync()

9.3.2 ActivityManagerInternal.startProcess()

9.3.3 ActivityManagerService.LocalService.startProcess()

9.3.4 ActivityManagerService.startProcessLocked()

9.3.5 ProcessList.startProcessLocked()

9.3.6 ProcessList.startProcess()

9.3.7 Process.start()

9.3.8 ZygoteProcess.start()

9.3.9 ZygoteProcess.startViaZygote()

9.3.10 ZygoteProcess.openZygoteSocketIfNeeded(abi)

9.4.11 ZygoteProcess.zygoteSendArgsAndGetResult()

9.4.12 ZygoteProcess.attemptZygoteSendArgsAndGetResult()

9.4.13 ZygoteInit.main()

9.4.14 ZygoteService.runSelectLoop()

9.4.15 ZygoteConnection.processOneCommand()

9.4.15 ActivityThread.main()

開局一張圖

原始碼版本：Android 11(SDK 30)

涉及到的類

Instrumentation：負責 Application 和 Activity 的建立和生命周期控制，
ActivityTaskManager：此類提供有關Activity及其容器（如任務、堆疊和顯示）的資訊并與之互動，
ActivityTaskManagerService：用于管理Activity及其容器（任務、顯示等）的系統服務，之前這個活是AMS的，現在從AMS中剝離出來了，
ActivityStartController：用于委托Activity啟動的控制器，
ActivityStarter：專門負責一個 Activity 的啟動操做，它的主要做用包括決議 Intent、建立 ActivityRecord、若是有可能還要建立 TaskRecordflex
ActivityStack：Activity在ATMS的堆疊管理，用來記錄已經啟動的Activity的先后關系，狀態資訊等，通過ActivityStack決定是否需要啟動新的行程，
RootWindowContainer：設備的Root WindowContainer，
TaskRecord：ATMS抽象出來的一個"任務"的概念，是記錄ActivityRecord的堆疊，一個"Task"包含若干個ActivityRecord，ATMS用TaskRecord確保Activity啟動和退出的順序，
ActivityStackSupervisor：負責所有Activity堆疊的管理，內部管理了mHomeStack、mFocusedStack和mLastFocusedStack三個Activity堆疊，其中，mHomeStack管理的是Launcher相關的Activity堆疊；mFocusedStack管理的是當前顯示在前臺Activity的Activity堆疊；mLastFocusedStack管理的是上一次顯示在前臺Activity的Activity堆疊，
ActivitySupervisor：管理 activity 任務堆疊，
ActivityThread：ActivityThread 運行在UI執行緒（主執行緒），App的真正入口，
ApplicationThread：用來實作ATMS和ActivityThread之間的互動，
ApplicationThreadProxy：ApplicationThread 在服務端的代理，ATMS就是通過該代理與ActivityThread進行通信的，
ClientLifecycleManager：能夠組合多個客戶端生命周期 transaction 請求和/或回呼，并將它們作為單個 transaction 執行，
TransactionExecutor：已正確的順序管理 transaction 執行的類，

1、Activity.java

1.1 startActivity()

@Override
public void startActivity(Intent intent) {
    //接著往里看
    this.startActivity(intent, null);
}

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    ...
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

最終呼叫了 startActivityForResult 方法，傳入的 -1 表示不需要獲取 startActivity 的結果，

1.2 startActivityForResult()

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
    @Nullable Bundle options) {
    //mParent表示當前Activitiy的父類，
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        //ActivityThread mMainThread;
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        ...
    } else {
        ...
    }
}

startActivityForResult 呼叫 Instrumentation.execStartActivity 方法，剩下的交給 Instrumentation 類去處理，

mMainThread 是 ActivityThread 型別，ActivityThread 可以理解為一個行程，這就是 Activity 所在的行程，

通過 mMainThread 獲取一個 ApplicationThread 的參考，這個參考就是用來實作行程間通信的，具體來說就是 AMS 所在系統行程通知應用程式行程進行的一系列操作，

上面有Instrumentation、ActivityThread、ApplicationThread 等類的介紹，

2、Instrumentation.java

frameworks/base/core/java/android/app/Instrumentation.java

/**
 * Base class for implementing application instrumentation code.
 */
public class Instrumentation {
    ...
}

2.1 execStartActivity()

 public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        ...
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            //檢查啟動Activity的結果
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

在 Instrumentation 中，呼叫了 ActivityTaskManager.getService().startActivity() ，咱們近距離觀望一下，

3、ActivityTaskManage.java

frameworks/base/core/java/android/app/ActivityTaskManager.java

@TestApi
@SystemService(Context.ACTIVITY_TASK_SERVICE)
public class ActivityTaskManager {
    ...
}

3.1 getService()

    /** @hide */
    public static IActivityTaskManager getService() {
        return IActivityTaskManagerSingleton.get();
    }

3.2 IActivityTaskManagerSingleton

    @UnsupportedAppUsage(trackingBug = 129726065)
    private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
            new Singleton<IActivityTaskManager>() {
                @Override
                protected IActivityTaskManager create() {
                    //代理物件（動態代理）
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                    return IActivityTaskManager.Stub.asInterface(b);
                }
            };

這里實際上回傳的是一個 ActivityTaskManagerService 這出現了跨行程 (從應用行程(app) > system_service行程) ，然后呼叫其 startActivity 方法，

實際上這里就是通過 AIDL 來呼叫 ATMS 的 startActivity 方法，回傳 IActivityTaskManager.startActivity 的結果：Activity 已正常成功啟動，

至此，startActivity 的作業重心成功地從 應用行程(app) 轉移到了系統行程(system_service) 的 ATMS 中，

4、ActivityTaskManagerService.java

frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    ...
}

4.1 startActivity()

@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
        Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

4.2 startActivityAsUser()

@Override
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
        String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
        Bundle bOptions, int userId) {
    return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
            true /*validateIncomingUser*/);
}

4.3 startActivityAsUser() 比上面多個引數

//重點來了
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
        @Nullable String callingFeatureId, Intent intent, String resolvedType,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
    assertPackageMatchesCallingUid(callingPackage);
    enforceNotIsolatedCaller("startActivityAsUser");

    userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

    // 在此處切換到用戶app堆疊，
    return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setCallingFeatureId(callingFeatureId)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setUserId(userId)
            .execute();

    }

4.4 getActivityStartController()

    ActivityStartController getActivityStartController() {
        return mActivityStartController;
    }

5、ActivityStartController.java

/**
 * Controller for delegating activity launches.
 */
public class ActivityStartController {
    ...
}

5.1 obtainStarter();

    /**
     * @return A starter to configure and execute starting an activity. It is valid until after
     *         {@link ActivityStarter#execute} is invoked. At that point, the starter should be
     *         considered invalid and no longer modified or used.
     */
    ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }

6、ActivityStarter.java

frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java

/**
 * Controller for interpreting how and then launching an activity.
 *
 * This class collects all the logic for determining how an intent and flags should be turned into
 * an activity and associated task and stack.
 */
class ActivityStarter {
    ...
}

6.1 execute()

    /**
     * 根據前面提供的請求引數決議必要的資訊，執行開始活動的請求，
     * @return The starter result.
     */
    int execute() {
        ...
                res = executeRequest(mRequest);
        ...
    }

6.2 executeRequest()

    /**
     * Activity啟動之前需要做那些準備？
     * 通常的Activity啟動流程將通過 startActivityUnchecked 到 startActivityInner，
     */
    private int executeRequest(Request request) {
        ...
        //Activity的記錄
        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        ...
        //Activity stack(堆疊)管理
        mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
                restrictedBgActivity, intentGrants);

        ...
        return mLastStartActivityResult;
    }

從上面代碼可以看出，經過多個方法的呼叫，最終通過 obtainStarter 方法獲取了 ActivityStarter 型別的物件，然后呼叫其 execute() 方法，

在 execute() 方法中，會再次呼叫其內部的 executeRequest() 方法，

咱們接著看看 startActivityUnchecked() ;

6.3 startActivityUnchecked()

    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                int startFlags, boolean doResume, ActivityOptions options, Task inTask,
                boolean restrictedBgActivity, NeededUriGrants intentGrants) {
        ....
        try {
            ...
            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
        } finally {
            ...
        }

        postStartActivityProcessing(r, result, startedActivityRootTask);

        return result;
    }

6.4 startActivityInner()

    int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, Task inTask,
            boolean restrictedBgActivity, NeededUriGrants intentGrants) {
        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                voiceInteractor, restrictedBgActivity);

        //計算啟動模式
        computeLaunchingTaskFlags();
        computeSourceRootTask();
        //設定啟動模式
        mIntent.setFlags(mLaunchFlags);
        ...

        // 關鍵點來了
        mRootWindowContainer.resumeFocusedTasksTopActivities(
                        mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
        ...

        return START_SUCCESS;
    }

這個是 mRootWindowContainer 是 RootWindowContainer，

7、RootWindowContainer.java

frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java

/** Root {@link WindowContainer} for the device. */
class RootWindowContainer extends WindowContainer<DisplayContent>
        implements DisplayManager.DisplayListener {
        ...
        }

7.1 resumeFocusedTasksTopActivities()

    boolean resumeFocusedTasksTopActivities(
            Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
            boolean deferPause) {
        ...
        boolean result = false;
        if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
                || getTopDisplayFocusedRootTask() == targetRootTask)) {
            result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                    deferPause);
        }

        ...
        return result;
    }

當然這里看的是 targetRootTask 是 Task 物件的實體，咱們就去追蹤這個方法，

8、Task.java

frameworks/base/services/core/java/com/android/server/wm/Task.java

class Task extends WindowContainer<WindowContainer> {
      ...
}

8.1 resumeTopActivityUncheckedLocked()

    @GuardedBy("mService")
    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
            boolean deferPause) {
        ...
        someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
        ...
        return someActivityResumed;
    }

8.2 resumeTopActivityInnerLocked()

    @GuardedBy("mService")
    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
            boolean deferPause) {
        ...
            try {
                ....
            } catch (Exception e) {
                ....
                //重點
                mTaskSupervisor.startSpecificActivity(next, true, false);
                return true;
            }
        ....
        return true;
    }

mTaskSupervisor：是 ActivityTaskSupervisor 物件的實體，下面咱們看看其 startSpecificActivity() 方法，

9、ActivityTaskSupervisor.class

frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java

public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
      ...
}

9.1 startSpecificActivity()

    void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
        // 此 Activity 的 應用程式(行程) 是否已在運行？
        final WindowProcessController wpc =
                mService.getProcessController(r.processName, r.info.applicationInfo.uid);

        boolean knownToBeDead = false;
        if (wpc != null && wpc.hasThread()) {
            try {
                //行程已啟動
                //注釋1：開始啟動activity
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                
            }
        }

        r.notifyUnknownVisibilityLaunchedForKeyguardTransition();

        final boolean isTop = andResume && r.isTopRunningActivity();
        //注釋2：行程未啟動
        mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
    }

注釋1：行程已啟動，

注釋2：行程未啟動，

9.2 行程已啟動

9.2.1 realStartActivityLocked()

    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {

        ...
                //創建 Activity 啟動的 transaction
                final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.appToken);

                final boolean isTransitionForward = r.isTransitionForward();
                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        System.identityHashCode(r), r.info,
                        mergedConfiguration.getGlobalConfiguration(),
                        mergedConfiguration.getOverrideConfiguration(), r.compat,
                        r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
                        r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
                        r.takeOptions(), isTransitionForward,
                        proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
                        r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
                        r.getLaunchedFromBubble()));

                // Set desired final state.
                final ActivityLifecycleItem lifecycleItem;
                if (andResume) {
                    lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
                } else {
                    lifecycleItem = PauseActivityItem.obtain();
                }
                clientTransaction.setLifecycleStateRequest(lifecycleItem);

                // Schedule transaction.
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);
         
        ...
        return true;
    }

這的 mService 就是 ActivityTaskManagerService(ATMS) 的實體，mService.getLifecycleManager() 回傳的是一個 ClientLifecycleManager 物件，想看 scheduleTransaction() 是干嘛的只能找它了，

9.2.2 ClientLifecycleManager.scheduleTransaction()

frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java

    //這里咱們傳入的是一個啟動 Activity 的 transaction
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        //注釋1
        transaction.schedule();
        if (!(client instanceof Binder)) {
            // 如果 client 不是Binder的實體，則它是一個遠程呼叫，此時可以安全地回收該物件，
            // 在ActivityThread中的客戶端上執行transaction后，將回收用于本地呼叫的所有物件，
            transaction.recycle();
        }
    }

從方法中看出 transaction 是個 ClientTransaction ，那咱直接去找他，

9.2.3 ClientTransaction.schedule()

    /** Target client. */
    private IApplicationThread mClient;
    
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

看到 IApplicationThread ，咱們直接去找 ApplicationThread ，

9.2.4 ApplicationThread.scheduleTransaction()

frameworks/base/core/java/android/app/ActivityThread.java

ApplicationThread 屬于 ActivityThread 的內部類，

public final class ActivityThread extends ClientTransactionHandler
        implements ActivityThreadInternal {
    ...
    private class ApplicationThread extends IApplicationThread.Stub {
        ...
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
        ...
    }
    ...
}

ActivityThread 類中是沒有 scheduleTransaction 方法的，通常遇到這種狀況，直接找其父類 ClientTransactionHandler，

9.2.5 ClientTransactionHandler.scheduleTransaction()

frameworks/base/core/java/android/app/ClientTransactionHandler.java

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

從這里看到他呼叫 sendMessage() 方法發送了個 ActivityThread.H.EXECUTE_TRANSACTION 訊息，咱們回到其子類 ActivityThread 中查看，

9.2.6 ActivityThread.H.handleMessage()

這里的 H 是 ActivityThread 的內部類，

    // An executor that performs multi-step transactions.
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
    class H extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                        ...
                        case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    mTransactionExecutor.execute(transaction);
                    if (isSystem()) {
                        transaction.recycle();
                    }
                    break;
                    ...
            }
        }
    }

這里的 mTransactionExecutor 是 transactions 的執行者，

9.2.7 TransactionExecutor.execute()

frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java

    public void execute(ClientTransaction transaction) {
        ...
        executeCallbacks(transaction);
        ...
    }

9.2.8 TransactionExecutor.executeCallbacks()

    /** Cycle through all states requested by callbacks and execute them at proper times. */
    @VisibleForTesting
    public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        ...
        final IBinder token = transaction.getActivityToken();
        ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        ...
        final int size = callbacks.size();
        for (int i = 0; i < size; ++i) {
            ...
            if (postExecutionState != UNDEFINED && r != null) {
                // 重點
                final boolean shouldExcludeLastTransition =
                        i == lastCallbackRequestingState && finalState == postExecutionState;
                cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
            }
        }
    }

這個方法的重點是 cycleToPath() ，咱們繼續，

9.2.9 TransactionExecutor.cycleToPath()

    private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
        final int start = r.getLifecycleState();
        //IntArray：實作不斷增長的int基元陣列，
        //獲取此次要執行生命周期的路徑path
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
        performLifecycleSequence(r, path, transaction);
    }

9.2.10 TransactionExecutor.performLifecycleSequence()

    /** Transition the client through previously initialized state sequence. */
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            
            switch (state) {
                case ON_CREATE:
                    mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                            null /* customIntent */);
                    break;
                case ON_START:
                    mTransactionHandler.handleStartActivity(r, mPendingActions,
                            null /* activityOptions */);
                    break;
                case ON_RESUME:
                    mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                    break;
                case ON_PAUSE:
                    mTransactionHandler.handlePauseActivity(r, false /* finished */,
                            false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                            "LIFECYCLER_PAUSE_ACTIVITY");
                    break;
                case ON_STOP:
                    mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
                            mPendingActions, false /* finalStateRequest */,
                            "LIFECYCLER_STOP_ACTIVITY");
                    break;
                case ON_DESTROY:
                    mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
                            0 /* configChanges */, false /* getNonConfigInstance */,
                            "performLifecycleSequence. cycling to:" + path.get(size - 1));
                    break;
                case ON_RESTART:
                    mTransactionHandler.performRestartActivity(r, false /* start */);
                    break;
                default:
                    throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
            }
        }
    }

到這里咱們終于看到了熟悉的內容，Activity的生命周期，好激動哈哈，

這里咱們以 ON_CREATE 為例，從上面代碼看出 ON_CREATE 等其實就是個int值(常量)，這里咱就不多描述了，mTransactionHandler 是 ClientTransactionHandler 的實體，直接看handleLaunchActivity() 方法，

9.2.11 ClientTransactionHandler.handleLaunchActivity()

frameworks/base/core/java/android/app/ClientTransactionHandler.java

public abstract class ClientTransactionHandler {
    ...
    /** Perform activity launch. */
    public abstract Activity handleLaunchActivity(@NonNull ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent);
    ...    
}

從上面看出 handleLaunchActivity() 是抽象方法，ActivityThread 做為其子類，只能找其子類 ActivityThread 看看具體實作，

9.2.12 ActivityThread.handleLaunchActivity()

    /**
     * Extended implementation of activity launch. Used when server requests a launch or relaunch.
     */
    @Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
        // 在創建 activity 之前初始化
        if (ThreadedRenderer.sRendererEnabled
                && (r.activityInfo.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
            HardwareRenderer.preload();
        }
        //初始化 Activity 的 WindowManager，每一個 Activity 都會對應一個"視窗"，
        WindowManagerGlobal.initialize();

        // 提示 GraphicsEnvironment Activity 正在行程中啟動，
        GraphicsEnvironment.hintActivityLaunch();

        //這里重點：Activity 啟動的核心實作，
        final Activity a = performLaunchActivity(r, customIntent);
        ...
        return a;
    }

performLaunchActivity()，Activity 啟動的核心實作，具體咱們往下看

9.2.13 ActivityThread.performLaunchActivity()

    /**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            //注釋1： 新實體化的 Activity 物件，
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            ...
        } catch (Exception e) {
            ...
        }
                //重點：呼叫activity.attach()，
                //建立 Activity 與 Context 之間的聯系，
                //創建 PhoneWindow 物件，并與 Activity 進行關聯操作，
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback,
                        r.assistToken, r.shareableActivityToken);
                        
                //persistableMode屬性設定為： ActivityInfo.PERSIST_ACROSS_REBOOTS(persistAcrossReboots);
                //注釋2：執行 Activity 的 onCreate() 方法，
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
        return activity;
    }

這里首先看看 mInstrumentation 其實就是 Instrumentation ，在本文 startActivityForResult 部分也有用到，Instrumentation 負責 Application 和 Activity 的建立和生命周期控制，

這里用到了他的兩個方法咱們一起看看，

9.2.14 Instrumentation.newActivity()

    /**
     * @param cl 用于實體化物件的類加載器(ClassLoader)，
     * @param className 實作 Activity 物件的類的名稱，
     * @param intent 指定要實體化的活動類的 Intent 物件，
     * 
     * @return 新實體化的 Activity 物件，
     */
    public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        String pkg = intent != null && intent.getComponent() != null
                ? intent.getComponent().getPackageName() : null;
        return getFactory(pkg).instantiateActivity(cl, className, intent);
    }

pkg 就是 intent 所在的包名，

getFactory(pkg) 通過獲取到的包名得到 AppComponentFactory ，然后呼叫其 instantiateActivity() 方法獲取 Activity ，

9.2.14.1 Instrumentation.getFactory()

    private AppComponentFactory getFactory(String pkg) {
        if (pkg == null) {
            ...
            return AppComponentFactory.DEFAULT;
        }
        if (mThread == null) {
            ....
            return AppComponentFactory.DEFAULT;
        }
        LoadedApk apk = mThread.peekPackageInfo(pkg, true);
        // This is in the case of starting up "android".
        if (apk == null) apk = mThread.getSystemContext().mPackageInfo;
        return apk.getAppFactory();
    }

9.2.14.2 AppComponentFactory.instantiateActivity()

frameworks/base/core/java/android/app/AppComponentFactory.java

/**
  * 用于控制 manifest 元素實體化的介面，
  *
  * @see #instantiateApplication
  * @see #instantiateActivity
  * @see #instantiateClassLoader
  * @see #instantiateService
  * @see #instantiateReceiver
  * @see #instantiateProvider
  */
public class AppComponentFactory {
      ...
}

instantiateActivity()

    /**
     * 此方法僅用于提供用于實體化的鉤子，
     * 它不提供對 Activity 物件的早期訪問，
     * 回傳的物件還不會被初始化為 Context 并且不應該用于與其他 android API 互動，
     */
    public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
            @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Activity) cl.loadClass(className).newInstance();
    }

這里通過反射拿到 Activity 的實體，

9.2.15 Instrumentation.callActivityOnCreate()

    /**
     * 執行 Activity#onCreate方法的呼叫，
     *
     * @param activity 正在創建的 activity ，
     * @param icicle 將以前凍結的狀態（或null）傳遞給 onCreate() ，
     */
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        //重點
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }

從這里可以看到即將進入 Activity 的內部，

9.2.15.1 Activity.performCreate()

    final void performCreate(Bundle icicle) {
        performCreate(icicle, null);
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        ...
        //重點
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
        ...
    }

看到這里，startSpecificActivity() 方法中的 行程已啟動的狀態算是完結，startActivity 啟動成功，結合 9.2.13 ActivityThread.performLaunchActivity() 查看 Activity 中的 attach() 方法呼叫早于 onCreate() 方法，

下面讓我們回到 9.1 startSpecificActivity() 中查看行程未啟動的流程情況，

9.3 行程未啟動

既然行程未啟動那肯定先啟動行程了，咱們接著看，

    final ActivityTaskManagerService mService;
    void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
        ....
        mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
    }

從這里看到 mService 其實就是 ATMS ，走著，

9.3.1 ATMS.startProcessAsync()

    void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
            String hostingType) {
        try {
            ...
            // 發布訊息以啟動行程，以避免在持有 ATMS 鎖的情況下呼叫 AMS 可能出現死鎖，
            final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
                    mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
                    isTop, hostingType, activity.intent.getComponent());
            mH.sendMessage(m);
        } finally {
            Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
        }
    }

9.3.2 ActivityManagerInternal.startProcess()

frameworks/base/core/java/android/app/ActivityManagerInternal.java

/**
 * Activity manager local system service interface.
 */
public abstract class ActivityManagerInternal {
    /** Starts a given process. */
    public abstract void startProcess(String processName, ApplicationInfo info,
            boolean knownToBeDead, boolean isTop, String hostingType, ComponentName hostingName);
}

這里是個抽象類，咱們去找其實作類 ActivityManagerService.LocalService，

9.3.3 ActivityManagerService.LocalService.startProcess()

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {   
    ...
    @VisibleForTesting
    public final class LocalService extends ActivityManagerInternal
            implements ActivityManagerLocal {
        ...
        @Override
        public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
                boolean isTop, String hostingType, ComponentName hostingName) {
            try {
                synchronized (ActivityManagerService.this) {
                    // 如果該行程稱為top app，請設定一個提示，以便在啟動該行程時，可以立即應用最高優先級，以避免在附加top app行程之前cpu被其他行程搶占，
                    
                    startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
                            new HostingRecord(hostingType, hostingName, isTop),
                            ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
                            false /* isolated */);
                }
            } finally {
            }
        }
    }
}

9.3.4 ActivityManagerService.startProcessLocked()

    /**
     * Process management.
     */
    final ProcessList mProcessList;
    @GuardedBy("this")
    final ProcessRecord startProcessLocked(String processName,
            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
            HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
            boolean isolated, boolean keepIfLarge) {
        return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
                hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
                keepIfLarge, null /* ABI override */, null /* entryPoint */,
                null /* entryPointArgs */, null /* crashHandler */);
    }

可以看出，這里的 mProcessList 就是 ProcessList，

9.3.5 ProcessList.startProcessLocked()

frameworks/base/services/core/java/com/android/server/am/ProcessList.java

    @GuardedBy("mService")
    final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
            boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
            int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
            boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs,
            Runnable crashHandler) {
        ...
        final boolean success =
                startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
        checkSlow(startTime, "startProcess: done starting proc!");
        return success ? app : null;
    }
    ------------分割線-------------
    @GuardedBy("mService")
    final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
            int zygotePolicyFlags, String abiOverride) {
        return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
                false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
                false /* mountExtStorageFull */, abiOverride);
    }
    ------------分割線-------------
    /**
     * @return {@code true} if process start is successful, false otherwise.
     */
    @GuardedBy("mService")
    boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
            int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
            boolean mountExtStorageFull, String abiOverride) {
            ...
            return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
                    runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
                    instructionSet, invokeWith, startTime);
    }
    ------------分割線-------------
    @GuardedBy("mService")
    boolean startProcessLocked(HostingRecord hostingRecord, String entryPoint, ProcessRecord app,
            int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags, int mountExternal,
            String seInfo, String requiredAbi, String instructionSet, String invokeWith,
            long startTime) {
                ...
                //終于到重點了，
                final Process.ProcessStartResult startResult = startProcess(hostingRecord,
                        entryPoint, app,
                        uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
                        requiredAbi, instructionSet, invokeWith, startTime);
                
                handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
                        startSeq, false);
                ...
    }

反復呼叫，終于看到了關鍵代碼 startProcess() ，

9.3.6 ProcessList.startProcess()

    private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
            ProcessRecord app, int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags,
            int mountExternal, String seInfo, String requiredAbi, String instructionSet,
            String invokeWith, long startTime) {

            ...
            final Process.ProcessStartResult startResult;
            if (hostingRecord.usesWebviewZygote()) {
                //行程是否應該從 webview zygote 產生
                startResult = startWebView(entryPoint,
                        app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                        app.info.dataDir, null, app.info.packageName, app.mDisabledCompatChanges,
                        new String[]{PROC_START_SEQ_IDENT + app.startSeq});
            } else if (hostingRecord.usesAppZygote()) {
                //行程是否應該從應用程式 zygote 中產生
                final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);

                // 我們無法隔離應用程式資料和存盤資料，因為父 zygote 已經這樣做了，
                startResult = appZygote.getProcess().start(entryPoint,
                        app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                        app.info.dataDir, null, app.info.packageName,
                        /*zygotePolicyFlags=*/ ZYGOTE_POLICY_FLAG_EMPTY, isTopApp,
                        app.mDisabledCompatChanges, pkgDataInfoMap, whitelistedAppDataInfoMap,
                        false, false,
                        new String[]{PROC_START_SEQ_IDENT + app.startSeq});
            } else {
                startResult = Process.start(entryPoint,
                        app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                        app.info.dataDir, invokeWith, app.info.packageName, zygotePolicyFlags,
                        isTopApp, app.mDisabledCompatChanges, pkgDataInfoMap,
                        whitelistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
                        new String[]{PROC_START_SEQ_IDENT + app.startSeq});
            }
            ...
   }

無論那種情況都會呼叫 Process.start() ;

9.3.7 Process.start()

frameworks/base/core/java/android/os/Process.java

    /**
     * State associated with the zygote process.
     */
    public static final ZygoteProcess ZYGOTE_PROCESS = new ZygoteProcess();
    public static ProcessStartResult start(@NonNull final String processClass,
                                           @Nullable final String niceName,
                                           int uid, int gid, @Nullable int[] gids,
                                           int runtimeFlags,
                                           int mountExternal,
                                           int targetSdkVersion,
                                           @Nullable String seInfo,
                                           @NonNull String abi,
                                           @Nullable String instructionSet,
                                           @Nullable String appDataDir,
                                           @Nullable String invokeWith,
                                           @Nullable String packageName,
                                           int zygotePolicyFlags,
                                           boolean isTopApp,
                                           @Nullable long[] disabledCompatChanges,
                                           @Nullable Map<String, Pair<String, Long>>
                                                   pkgDataInfoMap,
                                           @Nullable Map<String, Pair<String, Long>>
                                                   whitelistedDataInfoMap,
                                           boolean bindMountAppsData,
                                           boolean bindMountAppStorageDirs,
                                           @Nullable String[] zygoteArgs) {
        return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
                    runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                    abi, instructionSet, appDataDir, invokeWith, packageName,
                    zygotePolicyFlags, isTopApp, disabledCompatChanges,
                    pkgDataInfoMap, whitelistedDataInfoMap, bindMountAppsData,
                    bindMountAppStorageDirs, zygoteArgs);
    }

這里的 ZYGOTE_PROCESS 就是 ZygoteProcess ，呼叫其 start() 方法，

9.3.8 ZygoteProcess.start()

frameworks/base/core/java/android/os/ZygoteProcess.java

    /**
     * 開始一個新的行程，
     * 如果啟用了行程，則會創建一個新行程并在那里執行processClass 的靜態main() 函式，
     * 該函式回傳后行程將繼續運行，
     * 
     * 如果未啟用行程，則會在呼叫者行程中創建一個新執行緒并在那里呼叫 processclass 的 main()，
     * 
     * niceName 引數，如果不是空字串，則是一個自定義名稱，用于提供給行程而不是使用 processClass，
     * 這允許您創建易于識別的行程，即使您使用相同的基本 processClass 來啟動它們，
     *
     * 當 invokeWith 不為 null 時，行程將作為一個新的 app 而不是 zygote fork 啟動，
     * 請注意，這僅適用于 uid 0 或當runtimeFlags 包含 DEBUG_ENABLE_DEBUGGER 時，
     *
     * @param processClass 用作行程主入口點的類，
     * @param niceName 用于行程的更易讀的名稱，
     * @param uid 行程將在其下運行的用戶 ID，
     * @param gid 行程將在其下運行的組 ID，
     * @param gids 與行程關聯的附加組 ID，
     * @param runtimeFlags 附加標志，
     * @param targetSdkVersion 應用的目標 SDK 版本，
     * @param seInfo null-ok 新行程的 SELinux 資訊，
     * @param abi 非空此應用程式應使用的 ABI，
     * @param instructionsSet null-確定要使用的指令集，
     * @param appDataDir null-ok 應用程式的資料目錄，
     * @param invokeWith null-ok 要呼叫的命令，
     * @param packageName null-ok 這個行程所屬的包名，
     * @param zygotePolicyFlags 用于確定如何啟動應用程式的標志，
     * @param isTopApp 行程是否為高優先級應用程式啟動，
     * @param disabledCompatChanges 正在啟動的行程的禁用兼容更改的 null-ok 串列，
     * @param pkgDataInfoMap 從相關包名稱映射到私有資料目錄卷 UUID 和 inode 編號，
     * @param allowlistedDataInfoList 從允許的包名稱映射到私有資料目錄卷 UUID 和 inode 編號，
     * @param bindMountAppsData zygote 是否需要掛載 CE 和 DE 資料，
     * @param bindMountAppStorageDirs zygote 是否需要掛載Android/obb 和Android/data，
     *
     * @param zygoteArgs 提供給 Zygote 行程的附加引數，
     * @return 一個物件，描述嘗試啟動行程的結果，
     * @throws RuntimeException 出現致命啟動失敗
     */
    //這里從上一個方法傳來一大堆引數就不多描述了
    public final Process.ProcessStartResult start(...) {
        ...
            return startViaZygote(processClass, niceName, uid, gid, gids,
                    runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                    abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
                    packageName, zygotePolicyFlags, isTopApp, disabledCompatChanges,
                    pkgDataInfoMap, allowlistedDataInfoList, bindMountAppsData,
                    bindMountAppStorageDirs, zygoteArgs);
        ...
    }

9.3.9 ZygoteProcess.startViaZygote()

    //這里從上一個方法傳來一大堆引數就不多描述了
    private Process.ProcessStartResult startViaZygote(...)
                                                      throws ZygoteStartFailedEx {
        ...
        synchronized(mLock) {
            // The USAP pool can not be used if the application will not use the systems graphics
            // driver.  If that driver is requested use the Zygote application start path.
            return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
                                              zygotePolicyFlags,
                                              argsForZygote);
        }
    }

在看 zygoteSendArgsAndGetResult() 之前咱們看看 openZygoteSocketIfNeeded(abi) ，

9.3.10 ZygoteProcess.openZygoteSocketIfNeeded()

    /**
     * 嘗試打開一個 session socket到具有兼容 ABI 的 Zygote 行程（如果尚未打開）， 如果兼容的 session socket已經打開，則回傳該 session socket，
     *
     * 此功能可能會阻塞，并且可能必須嘗試連接到多個 Zygotes 才能找到合適的 Zygotes， 需要保持 mLock，
     */
    @GuardedBy("mLock")
    private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
        try {
            attemptConnectionToPrimaryZygote();

            ...
    }
    ------------分割線-------------
    /**
     * 如果Primary Zygote不存在或已斷開連接，則為它創建一個 ZygoteState，
     */
    @GuardedBy("mLock")
    private void attemptConnectionToPrimaryZygote() throws IOException {
        if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
            primaryZygoteState =
                    ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
            ...
        }
    }
    ------------分割線-------------
    static ZygoteState connect(@NonNull LocalSocketAddress zygoteSocketAddress,
            @Nullable LocalSocketAddress usapSocketAddress)
            throws IOException {
        ...
        //創建LocalSocket
        final LocalSocket zygoteSessionSocket = new LocalSocket();
            //將zygoteSessionSocket連接到端點，
            //只能在尚未連接的實體上呼叫，
            zygoteSessionSocket.connect(zygoteSocketAddress);
        ...
    }

打開了 ZygoteSocket 之后咱們看看 zygoteSendArgsAndGetResult();

9.4.11 ZygoteProcess.zygoteSendArgsAndGetResult()

    @GuardedBy("mLock")
    private Process.ProcessStartResult zygoteSendArgsAndGetResult(
            ZygoteState zygoteState, int zygotePolicyFlags, @NonNull ArrayList<String> args)
            throws ZygoteStartFailedEx {
        ...
        String msgStr = args.size() + "\n" + String.join("\n", args) + "\n";        
        return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
    }

9.4.12 ZygoteProcess.attemptZygoteSendArgsAndGetResult()

    private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
            ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
        try {
            final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
            final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;

            //寫，呼叫zygote(ZygoteInit)，
            zygoteWriter.write(msgStr);
            zygoteWriter.flush();

            // Always read the entire result from the input stream to avoid leaving
            // bytes in the stream for future process starts to accidentally stumble
            // upon.
            Process.ProcessStartResult result = new Process.ProcessStartResult();
            //讀，造成阻塞
            result.pid = zygoteInputStream.readInt();
            result.usingWrapper = zygoteInputStream.readBoolean();

            if (result.pid < 0) {
                throw new ZygoteStartFailedEx("fork() failed");
            }

            return result;
        } catch (IOException ex) {
            zygoteState.close();
            Log.e(LOG_TAG, "IO Exception while communicating with Zygote - "
                    + ex.toString());
            throw new ZygoteStartFailedEx(ex);
        }
    }

9.4.13 ZygoteInit.main()

    @UnsupportedAppUsage
    public static void main(String[] argv) {
            ...
            // zygote 永久回圈，
            caller = zygoteServer.runSelectLoop(abiList);
    }

9.4.14 ZygoteService.runSelectLoop()

    /**
     * 運行 zygote 行程的選擇回圈， 在新連接發生時接受新連接，并從連接中讀取一次一個 spawn-request 值的命令，
     * @param abiList 此 zygote 支持的 ABI 串列，
     */
    Runnable runSelectLoop(String abiList) {
        ...
                            //Session socket accepted from the Zygote server socket
                            ZygoteConnection connection = peers.get(pollIndex);
                            //通過 fork 啟動 子行程(應用程式)
                            final Runnable command = connection.processOneCommand(this);
        ...                                   
    }

9.4.15 ZygoteConnection.processOneCommand()

frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java

    Runnable processOneCommand(ZygoteServer zygoteServer) {
        ...
        pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
                parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
                parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
                parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mIsTopApp,
                parsedArgs.mPkgDataInfoList, parsedArgs.mWhitelistedDataInfoList,
                parsedArgs.mBindMountAppDataDirs, parsedArgs.mBindMountAppStorageDirs);
        ...
    }

fork 出一個新的行程(APP)，一個APP的程式入口就是ActivityThread.main()，

9.4.15 ActivityThread.main()

frameworks/base/core/java/android/app/ActivityThread.java

在 ActivityThread 初始化的時候，就已經創建訊息回圈了，所以在主執行緒里面創建 Handler 不需要指定 Looper，而如果在其他執行緒使用Handler，則需要 單獨使用Looper.prepare()和Looper.loop() 創建訊息回圈，

    public static void main(String[] args) {
        ...
        //初始化當前行程的 Looper 物件
        Looper.prepareMainLooper();
        ...
        ActivityThread thread = new ActivityThread();
        //此處創建Application
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // 呼叫 Looper 的 loop 方法開啟無限回圈，
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

Looper ：從 MessageQueue 中取出 Message，然后處理 Message 中指定的任務(startActivity)，

至此，不管是呼叫 startActivity() 啟動頁面，還是呼叫 startActivity() 開啟其他行程的界面都算完成了，

如有問題麻煩指正，

??Android 從原始碼解讀 Apk 的安裝程序 ??

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/308901.html

標籤：其他

上一篇：【C++初階】C++入門 | 第一章（命名空間、輸入&輸出、預設引數、函式多載等）

下一篇：【Java SE】第一章：Java的簡介與簡單的Java程式

?? Android startActivity原始碼分析(含啟動新應用) ??

開局一張圖

涉及到的類

1、Activity.java

1.1 startActivity()

1.2 startActivityForResult()

2、Instrumentation.java

2.1 execStartActivity()

3、ActivityTaskManage.java

3.1 getService()

3.2 IActivityTaskManagerSingleton

4、ActivityTaskManagerService.java

4.1 startActivity()

4.2 startActivityAsUser()

4.3 startActivityAsUser() 比上面多個引數

4.4 getActivityStartController()

5、ActivityStartController.java

5.1 obtainStarter();

6、ActivityStarter.java

6.1 execute()

6.2 executeRequest()

6.3 startActivityUnchecked()

6.4 startActivityInner()

7、RootWindowContainer.java

7.1 resumeFocusedTasksTopActivities()

8、Task.java

8.1 resumeTopActivityUncheckedLocked()

8.2 resumeTopActivityInnerLocked()

9、ActivityTaskSupervisor.class

9.1 startSpecificActivity()

9.2 行程已啟動

9.2.1 realStartActivityLocked()

9.2.2 ClientLifecycleManager.scheduleTransaction()

9.2.3 ClientTransaction.schedule()

9.2.4 ApplicationThread.scheduleTransaction()

9.2.5 ClientTransactionHandler.scheduleTransaction()

9.2.6 ActivityThread.H.handleMessage()

9.2.7 TransactionExecutor.execute()

9.2.8 TransactionExecutor.executeCallbacks()

9.2.9 TransactionExecutor.cycleToPath()

9.2.10 TransactionExecutor.performLifecycleSequence()

9.2.11 ClientTransactionHandler.handleLaunchActivity()

9.2.12 ActivityThread.handleLaunchActivity()

9.2.13 ActivityThread.performLaunchActivity()

9.2.14 Instrumentation.newActivity()

9.2.15 Instrumentation.callActivityOnCreate()

9.3 行程未啟動

9.3.1 ATMS.startProcessAsync()

9.3.2 ActivityManagerInternal.startProcess()

9.3.3 ActivityManagerService.LocalService.startProcess()

9.3.4 ActivityManagerService.startProcessLocked()

9.3.5 ProcessList.startProcessLocked()

9.3.6 ProcessList.startProcess()

9.3.7 Process.start()

9.3.8 ZygoteProcess.start()

9.3.9 ZygoteProcess.startViaZygote()

9.3.10 ZygoteProcess.openZygoteSocketIfNeeded()

9.4.11 ZygoteProcess.zygoteSendArgsAndGetResult()

9.4.12 ZygoteProcess.attemptZygoteSendArgsAndGetResult()

9.4.13 ZygoteInit.main()

9.4.14 ZygoteService.runSelectLoop()

9.4.15 ZygoteConnection.processOneCommand()

9.4.15 ActivityThread.main()

相關推薦

?? Android 應用是如何啟動的？??

??Android Runtime (ART) 和 Dalvik??

??Android Apk 的打包程序 ?? 只需兩幅圖

??Android 從原始碼解讀 Apk 的安裝程序 ??