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以上是关于❤️ Android startActivity源码分析(含启动新应用) ❤️的主要内容，如果未能解决你的问题，请参考以下文章 
 Android startActivities()的使用
 应用内部启动startActivity-Android12
 应用内部启动startActivity-Android12
 Android 系统源码初步阅读之 activity 的 startActivity(intent) 与 非 activity 的 startActivity(...) 的不同
 Android 系统源码初步阅读之 activity 的 startActivity(intent) 与 非 activity 的 startActivity(...) 的不同
 源码解析之-基于Android10.0的startActivity