由于看的学习资料版本与现在的不一致，所以准备自己动手写一篇，方便之后的回顾。

Activity -> startActivity

public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

public void startActivity(Intent intent, @Nullable Bundle options) {
    ...
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        // Note we want to go through this call for compatibility with
        // applications that may have overridden the method.
        startActivityForResult(intent, -1);
    }
}


public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
    ...
    Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
    ...
}

mInstrumentation.execStartActivity() -> Instrumentation.execStartActivity()

Instrumentation -> execStartActivity

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, String target,
        Intent intent, int requestCode, Bundle options) {
    ...
    int result = ActivityTaskManager.getService().startActivity(whoThread,
                    who.getBasePackageName(), who.getAttributionTag(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()), token, target,
                    requestCode, 0, null, options);
    ...
}

ActivityTaskManager -> getService

public static IActivityTaskManager getService() {
    return IActivityTaskManagerSingleton.get();
}

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);
            }
};

Android 11 之后拿到的是 ActivityTaskManagerService

ActivityTaskManagerService -> startActivity

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    ...
    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());
    }

    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*/);
    }

    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");

        // TODO: Switch to user app stacks here.
        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();
    }
    ...
}

getActivityStartController().obtainStarter() 得到的是 ActivityStarter 对象，所以会执行 ActivityStarter 的 execute 方法

ActivityStarter -> execute

int execute() {
    try {
        if (mRequest.intent != null && mRequest.intent.hasFileDescriptors()) {
                throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        
        final LaunchingState launchingState;
            synchronized (mService.mGlobalLock) {
                final ActivityRecord caller = ActivityRecord.forTokenLocked(mRequest.resultTo);
                launchingState = mSupervisor.getActivityMetricsLogger().notifyActivityLaunching(
                        mRequest.intent, caller);
        }

        if (mRequest.activityInfo == null) {
                mRequest.resolveActivity(mSupervisor);
        }
  
        int res;
        synchronized (mService.mGlobalLock) {
            final boolean globalConfigWillChange = mRequest.globalConfig != null
                        && mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
                final ActivityStack stack = mRootWindowContainer.getTopDisplayFocusedStack();
                if (stack != null) {
                    stack.mConfigWillChange = globalConfigWillChange;
                }
                if (DEBUG_CONFIGURATION) {
                    Slog.v(TAG_CONFIGURATION, "Starting activity when config will change = "
                            + globalConfigWillChange);
            }
            
            final long origId = Binder.clearCallingIdentity();

            res = resolveToHeavyWeightSwitcherIfNeeded();
            if (res != START_SUCCESS) {
                return res;
            }
            res = executeRequest(mRequest);
            Binder.restoreCallingIdentity(origId);
            if (globalConfigWillChange) {
                mService.mAmInternal.enforceCallingPermission(
                            android.Manifest.permission.CHANGE_CONFIGURATION,
                            "updateConfiguration()");
                if (stack != null) {
                        stack.mConfigWillChange = false;
                }
                if (DEBUG_CONFIGURATION) {
                    Slog.v(TAG_CONFIGURATION,
                            "Updating to new configuration after starting activity.");
                }
                mService.updateConfigurationLocked(mRequest.globalConfig, null, false);
            }
            
            mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
                        mLastStartActivityRecord);
            return getExternalResult(mRequest.waitResult == null ? res
                        : waitForResult(res, mLastStartActivityRecord));
        }
    } finally {
        onExecutionComplete();
    }
}

executeRequest() -> ActivityStarter. executeRequest()

ActivityStarter -> executeRequest

private int executeRequest(Request request) {
    ...
    mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
                restrictedBgActivity, intentGrants);
    ...
}

startActivityUnchecked() -> ActivityStarter.startActivityUnchecked()

ActivityStarter -> 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) {
    ...
    result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
    ...
}

startActivityInner() -> ActivityStarter. startActivityInner()

ActivityStarter -> startActivityInner

int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, Task inTask,
            boolean restrictedBgActivity, NeededUriGrants intentGrants) {
    ...
    mRootWindowContainer.resumeFocusedStacksTopActivities(
                        mTargetStack, mStartActivity, mOptions);
    ...
}

mRootWindowContainer.resumeFocusedStacksTopActivities() -> RootWindowContainer.resumeFocusedStacksTopActivities()

RootWindowContainer -> resumeFocusedStacksTopActivities

 boolean resumeFocusedStacksTopActivities(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    ...
    targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    ...
}

targetStack.resumeTopActivityUncheckedLocked() -> ActivityStack.resumeTopActivityUncheckedLocked()

ActivityStack -> resumeTopActivityUncheckedLocked

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    resumeTopActivityInnerLocked(prev, options);
    ...
}

resumeTopActivityInnerLocked() -> ActivityStack.resumeTopActivityInnerLocked()

ActivityStack -> resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    mStackSupervisor.startSpecificActivity();
    ...
}

mStackSupervisor.startSpecificActivity() -> ActivityStackSupervisor.startSpecificActivity()

ActivityStackSupervisor -> startSpecificActivity

 void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
    ...
    realStartActivityLocked(r, wpc, andResume, checkConfig);
    ...
}

realStartActivityLocked() -> ActivityStackSupervisor. realStartActivityLocked()

ActivityStackSupervisor -> realStartActivityLocked

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
    ...
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    ...
}

mService.getLifecycleManager().scheduleTransaction() -> ClientLifecycleManager.scheduleTransaction()

ClientLifecycleManager -> scheduleTransaction

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
        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();
    }
}

transaction.schedule() -> ClientTransaction. schedule()

ClientTransaction -> schedule

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

回到之前 startActivityForResult 调用的方法

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
    Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
}

在执行方法时会设置参数 mMainThread.getApplicationThread()，而 mMainThread.getApplicationThread() 方法获得的是 ApplicationThread，
ApplicationThread 是 ActivityThread 的内部类

mClient.scheduleTransaction() -> ApplicationThread.scheduleTransaction()

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

所以最终执行的是 ClientTransactionHandler.scheduleTransaction(transaction)

ClientTransactionHandler -> scheduleTransaction

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

sendMessage 是一个抽象方法，具体实现由子类 ActivityThread 实现

ActivityThread -> sendMessage

void sendMessage(int what, Object obj) {
    sendMessage(what, obj, 0, 0, false);
}

private void sendMessage(int what, Object obj, int arg1) {
    sendMessage(what, obj, arg1, 0, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2) {
    sendMessage(what, obj, arg1, arg2, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
    if (DEBUG_MESSAGES) {
            Slog.v(TAG,
                    "SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
    }
    Message msg = Message.obtain();
    msg.what = what;
    msg.obj = obj;
    msg.arg1 = arg1;
    msg.arg2 = arg2;
    if (async) {
        msg.setAsynchronous(true);
    }
    mH.sendMessage(msg);
}

msg.what = ActivityThread.H.EXECUTE_TRANSACTION 我们到 H 类去看看

H 类

case EXECUTE_TRANSACTION:
    final ClientTransaction transaction = (ClientTransaction) msg.obj;
    mTransactionExecutor.execute(transaction);
    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;

mTransactionExecutor.execute() -> TransactionExecutor.execute()

TransactionExecutor -> execute

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

executeCallbacks -> TransactionExecutor. executeCallbacks()
executeLifecycleState -> TransactionExecutor. executeLifecycleState()

TransactionExecutor -> executeCallbacks

public void executeCallbacks(ClientTransaction transaction) {
    ...
    item.execute(mTransactionHandler, token, mPendingActions);
    ...
}

item.execute() -> LaunchActivityItem.execute()

LaunchActivityItem -> execute

public void execute(ClientTransactionHandler client, IBinder token,
        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, mAssistToken, mFixedRotationAdjustments);
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

client.handleLaunchActivity() -> ActivityThread. handleLaunchActivity()

ActivityThread -> handleLaunchActivity

public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
    ...
    final Activity a = performLaunchActivity(r, customIntent);
    ...
}

ActivityThread -> performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ...
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    ...
}

mInstrumentation.callActivityOnCreate() -> Instrumentation..callActivityOnCreate()

Instrumentation -> callActivityOnCreate

public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
    prePerformCreate(activity);
    activity.performCreate(icicle, persistentState);
    postPerformCreate(activity);
}

activity.performCreate() -> Activity.performCreate()

Activity -> performCreate

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    ...
    if (persistentState != null) {
            onCreate(icicle, persistentState);
    } else {
            onCreate(icicle);
    }
    ...
}

最终调用 Activity 的 onCreate 方法，setContentView 也是在我们的 onCreate 方法调用。

TransactionExecutor -> executeLifecycleState

private void executeLifecycleState(ClientTransaction transaction) {
    ...
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    ...
}

lifecycleItem.execute() -> ResumeActivityItem.execute()

ResumeActivityItem -> execute

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

client.handleResumeActivity -> ActivityThread.handleResumeActivity()

ActivityThread -> handleResumeActivity

public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
            String reason) {
    ...
    final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
    ...
}

performResumeActivity() -> ActivityThread. performResumeActivity()

ActivityThread -> performResumeActivity

public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
            String reason) {
    ...
    r.activity.performResume(r.startsNotResumed, reason);
    ...
}

r.activity.performResume() -> Activity.performResume()

Activity -> performResume

final void performResume(boolean followedByPause, String reason) {
    ...
    performRestart(true /* start */, reason);
    mInstrumentation.callActivityOnResume(this);
    ...
}

performResume 最终调用了 onStart 和 onResume 方法，Activity 显示到当前页面

setContentView 源码解析

启动流程

文章就介绍到这里了，如果有什么写得不对的，可以在下方评论留言，我会第一时间改正。