Android Activity启动流程(Android 13)

Android Activity启动流程(Android 13)

概述

AMS（ActivityManagerService） 是 Android 使用系统中的一个核心组件。它负责管理应用程序的生命周期、历程管理、任务管理、内存管理以及应用程序之间的通信。
在 Android 10 及以后版本中，AMS 的部分功能迁移到了 ATMS，Activity 的管理和调度主要由 ATMS（ActivityTaskManagerService） 负责，而其他三大组件（Service、ContentProvider 和 BroadcastReceiver）仍旧由 AMS 管理。AMS 持有 ATMS 的引用，AMS 可以通过 ATMS 处理 Activity。
流程图

• App 历程向 SystemServer 历程发送 startActivity 请求。
  
• SystemServer 历程处理 startActivity 请求，如果 App 历程存在，则直接调用直接启动 Activity，如果 App 历程不存在，则向 Zygote 历程发送创建历程消息。
  
• Zygote 历程收到请求后，fork新历程，并调用 ActivityThread 的 main() 初始化使用。
  
• 新历程启动后，向 ActivityManagerService 发送 attachApplication，告诉 AMS 新历程已经启动了。
  
• ActivityManagerService 收到新历程通知，会做一些准备工作，然后调用 ActivityTaskSupervisor#realStartActivityLocked() 启动 Activity。ActivityTaskSupervisor 使用 ApplicationThread 的 Binder 代理向被启动的App历程发送 scheduleTransaction 请求。
  
• 已启动的 App 历程的 ApplicationThread（Binder 客户端） 收到请求后，通过 handler 向主线程发送 EXECUTE_TRANSACTION 消息。
  
• 主线程在收到消息后，通过反射机制创建目标 Activity，启动 Activity 并回调Activity.onCreate()等方法。
  

条件

• ActivityManagerService（AMS）：负责管理 Service、BroadcastReceiver 和 ContentProvider。
  
• ActivityTaskManagerService（ATMS）：负责 Activity 的启动、生命周期管理、任务栈管理等。
  
• ActivityTaskSupervisor：属于 AMTS 的一部分，负责监视和管理 Activity 的生命周期、任务栈以及 Activity 的启动和切换等使用。。
  
• Instrumentation：负责创建 Application 和 Activity 和管理生命周期，持有 ActivityThread 的引用。
  
• ActivityTaskManager：提供有关活动及其容器(如任务、堆栈和显示器)的信息，并与之交互。
  
• ActivityStartController：ActivityStart 的控制类。
  
• ActivityStarter：负责 Activity 的启动。
  
• ActivityInfo：负责记载 Activity 信息，如：主题、启动模式、屏幕方向、包信息等。
  
• ProcessRecord：负责记载历程信息，如：身份信息、历程中的组件（Activity组件记载表，Service组件记载表，广播记载表，ContentProvider记载表等）、历程状态、时间、Crash、ANR、电源信息等。
  
• ActivityRecord：负责记载 Activity 的信息，一个 Activity 对应一个 ActivityRecord，如：Activity 的配置信息、运行状态等。
  
• Task：继续自 TaskFragment，负责管理 Activity 的启动顺序，内部维护 ArrayList<ActivityRecord>。
  
• ActivityStackSupervisor：负责管理 ActivityStack 任务栈。
  
  
  
  • ArrayList<ActivityRecord> mStoppingActivities：维护克制的Activity。
    
  • ArrayList<ActivityRecord> mFinishingActivitie：维护已竣事的Activity。
    
  • ArrayList<ActivityRecord> mNoAnimActivities：维护无过渡动画的Activity。
    
  
  
• RootWindowContainer：负责管理与 Activity 相干的窗口。
  
• ActivityThread：运行在 UI 线程（主线程），App的入口。
  
• ApplicationThread：实现 IBinder 接口，是 ActivityThread 的内部类，负责与 ATMS 交互。
  
• ActivityStartController：负责 ATMS 中 Actvitiy 启动相干的功能。
  
• ResolveInfo：存储剖析 AndroidManifest.xml 的信息，如：Activity、Broadcast、Service、ContentProvider、packageName 等。
  
• 客户端：启动 Activity 的历程。
  
• 服务端：system_server 历程。
  

流程分析

Activity#startActivity()

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

复制代码

1. public void startActivity(Intent intent, @Nullable Bundle options) {
2.     getAutofillClientController().onStartActivity(intent, mIntent);
3.     if (options != null) {
4.         startActivityForResult(intent, -1, options);
5.     } else {
6.         startActivityForResult(intent, -1);
7.     }
8. }

复制代码

说明：

• 最终都会调用 Activity#startActivityForResult()，
  
• requestCode 为 -1 时表示没有返回值。
  

Activity#startActivityForResult()

1. public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,                                                                                                                                                      @Nullable Bundle options) {
2.     if (mParent == null) {
3.         options = transferSpringboardActivityOptions(options);
4.         // 调用Instrumentation#execStartActivity()
5.         Instrumentation.ActivityResult ar =
6.             mInstrumentation.execStartActivity(
7.             this, mMainThread.getApplicationThread(), mToken, this,
8.             intent, requestCode, options);
9.         if (ar != null) {
10.             mMainThread.sendActivityResult(
11.                 mToken, mEmbeddedID, requestCode, ar.getResultCode(),
12.                 ar.getResultData());
13.         }
14.         // requestCode必须>=0才可以启动Activity
15.         if (requestCode >= 0) {
16.             mStartedActivity = true;
17.         }
18.         // 取消输入事件，开始执行Activity动画
19.         cancelInputsAndStartExitTransition(options);
20.     } else {
22.     }
23. }

复制代码

说明：

• 最终调用 Instrumentation#execStartActivity()。
  
• mMainThread 是 ActivityThread 的实例。
  
• 通过 getApplicationThread() 获取 ApplicationThread，ApplicationThread 是一个 Binder 类。
  

Instrumentation#execStartActivity()

1. public ActivityResult execStartActivity(
2.         Context who, IBinder contextThread, IBinder token, Activity target,
3.         Intent intent, int requestCode, Bundle options) {
4.     IApplicationThread whoThread = (IApplicationThread) contextThread;
5.     // ......
6.     try {
7.         intent.migrateExtraStreamToClipData(who);
8.         intent.prepareToLeaveProcess(who);
9.         // 最终调用ActivityTaskManager#startActivity，并获取返回值
10.         int result = ActivityTaskManager.getService().startActivity(whoThread,
11.                 who.getOpPackageName(), who.getAttributionTag(), intent,
12.                 intent.resolveTypeIfNeeded(who.getContentResolver()), token,
13.                 target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
14.         // 检查Activity启动结果
15.         checkStartActivityResult(result, intent);
16.     } catch (RemoteException e) {
17.         throw new RuntimeException("Failure from system", e);
18.     }
19.     return null;
20. }

复制代码

说明：

• 通过 ActivityTaskManager 获取 ActivityTaskManagerService，举行 Binder 通信。
  
• 向 SystemServer 历程中 ATMS 发送 startActivity 请求
  
• 通过 checkStartActivityResult() 检测启动效果，如非常：未在AndroidManifest.xml中注册抛出非常等。
  

ActivityTaskManager#getService()

1. // ActivityTaskManager类
2. public static IActivityTaskManager getService() {
3.     return IActivityTaskManagerSingleton.get();
4. }
6. private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
7.             new Singleton<IActivityTaskManager>() {
8.                 @Override
9.                 protected IActivityTaskManager create() {
10.                     final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
11.                     return IActivityTaskManager.Stub.asInterface(b);
12.                 }
13.             };

复制代码

ActivityTaskManagerService#startActivity()

1. public final int startActivity(IApplicationThread caller, String callingPackage,
2.         String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
3.         String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
4.         Bundle bOptions) {
5.     // 调用ActivityTaskManagerService#startActivityAsUser()
6.     return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
7.             resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
8.             UserHandle.getCallingUserId());
9. }

复制代码

说明：

• 这是一个跨历程使用，已经进入 system_server 历程。
  
• 在该流程return前，Client即发起startActivity的应用历程均处于挂起状态。
  

ActivityTaskManagerService#startActivityAsUser()

1. public int startActivityAsUser(IApplicationThread caller, String callingPackage,
2.             String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
3.             String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
4.             Bundle bOptions, int userId) {
5.         return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
6.                 resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
7.                 true );
8. }

复制代码

1. private int startActivityAsUser(IApplicationThread caller, String callingPackage,
2.         @Nullable String callingFeatureId, Intent intent, String resolvedType,
3.         IBinder resultTo, String resultWho, int requestCode, int startFlags,
4.         ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
5.        
6.       userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
7.                 Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
8.    
9.     // 最终调用ActivityStarter#execute()
10.     return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
11.             .setCaller(caller)
12.             .setCallingPackage(callingPackage)
13.             .setCallingFeatureId(callingFeatureId)
14.             .setResolvedType(resolvedType)
15.             .setResultTo(resultTo)
16.             .setResultWho(resultWho)
17.             .setRequestCode(requestCode)
18.             .setStartFlags(startFlags)
19.             .setProfilerInfo(profilerInfo)
20.             .setActivityOptions(bOptions)
21.             .setUserId(userId)
22.             .execute();
23. }

复制代码

说明：

• 通过 getActivityStartController() 获取 ActivityStartController 实例。
  
• 通过 obtainStarter() 获取 ActivityStarter 实例。
  
• 最终调用 ActivityStarter#execute()。
  

ActivityStarter#execute()

1. int execute() {
2.     // ......
3.     try {
4.         // 调用ActivityStarter#executeRequest()
5.         res = executeRequest(mRequest);
6.     } finally {
7.         // 启动Activity后的回调
8.         onExecutionComplete();
9.     }
10. }

复制代码

ActivityStarter#executeRequest()

1. private int executeRequest(Request request) {   
3.     // 创建ActivityRecord
4.     final ActivityRecord r = new ActivityRecord.Builder(mService)
5.         .setCaller(callerApp)
6.         .setLaunchedFromPid(callingPid)
7.         .setLaunchedFromUid(callingUid)
8.         .setLaunchedFromPackage(callingPackage)
9.         .setLaunchedFromFeature(callingFeatureId)
10.         .setIntent(intent)
11.         .setResolvedType(resolvedType)
12.         .setActivityInfo(aInfo)
13.         .setConfiguration(mService.getGlobalConfiguration())
14.         .setResultTo(resultRecord)
15.         .setResultWho(resultWho)
16.         .setRequestCode(requestCode)
17.         .setComponentSpecified(request.componentSpecified)
18.         .setRootVoiceInteraction(voiceSession != null)
19.         .setActivityOptions(checkedOptions)
20.         .setSourceRecord(sourceRecord)
21.         .build();
23.     // 调用ActivityStarter#startActivityUnchecked()
24.     mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
25.                 request.voiceInteractor, startFlags, true /* doResume */, checkedOptions,
26.                 inTask, inTaskFragment, restrictedBgActivity, intentGrants);
27.       
28.     return mLastStartActivityResult;
29. }

复制代码

说明：

• 创建 ActivityRecord 实例。
  
• 调用 startActivityUnchecked()。
  

ActivityStarter#startActivityUnchecked()

1. private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
2.                                    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
3.                                    int startFlags, boolean doResume, ActivityOptions options, Task inTask,
4.                                    TaskFragment inTaskFragment, boolean restrictedBgActivity,
5.                                    NeededUriGrants intentGrants) {
6. 、
7.     try {
8.         mService.deferWindowLayout();
9.         Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
10.         // 调用ActivityStarter#startActivityInner()
11.         result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
12.                                     startFlags, doResume, options, inTask, inTaskFragment,                                                                             restrictedBgActivity, intentGrants);
13.     }  
14.     return result;
15. }

复制代码

ActivityStarter#startActivityInner()

1. int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
2.         IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
3.         int startFlags, boolean doResume, ActivityOptions options, Task inTask,
4.         TaskFragment inTaskFragment, boolean restrictedBgActivity,
5.         NeededUriGrants intentGrants) {
6.     // 初始化参数
7.     setInitialState(r, options, inTask, inTaskFragment, doResume, startFlags, sourceRecord,
8.             voiceSession, voiceInteractor, restrictedBgActivity);
9.         // 处理Intent携带的flags
10.     computeLaunchingTaskFlags();
11.     // 获取Activity的任务栈
12.     computeSourceRootTask();
13.     // 设置启动模式
14.     mIntent.setFlags(mLaunchFlags);   
15.     // 获取可用的任务栈
16.     final Task reusedTask = getReusableTask();
17.   
18.     // 计算是否有一个现存的任务需要使用
19.     final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
20.     // 标记是否使用新建任务栈
21.     final boolean newTask = targetTask == null;
22.     mTargetTask = targetTask;
24.     // 调用RootWindowContainer#resumeFocusedTasksTopActivities()
25.     mRootWindowContainer.resumeFocusedTasksTopActivities(
26.                         mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
28.     return START_SUCCESS;
29. }

复制代码

说明：

• 这里主要处理任务栈相干流程：
  
  
  
  • 如果找到可用任务栈则直接使用，如果没有找到可用则新建。
    
  
  
• 接着调用 resumeFocusedTasksTopActivities()。
  

RootWindowContainer#resumeFocusedTasksTopActivities()

1. boolean resumeFocusedTasksTopActivities(
2.         Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
3.         boolean deferPause) {
4.     boolean result = false;
5.     if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
6.             || getTopDisplayFocusedRootTask() == targetRootTask)) {
7.         // 调用Task#resumeTopActivityUncheckedLocked()
8.         result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
9.                 deferPause);
10.     }  
11.     return result;
12. }

复制代码

Task#resumeTopActivityUncheckedLocked()

1. boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
2.                                          boolean deferPause) {
3.     // 调用Task#resumeTopActivityInnerLocked()
4.     someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
5.     return someActivityResumed;
6. }

复制代码

Task#resumeTopActivityInnerLocked()

1. private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
2.         boolean deferPause) {
3.     // 获取任务栈的栈顶的Activity
4.     final ActivityRecord topActivity = topRunningActivity(true);
5.     final TaskFragment topFragment = topActivity.getTaskFragment();
6.     // TaskFragment#resumeTopActivity()
7.     resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);   
8.     return resumed[0];
9. }

复制代码

TaskFragment#resumeTopActivity()

1. final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
2.                                 boolean deferPause) {     
3.     ActivityRecord next = topRunningActivity(true);
5.     if (mResumedActivity != null) {
6.         // 暂停栈顶的Activity
7.         pausing |= startPausing(mTaskSupervisor.mUserLeaving, false,                                                                                                                                  next, "resumeTopActivity");
8.     }
10.     // 调用ActivityTaskSupervisor#startSpecificActivity()
11.     mTaskSupervisor.startSpecificActivity(next, true, false);
12.     return true;
13. }

复制代码

说明：

• 暂停栈顶的 Activity。
  
• 调用 startSpecificActivity() 启动 Activity。
  

ActivityTaskSupervisor#startSpecificActivity()

1. void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
2.     // Activity所在的App进程是否运行
3.     final WindowProcessController wpc =
4.             mService.getProcessController(r.processName, r.info.applicationInfo.uid);
6.     boolean knownToBeDead = false;
7.     if (wpc != null && wpc.hasThread()) {
8.         try {
9.             // 进程已启动情况
10.             realStartActivityLocked(r, wpc, andResume, checkConfig);
11.             return;
12.         } catch (RemoteException e) {           
13.         }
14.     }
16.     r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
18.     final boolean isTop = andResume && r.isTopRunningActivity();
19.     // 进程没有启动情况
20.     mService.startProcessAsync(r, knownToBeDead, isTop,
21.             isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
22.                     : HostingRecord.HOSTING_TYPE_ACTIVITY);
23. }

复制代码

说明：

• mService 是 ActivityTaskManagerService 的实例。
  
• 开始执行启动 Activity 的流程。
  
• 历程已启动情况：直接启动 Activity。
  
• 历程未启动情况：先启动历程，再启动 Activity。
  

情况一：历程已启动

ActivityTaskSupervisor#realStartActivityLocked()

1. boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
2.         boolean andResume, boolean checkConfig) throws RemoteException {            
3.     // 创建启动Activity的事务
4.     final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.token);
5.     final boolean isTransitionForward = r.isTransitionForward();
6.     final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
7.     // 添加callback
8.     clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
9.                     System.identityHashCode(r), r.info,                 
10.                     mergedConfiguration.getGlobalConfiguration(),
11.                     mergedConfiguration.getOverrideConfiguration(), r.compat,
12.                     r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
13.                     proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
14.                     results, newIntents, r.takeOptions(), isTransitionForward,
15.                     proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
16.                     r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken));
18.     // 设置Activity启动后的生命周期状态
19.     final ActivityLifecycleItem lifecycleItem;
20.     if (andResume) {
21.         // RESUME状态
22.         lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
23.     } else {
24.         // PAUSE状态
25.         lifecycleItem = PauseActivityItem.obtain();
26.     }
27.     // 设置状态
28.     clientTransaction.setLifecycleStateRequest(lifecycleItem);
30.     // 开启事务，最终调用ClientLifecycleManager#scheduleTransaction()
31.     mService.getLifecycleManager().scheduleTransaction(clientTransaction);                        
32.    
33.     return true;
34. }

复制代码

说明：

• mService 是 ActivityTaskManagerService 实例。
  
• mService.getLifecycleManager() 获取 ClientLifecycleManager 对象。
  
• AMS 向 app历程（ApplicationThread）发送 scheduleTransaction。
  

ClientLifecycleManager#scheduleTransaction()

1. // 启动Activity的事务
2. void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
3.     final IApplicationThread client = transaction.getClient();
4.     // 调用ClientTransaction#schedule()
5.     transaction.schedule();
6. }

复制代码

ClientTransaction#schedule()

1. public void schedule() throws RemoteException {
2.     // 调用ApplicationThread#scheduleTransaction()
3.     mClient.scheduleTransaction(this);
4. }

复制代码

说明：mClient 是 IApplicationThread 实例。
ApplicationThread#scheduleTransaction()

1. @Override
2. public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
3.     // 最终调用ClientTransactionHandler#scheduleTransaction()
4.     ActivityThread.this.scheduleTransaction(transaction);
5. }

复制代码

ClientTransactionHandler#scheduleTransaction()

1. void scheduleTransaction(ClientTransaction transaction) {
2.     transaction.preExecute(this);
3.     // 发送消息，在H类中接收消息
4.     sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
5. }

复制代码

说明：

• ClientTransactionHandler 是一个抽象类。
  
• ActivityThread 继续自 ClientTransactionHandler 类。
  
• scheduleTransaction() 方法定义在 ClientTransactionHandler 中。
  
• H 是一个 Handler，是 ActivityThread 的内部类。
  
• sendMessage() 是通过 Handler 发送消息。
  

ActivityThread.H#handleMessage()

1. class H extends Handler {
2.     public void handleMessage(Message msg) {
3.         switch (msg.what) {
4.             case EXECUTE_TRANSACTION:
5.                 final ClientTransaction transaction = (ClientTransaction) msg.obj;
6.                 // 执行事务
7.                 mTransactionExecutor.execute(transaction);
8.                 if (isSystem()) {
9.                     transaction.recycle();
10.                 }
11.                 break;
12.         }
13.     }
14. }

复制代码

说明：

• Handler 吸收消息，并执行事件。
  
• mTransactionExecutor 是 TransactionExecutor 实例。
  

TransactionExecutor#execute()

1. public void execute(ClientTransaction transaction) {
2.     // 调用TransactionExecutor#executeCallbacks()
3.     executeCallbacks(transaction);
4.     // 执行lifecycleState
5.     executeLifecycleState(transaction);
7.     mPendingActions.clear();
8. }

复制代码

说明：

• executeLifecycleState() 处理 Activity 的生命周期状态。
  

TransactionExecutor#executeCallbacks()

1. public void executeCallbacks(ClientTransaction transaction) {
2.     final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
3.     final IBinder token = transaction.getActivityToken();
4.     ActivityClientRecord r = mTransactionHandler.getActivityClient(token);     
5.     final int size = callbacks.size();
6.     for (int i = 0; i < size; ++i) {
7.         if (postExecutionState != UNDEFINED && r != null) {
8.             final boolean shouldExcludeLastTransition =
9.                                 i == lastCallbackRequestingState && finalState == postExecutionState;
10.             cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
11.         }
12.     }
13. }

复制代码

TransactionExecutor#cycleToPath()

1. private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
2.         ClientTransaction transaction) {
3.     // 获取当前Activity生命周期状态
4.     final int start = r.getLifecycleState();
5.     // 获取需要执行的生命周期数组
6.     final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
7.     // 按顺序执行Activity的生命周期
8.     performLifecycleSequence(r, path, transaction);
9. }

复制代码

TransactionExecutor#executeLifecycleState()

1. private void executeLifecycleState(ClientTransaction transaction) {
2.     final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
3.     if (lifecycleItem == null) {
4.         return;
5.     }
7.     final IBinder token = transaction.getActivityToken();
8.     final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);   
10.     if (r == null) {
11.         return;
12.     }
14.     // 调用cycleToPath()
15.     cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
17.     lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
18.     lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
19. }

复制代码

TransactionExecutor#performLifecycleSequence()

1. private void performLifecycleSequence(ActivityClientRecord r, IntArray path, ClientTransaction transaction){
2.     final int size = path.size();
3.     // 遍历生命周期数组
4.     for (int i = 0, state; i < size; i++) {
5.         state = path.get(i);
6.         switch (state) {
7.             case ON_CREATE:
8.                 // 调用ClientTransactionHandler#handleLaunchActivity()，这是个抽象类抽象方法
9.                 // 最终调用ActivityThread#handleLaunchActivity()
10.                 mTransactionHandler.handleLaunchActivity(r, mPendingActions,
11.                         null /* customIntent */);
12.                 break;
13.             case ON_START:
14.                 mTransactionHandler.handleStartActivity(r, mPendingActions,
15.                         null /* activityOptions */);
16.                 break;
17.             case ON_RESUME:
18.                 mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
19.                         r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
20.                 break;
21.             case ON_PAUSE:
22.                 mTransactionHandler.handlePauseActivity(r, false /* finished */,
23.                         false /* userLeaving */, 0 /* configChanges */, mPendingActions,
24.                         "LIFECYCLER_PAUSE_ACTIVITY");
25.                 break;
26.             case ON_STOP:
27.                 mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
28.                         mPendingActions, false /* finalStateRequest */,
29.                         "LIFECYCLER_STOP_ACTIVITY");
30.                 break;
31.             case ON_DESTROY:
32.                 mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
33.                         0 /* configChanges */, false /* getNonConfigInstance */,
34.                         "performLifecycleSequence. cycling to:" + path.get(size - 1));
35.                 break;
36.             case ON_RESTART:
37.                 mTransactionHandler.performRestartActivity(r, false /* start */);
38.                 break;
39.             default:
40.                 throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
41.         }
42.     }
43. }

复制代码

说明：

• 遍历生命周期数组，如果生命周期数组只有 ON_START 和 ON_RESUME，那么先后执行 handleStartActivity() 和 handleResumeActivity()。
  

ClientTransactionHandler#handleLaunchActivity()

1. public abstract class ClientTransactionHandler {
2.     public abstract Activity handleLaunchActivity(@NonNull ActivityClientRecord r,
3.                         PendingTransactionActions pendingActions, Intent customIntent);
4. }

复制代码

说明：

• ClientTransactionHandler 是一个抽象类，handleLaunchActivity 是一个抽象方法。
  
• ActivityThread 是 ClientTransactionHandler 的子类，直接看 ActivityThread 代码。
  

ActivityThread#handleLaunchActivity()

1. public Activity handleLaunchActivity(ActivityClientRecord r,
2.         PendingTransactionActions pendingActions, Intent customIntent) {  
3.         // 在创建Activity之前初始化
4.     if (ThreadedRenderer.sRendererEnabled
5.             && (r.activityInfo.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
6.         HardwareRenderer.preload();
7.     }
8.     // 获取WMS服务，初始化WindowManager
9.     WindowManagerGlobal.initialize();
10.     // GraphicsEnvironment提示一个activity正在进程上启动
11.     GraphicsEnvironment.hintActivityLaunch();
12.     // 启动Activity，调用ActivityThread#performLaunchActivity()
13.     final Activity a = performLaunchActivity(r, customIntent);
14.     return a;
15. }

复制代码

说明：

• 初始化 WindowManagerGlocal。
  
• 调用 performLaunchActivity() 执行 Activity 的创建流程。
  

ActivityThread#performLaunchActivity()

1. private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {   
3.     ContextImpl appContext = createBaseContextForActivity(r);
4.     Activity activity = null;
6.     java.lang.ClassLoader cl = appContext.getClassLoader();
7.     // 创建Activity
8.     activity = mInstrumentation.newActivity(
9.         cl, component.getClassName(), r.intent);   
11.     // 获取Application实例
12.     Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation);
14.     // Activity与Context建立关联
15.     activity.attach(appContext, this, getInstrumentation(), r.token,
16.                     r.ident, app, r.intent, r.activityInfo, title, r.parent,
17.                     r.embeddedID, r.lastNonConfigurationInstances, config,
18.                     r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
19.                     r.assistToken, r.shareableActivityToken);
21.     // 执行Activity的create流程，包含Activity#onCreate()回调
22.     if (r.isPersistable()) {
23.         mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
24.     } else {
25.         mInstrumentation.callActivityOnCreate(activity, r.state);
26.     }
28.     return activity;
29. }

复制代码

说明：

• mInstrumentation 是 Instrumentation 实例。
  
• 通过 Instrumentation 类创建 Activity 实例。
  
• 接着执行 Activity 的生命周期。
  

Instrumentation#newActivity()

1. public Activity newActivity(ClassLoader cl, String className,
2.         Intent intent)
3.         throws InstantiationException, IllegalAccessException,
4.         ClassNotFoundException {
5.     String pkg = intent != null && intent.getComponent() != null
6.             ? intent.getComponent().getPackageName() : null;
7.     return getFactory(pkg).instantiateActivity(cl, className, intent);
8. }
10. private AppComponentFactory getFactory(String pkg) {
11.     if (pkg == null) {
12.         return AppComponentFactory.DEFAULT;
13.     }
14.     if (mThread == null) {
15.         return AppComponentFactory.DEFAULT;
16.     }
17.     LoadedApk apk = mThread.peekPackageInfo(pkg, true);
18.     if (apk == null) apk = mThread.getSystemContext().mPackageInfo;
19.     return apk.getAppFactory();
20. }
22. public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className, @Nullable Intent intent)
23.         throws InstantiationException, IllegalAccessException, ClassNotFoundException {
24.     return (Activity) cl.loadClass(className).newInstance();
25. }

复制代码

说明：

• 调用 newActivity()，通过反射创建 Activity 实例。
  

Activity#attach()

1. final void attach(Context context, ActivityThread aThread,
2.         Instrumentation instr, IBinder token, int ident,
3.         Application application, Intent intent, ActivityInfo info,
4.         CharSequence title, Activity parent, String id,
5.         NonConfigurationInstances lastNonConfigurationInstances,
6.         Configuration config, String referrer, IVoiceInteractor voiceInteractor,
7.         Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken,
8.         IBinder shareableActivityToken) {
9.     attachBaseContext(context);
11.     mFragments.attachHost(null /*parent*/);
13.     // 创建PhoneWindow实例
14.     mWindow = new PhoneWindow(this, window, activityConfigCallback);
15.     mWindow.setWindowControllerCallback(mWindowControllerCallback);
16.         // 将Activity传入PhoneWindow
17.     mWindow.setCallback(this);
18.     mWindow.setOnWindowDismissedCallback(this);
19.     mWindow.getLayoutInflater().setPrivateFactory(this);
20.         // PhoneWindow关联WindowManager
21.     mWindow.setWindowManager(
22.             (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
23.             mToken, mComponent.flattenToString(),
24.             (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
25.     if (mParent != null) {
26.         mWindow.setContainer(mParent.getWindow());
27.     }
28.     // 让Activity持有WindowManager
29.     mWindowManager = mWindow.getWindowManager();
30.     mCurrentConfig = config;
32.     mWindow.setColorMode(info.colorMode);
33.     mWindow.setPreferMinimalPostProcessing(
34.             (info.flags & ActivityInfo.FLAG_PREFER_MINIMAL_POST_PROCESSING) != 0);
36.     getAutofillClientController().onActivityAttached(application);
37.     setContentCaptureOptions(application.getContentCaptureOptions());
38. }

复制代码

Instrumentation#callActivityOnCreate()

1. public void callActivityOnCreate(Activity activity, Bundle icicle) {
2.     prePerformCreate(activity);
3.     // 调用Activity#performCreate()
4.     activity.performCreate(icicle);
5.     postPerformCreate(activity);
6. }

复制代码

说明：

• Activity 执行create流程。
  
• 接着调用 performCreate()。
  

Activity#performCreate()

1. final void performCreate(Bundle icicle) {
2.   performCreate(icicle, null);
3. }
5. final void performCreate(Bundle icicle, PersistableBundle persistentState) {   
6.   // 回调Activity#onCreate()
7.   if (persistentState != null) {
8.     onCreate(icicle, persistentState);
9.   } else {
10.     onCreate(icicle);
11.   }
12.   // Fragment分发生命周期
13.   mFragments.dispatchActivityCreated();
14. }

复制代码

说明：

• 到此 Activity 已经被创建并启动。
  
• 执行了 onCreate() 方法，
  
• 在 onCreate() 中可以通过 setContentView() 设置布局。
  

ActivityThread#handleStartActivity()

1. public void handleStartActivity(ActivityClientRecord r,
2.         PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
3.     final Activity activity = r.activity;
4.     if (!r.stopped) {
5.         throw new IllegalStateException("Can't start activity that is not stopped.");
6.     }
7.         // 如果Activity被finish直接return
8.     if (r.activity.mFinished) {
9.         return;
10.     }
12.     unscheduleGcIdler();
13.     if (activityOptions != null) {
14.         activity.mPendingOptions = activityOptions;
15.     }
17.     // 调用Activity#performStart()
18.     activity.performStart("handleStartActivity");
19.     // 生命周期状态设置为ON_START
20.     r.setState(ON_START);
22.     // 最终会调用Activity#onRestoreInstanceState()
23.     if (pendingActions.shouldRestoreInstanceState()) {
24.         if (r.isPersistable()) {
25.             if (r.state != null || r.persistentState != null) {
26.                 mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
27.                         r.persistentState);
28.             }
29.         } else if (r.state != null) {
30.             mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
31.         }
32.     }
34.     // 可见状态
35.     updateVisibility(r, true);
36.     mSomeActivitiesChanged = true;
37. }

复制代码

说明：

• 调用 performStart()，最终会调用 Activity#onStart()。
  
• 将生命周期状态设置为 ON_START。
  
• 最终调用 Activity#onRestoreInstanceState()。
  

ActivityThread#handleResumeActivity()

1. public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
2.                                  boolean isForward, String reason) {
3.     unscheduleGcIdler();
4.     mSomeActivitiesChanged = true;
6.     // 如果是resume状态则直接return
7.     if (!performResumeActivity(r, finalStateRequest, reason)) {
8.         return;
9.     }
11.     final Activity a = r.activity;
13.     final int forwardBit = isForward
14.         ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
16.     boolean willBeVisible = !a.mStartedActivity;
17.     if (!willBeVisible) {
18.         willBeVisible = ActivityClient.getInstance().willActivityBeVisible(
19.             a.getActivityToken());
20.     }
21.     if (r.window == null && !a.mFinished && willBeVisible) {
22.         // 获取PhoneWindow
23.         r.window = r.activity.getWindow();
24.         // 获取DecorView
25.         View decor = r.window.getDecorView();
26.         // DecorView设置为不可见
27.         decor.setVisibility(View.INVISIBLE);
28.         // 获取WindowManager
29.         ViewManager wm = a.getWindowManager();
30.         WindowManager.LayoutParams l = r.window.getAttributes();
31.         a.mDecor = decor;
32.         l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
33.         l.softInputMode |= forwardBit;
34.         if (r.mPreserveWindow) {
35.             a.mWindowAdded = true;
36.             r.mPreserveWindow = false;
37.             ViewRootImpl impl = decor.getViewRootImpl();
38.             if (impl != null) {
39.                 impl.notifyChildRebuilt();
40.             }
41.         }
42.         if (a.mVisibleFromClient) {
43.             if (!a.mWindowAdded) {
44.                 a.mWindowAdded = true;
45.                 // 将DecorView添加到Window中
46.                 wm.addView(decor, l);
47.             } else {
48.                 a.onWindowAttributesChanged(l);
49.             }
50.         }
51.     }
52. }

复制代码

说明：

• 调用 performResumeActivity()，最终会执行 Activity#onResume()。
  
• 将 DecorView 添加到窗口中，最终显示布局。
  

ActivityThread#performResumeActivity()

1. public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
2.                                      String reason) {
3.     // 如果Activity是finish状态，则直接return false
4.     if (r.activity.mFinished) {
5.         return false;
6.     }
7.     // 如果Activity是ON_RESUME状态，则直接return false
8.     if (r.getLifecycleState() == ON_RESUME) {
9.         return false;
10.     }
11.     try {
12.         // 最终会调用onResume()
13.         r.activity.performResume(r.startsNotResumed, reason)
14.         r.state = null;
15.         r.persistentState = null;
16.         // 设置Activity到状态为ON_RESUME
17.         r.setState(ON_RESUME);
18.         reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");
19.     } catch (Exception e) {
20.     }
21.     return true;
22. }

复制代码

说明：

• 检查 Activity 到状态。
  
• 最终会执行 onResume()。
  

情况二：历程未启动

ActivityTaskManagerService#startProcessAsync()

1. void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop, String hostingType) {
2.     try {
3.         // 发布消息以启动进程，以避免在ATMS锁保持的情况下调用AMS可能出现死锁。
4.         // 调用ActivityManagerInternal#startProcess()，这是一个抽象类
5.         final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
6.                 mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
7.                 isTop, hostingType, activity.intent.getComponent());
8.         mH.sendMessage(m);
9.     } finally {        
10.     }
11. }

复制代码

说明：启动App历程。
ActivityManagerInternal#startProcess()

1. public abstract class ActivityManagerInternal {
2.     public abstract void startProcess(String processName, ApplicationInfo info,
3.                                       boolean knownToBeDead, boolean isTop, String hostingType,                                                                                                         ComponentName hostingName);
4. }

复制代码

说明：

• ActivityManagerInternal 是抽象类。
  
• 子类是 ActivityManagerService.LocalService。
  

ActivityManagerService.LocalService#startProcess()

1. public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
2.         boolean isTop, String hostingType, ComponentName hostingName) {
3.     try {
4.         synchronized (ActivityManagerService.this) {
5.             // 开启一个新进程
6.             // 调用ActivityManagerService#startProcessLocked()
7.             startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
8.                     new HostingRecord(hostingType, hostingName, isTop),
9.                     ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
10.                     false /* isolated */);
11.         }
12.     } finally {   
13.     }
14. }

复制代码

ActivityManagerService#startProcessLocked()

1. final ProcessRecord startProcessLocked(String processName,
2.         ApplicationInfo info, boolean knownToBeDead, int intentFlags,
3.         HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
4.         boolean isolated) {
5.     return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
6.             hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
7.             false /* isSdkSandbox */, 0 /* sdkSandboxClientAppUid */,
8.             null /* sdkSandboxClientAppPackage */,
9.             null /* ABI override */, null /* entryPoint */,
10.             null /* entryPointArgs */, null /* crashHandler */);
11. }

复制代码

ProcessList#startProcessLocked()

1. @GuardedBy("mService")
2. ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
3.         boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
4.         int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
5.         boolean isSdkSandbox, int sdkSandboxUid, String sdkSandboxClientAppPackage,
6.         String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
7.    
8.     final boolean success =
9.         startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
10.     return success ? app : null;
11. }

复制代码

1. boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
2.         int zygotePolicyFlags, String abiOverride) {
3.     return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
4.             false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
5.             abiOverride);
6. }

复制代码

1. boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
2.         int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
3.         String abiOverride) {
4.     return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
5.                 runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
6.                 instructionSet, invokeWith, startUptime, startElapsedTime);
7. }

复制代码

1. boolean startProcessLocked(HostingRecord hostingRecord, String entryPoint, ProcessRecord app,
2.         int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags, int mountExternal,
3.         String seInfo, String requiredAbi, String instructionSet, String invokeWith,
4.         long startUptime, long startElapsedTime) {
5.     // 调用ProcessList#startProcess()
6.     final Process.ProcessStartResult startResult = startProcess(hostingRecord,
7.                     entryPoint, app,
8.                     uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
9.                     requiredAbi, instructionSet, invokeWith, startUptime);
10.     handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
11.                     startSeq, false);
12. }

复制代码

ProcessList#startProcess()

1. private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
2.         ProcessRecord app, int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags,
3.         int mountExternal, String seInfo, String requiredAbi, String instructionSet,
4.         String invokeWith, long startTime) {
5.     try {      
6.         final Process.ProcessStartResult startResult;
7.         boolean regularZygote = false;
8.         if (hostingRecord.usesWebviewZygote()) {
9.             // 从WebView Zygote中产生
10.             startResult = startWebView(entryPoint,
11.                     app.processName, uid, uid, gids, runtimeFlags, mountExternal,
12.                     app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
13.                     app.info.dataDir, null, app.info.packageName,
14.                     app.getDisabledCompatChanges(),
15.                     new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
16.         } else if (hostingRecord.usesAppZygote()) {
17.             // 从Zygote进程中生成
18.             final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
19.             // 调用ZygoteProcess#start()
20.             startResult = appZygote.getProcess().start(entryPoint,
21.                     app.processName, uid, uid, gids, runtimeFlags, mountExternal,
22.                     app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
23.                     app.info.dataDir, null, app.info.packageName,
24.                     /*zygotePolicyFlags=*/ ZYGOTE_POLICY_FLAG_EMPTY, isTopApp,
25.                     app.getDisabledCompatChanges(), pkgDataInfoMap, allowlistedAppDataInfoMap,
26.                     false, false,
27.                     new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
28.         } else {
29.             regularZygote = true;
30.             startResult = Process.start(entryPoint,
31.                     app.processName, uid, uid, gids, runtimeFlags, mountExternal,
32.                     app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
33.                     app.info.dataDir, invokeWith, app.info.packageName, zygotePolicyFlags,
34.                     isTopApp, app.getDisabledCompatChanges(), pkgDataInfoMap,
35.                     allowlistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
36.                     new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});
37.         }
38.         return startResult;
39.     }
40. }

复制代码

ZygoteProcess#start()

1. public final Process.ProcessStartResult start(@NonNull final String processClass,
2.                                               final String niceName,
3.                                               int uid, int gid, @Nullable int[] gids,
4.                                               int runtimeFlags, int mountExternal,
5.                                               int targetSdkVersion,
6.                                               @Nullable String seInfo,
7.                                               @NonNull String abi,
8.                                               @Nullable String instructionSet,
9.                                               @Nullable String appDataDir,
10.                                               @Nullable String invokeWith,
11.                                               @Nullable String packageName,
12.                                               int zygotePolicyFlags,
13.                                               boolean isTopApp,
14.                                               @Nullable long[] disabledCompatChanges,
15.                                               @Nullable Map<String, Pair<String, Long>>
16.                                                       pkgDataInfoMap,
17.                                               @Nullable Map<String, Pair<String, Long>>
18.                                                       allowlistedDataInfoList,
19.                                               boolean bindMountAppsData,
20.                                               boolean bindMountAppStorageDirs,
21.                                               @Nullable String[] zygoteArgs) {
22.      return startViaZygote(processClass, niceName, uid, gid, gids,
23.                 runtimeFlags, mountExternal, targetSdkVersion, seInfo,
24.                 abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
25.                 packageName, zygotePolicyFlags, isTopApp, disabledCompatChanges,
26.                 pkgDataInfoMap, allowlistedDataInfoList, bindMountAppsData,
27.                 bindMountAppStorageDirs, zygoteArgs);
28. }

复制代码

ZygoteProcess#startViaZygote()

1. private Process.ProcessStartResult startViaZygote(@NonNull final String processClass,
2.                                                   @Nullable final String niceName,
3.                                                   final int uid, final int gid,
4.                                                   @Nullable final int[] gids,
5.                                                   int runtimeFlags, int mountExternal,
6.                                                   int targetSdkVersion,
7.                                                   @Nullable String seInfo,
8.                                                   @NonNull String abi,
9.                                                   @Nullable String instructionSet,
10.                                                   @Nullable String appDataDir,
11.                                                   @Nullable String invokeWith,
12.                                                   boolean startChildZygote,
13.                                                   @Nullable String packageName,
14.                                                   int zygotePolicyFlags,
15.                                                   boolean isTopApp,
16.                                                   @Nullable long[] disabledCompatChanges,
17.                                                   @Nullable Map<String, Pair<String, Long>>
18.                                                           pkgDataInfoMap,
19.                                                   @Nullable Map<String, Pair<String, Long>>
20.                                                           allowlistedDataInfoList,
21.                                                   boolean bindMountAppsData,
22.                                                   boolean bindMountAppStorageDirs,
23.                                                   @Nullable String[] extraArgs)
24.                                                   throws ZygoteStartFailedEx {
26.     synchronized(mLock) {
27.         // 依次调用ZygoteProcess#openZygoteSocketIfNeeded()
28.         // -> ZygoteProcess#zygoteSendArgsAndGetResult()
29.         return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
30.                                           zygotePolicyFlags,
31.                                           argsForZygote);
32.     }
33. }

复制代码

说明：

• openZygoteSocketIfNeeded()：尝试打开 Socket。
  
• zygoteSendArgsAndGetResult()：发送消息。
  

ZygoteProcess#zygoteSendArgsAndGetResult()

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

复制代码

ZygoteProcess#attemptZygoteSendArgsAndGetResult()

1. private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
2.         ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
3.     try {
4.         final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
5.         final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
6.         zygoteWriter.write(msgStr);
7.         zygoteWriter.flush();
8.         Process.ProcessStartResult result = new Process.ProcessStartResult();
9.         result.pid = zygoteInputStream.readInt();
10.         result.usingWrapper = zygoteInputStream.readBoolean();
11.         if (result.pid < 0) {
12.             throw new ZygoteStartFailedEx("fork() failed");
13.         }
14.         return result;
15.     } catch (IOException ex) {
16.         zygoteState.close();
17.         throw new ZygoteStartFailedEx(ex);
18.     }
19. }

复制代码

说明：

• 通过 Scoket 方式调用 Zygote 历程。
  

ZygoteInit#main()

1. public static void main(String[] argv){
2.     caller = zygoteServer.runSelectLoop(abiList);
3.     if (caller != null) {
4.         caller.run();
5.     }
6. }

复制代码

说明：

• 从 Zygote 历程中fork出新App历程。
  

ZygoteServer#runSelectLoop()

1. Runnable runSelectLoop(String abiList) {
2.     ZygoteConnection connection = peers.get(pollIndex);
3.     final Runnable command = connection.processOneCommand(this)
4. }

复制代码

说明；

• 运行 Zygote 历程，fork 出子历程。
  

ZygoteConnection#processCommand()

1. Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) {
2.     // fork操作
3.     if (parsedArgs.mInvokeWith != null || parsedArgs.mStartChildZygote
4.         || !multipleOK || peer.getUid() != Process.SYSTEM_UID) {
5.         // 调用Zygote#forkAndSpecialize()
6.         pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid,
7.                                        parsedArgs.mGids, parsedArgs.mRuntimeFlags, rlimits,
8.                                        parsedArgs.mMountExternal, parsedArgs.mSeInfo, parsedArgs.mNiceName,
9.                                        fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
10.                                        parsedArgs.mInstructionSet, parsedArgs.mAppDataDir,
11.                                        parsedArgs.mIsTopApp, parsedArgs.mPkgDataInfoList,
12.                                        parsedArgs.mAllowlistedDataInfoList,                                                                                                                                               parsedArgs.mBindMountAppDataDirs,
13.                                        parsedArgs.mBindMountAppStorageDirs);
14.         try {
15.             if (pid == 0) {
16.                 zygoteServer.setForkChild();
17.                 zygoteServer.closeServerSocket();
18.                 IoUtils.closeQuietly(serverPipeFd);
19.                 serverPipeFd = null;
20.                 // 调用ZygoteConnection#handleChildProc()
21.                 return handleChildProc(parsedArgs, childPipeFd,
22.                                        parsedArgs.mStartChildZygote);
23.             } else {
24.                 IoUtils.closeQuietly(childPipeFd);
25.                 childPipeFd = null;               
26.                 handleParentProc(pid, serverPipeFd);
27.                 return null;
28.             }
29.         } finally {
30.             IoUtils.closeQuietly(childPipeFd);
31.             IoUtils.closeQuietly(serverPipeFd);
32.         }
33.     } else {
34.         ZygoteHooks.preFork();
35.         Runnable result = Zygote.forkSimpleApps(argBuffer,
36.                                                 zygoteServer.getZygoteSocketFileDescriptor(),
37.                                                 peer.getUid(), Zygote.minChildUid(peer),                                                                                                                                         parsedArgs.mNiceName);
38.         if (result == null) {
39.             ZygoteHooks.postForkCommon();
40.             continue;
41.         } else {
42.             zygoteServer.setForkChild();
43.             Zygote.setAppProcessName(parsedArgs, TAG);
44.             return result;
45.         }
46.     }
47. }

复制代码

说明：fork出新的App历程。
Zygote#forkAndSpecialize()

1. static int forkAndSpecialize(int uid, int gid, int[] gids, int runtimeFlags,
2.         int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
3.         int[] fdsToIgnore, boolean startChildZygote, String instructionSet, String appDataDir,
4.         boolean isTopApp, String[] pkgDataInfoList, String[] allowlistedDataInfoList,
5.         boolean bindMountAppDataDirs, boolean bindMountAppStorageDirs) {
6.     ZygoteHooks.preFork();
8.     int pid = nativeForkAndSpecialize(
9.             uid, gid, gids, runtimeFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
10.             fdsToIgnore, startChildZygote, instructionSet, appDataDir, isTopApp,
11.             pkgDataInfoList, allowlistedDataInfoList, bindMountAppDataDirs,
12.             bindMountAppStorageDirs);
13.     if (pid == 0) {
14.         // Note that this event ends at the end of handleChildProc,
15.         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "PostFork");
17.         // If no GIDs were specified, don't make any permissions changes based on groups.
18.         if (gids != null && gids.length > 0) {
19.             NetworkUtilsInternal.setAllowNetworkingForProcess(containsInetGid(gids));
20.         }
21.     }
23.     // Set the Java Language thread priority to the default value for new apps.
24.     Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
26.     ZygoteHooks.postForkCommon();
27.     return pid;
28. }

复制代码

ZygoteConnection#handleChildProc()

1. private Runnable handleChildProc(ZygoteArguments parsedArgs,
2.         FileDescriptor pipeFd, boolean isZygote) {
3.     closeSocket();
4.     Zygote.setAppProcessName(parsedArgs, TAG);
5.     // End of the postFork event.
6.     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
7.     if (parsedArgs.mInvokeWith != null) {
8.         WrapperInit.execApplication(parsedArgs.mInvokeWith,
9.                 parsedArgs.mNiceName, parsedArgs.mTargetSdkVersion,
10.                 VMRuntime.getCurrentInstructionSet(),
11.                 pipeFd, parsedArgs.mRemainingArgs);
12.         throw new IllegalStateException("WrapperInit.execApplication unexpectedly returned");
13.     } else {
14.         if (!isZygote) {
15.             return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
16.                     parsedArgs.mDisabledCompatChanges,
17.                     parsedArgs.mRemainingArgs, null /* classLoader */);
18.         } else {
19.             // 调用ZygoteInit#childZygoteInit()
20.             return ZygoteInit.childZygoteInit(
21.                     parsedArgs.mRemainingArgs  /* classLoader */);
22.         }
23.     }
24. }

复制代码

ZygoteInit#childZygoteInit()

1. static Runnable childZygoteInit(String[] argv) {
2.     RuntimeInit.Arguments args = new RuntimeInit.Arguments(argv);
3.     return RuntimeInit.findStaticMain(args.startClass, args.startArgs, /* classLoader= */null);
4. }

复制代码

RuntimeInit#findStaticMain()

1. protected static Runnable findStaticMain(String className, String[] argv,
2.         ClassLoader classLoader) {
3.     Class<?> cl;
5.     try {
6.         cl = Class.forName(className, true, classLoader);
7.     } catch (ClassNotFoundException ex) {
8.         throw new RuntimeException(
9.                 "Missing class when invoking static main " + className,
10.                 ex);
11.     }
13.     Method m;
14.     try {
15.         // 通过反射获取main方法
16.         m = cl.getMethod("main", new Class[] { String[].class });
17.     }
19.     int modifiers = m.getModifiers();
20.     if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
21.         throw new RuntimeException(
22.                 "Main method is not public and static on " + className);
23.     }
24.     return new MethodAndArgsCaller(m, argv);
25. }

复制代码

说明：

• 通过反射获取 main() 方法并执行。
  

ActivityThread#main()

1. public static void main(String[] args) {   
2.     Looper.prepareMainLooper();
3.     ActivityThread thread = new ActivityThread();
4.     // 调用ActivityThread#attach()
5.     thread.attach(false, startSeq);
6.     if (sMainThreadHandler == null) {
7.         sMainThreadHandler = thread.getHandler();
8.     }
9.     Looper.loop();
10.     throw new RuntimeException("Main thread loop unexpectedly exited");
11. }

复制代码

ActivityThread#attach()

1. private void attach(boolean system, long startSeq) {
2.     sCurrentActivityThread = this;
3.     mConfigurationController = new ConfigurationController(this);
4.     mSystemThread = system;
5.     if (!system) {
6.         android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
7.                                                 UserHandle.myUserId());
8.         RuntimeInit.setApplicationObject(mAppThread.asBinder());
9.         final IActivityManager mgr = ActivityManager.getService();
10.         try {
11.             // 调用ActivityManagerService#attachApplication()
12.             mgr.attachApplication(mAppThread, startSeq);
13.         } catch (RemoteException ex) {
14.             throw ex.rethrowFromSystemServer();
15.         }
16.       
17.         BinderInternal.addGcWatcher(new Runnable() {
18.             @Override public void run() {
19.                 if (!mSomeActivitiesChanged) {
20.                     return;
21.                 }
22.                 Runtime runtime = Runtime.getRuntime();
23.                 long dalvikMax = runtime.maxMemory();
24.                 long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
25.                 if (dalvikUsed > ((3*dalvikMax)/4)) {
26.                     if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
27.                                                   + " total=" + (runtime.totalMemory()/1024)
28.                                                   + " used=" + (dalvikUsed/1024));
29.                     mSomeActivitiesChanged = false;
30.                     try {
31.                         ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
32.                     } catch (RemoteException e) {
33.                         throw e.rethrowFromSystemServer();
34.                     }
35.                 }
36.             }
37.         });
38.     } else {
39.         android.ddm.DdmHandleAppName.setAppName("system_process",
40.                                                 UserHandle.myUserId());
41.         try {
42.             mInstrumentation = new Instrumentation();
43.             mInstrumentation.basicInit(this);
44.             ContextImpl context = ContextImpl.createAppContext(
45.                 this, getSystemContext().mPackageInfo);
46.             mInitialApplication = context.mPackageInfo.makeApplicationInner(true, null);
47.             mInitialApplication.onCreate();
48.         } catch (Exception e) {
49.          
50.         }
51.     }
53.     ViewRootImpl.addConfigCallback(configChangedCallback);
54. }

复制代码

说明：

• 调用 ActivityManagerService#attachApplication() 向 AMS 通知历程已经启动。
  

ActivityManagerService#attachApplication()

1. public final void attachApplication(IApplicationThread thread, long startSeq) {
2.     if (thread == null) {
3.         throw new SecurityException("Invalid application interface");
4.     }
5.     synchronized (this) {
6.         int callingPid = Binder.getCallingPid();
7.         final int callingUid = Binder.getCallingUid();
8.         final long origId = Binder.clearCallingIdentity();
9.         // 调用ActivityManagerService#attachApplicationLocked()
10.         attachApplicationLocked(thread, callingPid, callingUid, startSeq);
11.         Binder.restoreCallingIdentity(origId);
12.     }
13. }

复制代码

ActivityManagerService#attachApplicationLocked()

1. private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
2.                                         int pid, int callingUid, long startSeq) {
3.     synchronized (mProcLock) {
4.         app.mState.setCurAdj(ProcessList.INVALID_ADJ);
5.         app.mState.setSetAdj(ProcessList.INVALID_ADJ);
6.         app.mState.setVerifiedAdj(ProcessList.INVALID_ADJ);
7.         mOomAdjuster.setAttachingSchedGroupLSP(app);
8.         app.mState.setForcingToImportant(null);
9.         updateProcessForegroundLocked(app, false, 0, false);
10.         app.mState.setHasShownUi(false);
11.         app.mState.setCached(false);
12.         app.setDebugging(false);
13.         app.setKilledByAm(false);
14.         app.setKilled(false);
15.         app.setUnlocked(StorageManager.isUserKeyUnlocked(app.userId));
16.     }
17.     // 移除进程超时信息
18.     mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
20.     final ProviderInfoList providerList = ProviderInfoList.fromList(providers);
21.     if (app.getIsolatedEntryPoint() != null) {
22.         thread.runIsolatedEntryPoint(
23.             app.getIsolatedEntryPoint(), app.getIsolatedEntryPointArgs());
24.     } else if (instr2 != null) {
25.         thread.bindApplication(processName, appInfo,
26.                                app.sdkSandboxClientAppVolumeUuid, app.sdkSandboxClientAppPackage,
27.                                providerList,
28.                                instr2.mClass,
29.                                profilerInfo, instr2.mArguments,
30.                                instr2.mWatcher,
31.                                instr2.mUiAutomationConnection, testMode,
32.                                mBinderTransactionTrackingEnabled, enableTrackAllocation,
33.                                isRestrictedBackupMode || !normalMode, app.isPersistent(),
34.                                new Configuration(app.getWindowProcessController().getConfiguration()),
35.                                app.getCompat(), getCommonServicesLocked(app.isolated),
36.                                mCoreSettingsObserver.getCoreSettingsLocked(),
37.                                buildSerial, autofillOptions, contentCaptureOptions,
38.                                app.getDisabledCompatChanges(), serializedSystemFontMap,
39.                                app.getStartElapsedTime(), app.getStartUptime());
40.     } else {
41.         thread.bindApplication(processName, appInfo,
42.                                app.sdkSandboxClientAppVolumeUuid, app.sdkSandboxClientAppPackage,
43.                                providerList, null, profilerInfo, null, null, null, testMode,
44.                                mBinderTransactionTrackingEnabled, enableTrackAllocation,
45.                                isRestrictedBackupMode || !normalMode, app.isPersistent(),
46.                                new Configuration(app.getWindowProcessController().getConfiguration()),
47.                                app.getCompat(), getCommonServicesLocked(app.isolated),
48.                                mCoreSettingsObserver.getCoreSettingsLocked(),
49.                                buildSerial, autofillOptions, contentCaptureOptions,
50.                                app.getDisabledCompatChanges(), serializedSystemFontMap,
51.                                app.getStartElapsedTime(), app.getStartUptime());
52.     }
54.     if (normalMode) {
55.         try {
56.             // 最终调用ActivityTaskManagerService.LocalService#attachApplication()
57.             didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
58.         } catch (Exception e) {
59.         }
60.     }
62.     return true;
63. }

复制代码

说明：

• thread 是 ApplicationThread 的实例。
  
• ApplicationThread 是 ActivityThread 的内部类。
  
• mAtmInternal 是 ActivityTaskManagerService.LocalService 的实例。
  

ApplicationThread#bindApplication()

1. public final void bindApplication(String processName, ApplicationInfo appInfo,
2.         String sdkSandboxClientAppVolumeUuid, String sdkSandboxClientAppPackage,
3.         ProviderInfoList providerList, ComponentName instrumentationName,
4.         ProfilerInfo profilerInfo, Bundle instrumentationArgs,
5.         IInstrumentationWatcher instrumentationWatcher,
6.         IUiAutomationConnection instrumentationUiConnection, int debugMode,
7.         boolean enableBinderTracking, boolean trackAllocation,
8.         boolean isRestrictedBackupMode, boolean persistent, Configuration config,
9.         CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
10.         String buildSerial, AutofillOptions autofillOptions,
11.         ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges,
12.         SharedMemory serializedSystemFontMap,
13.         long startRequestedElapsedTime, long startRequestedUptime) {   
15.     AppBindData data = new AppBindData();
16.     data.processName = processName;
17.     data.appInfo = appInfo;
18.     data.sdkSandboxClientAppVolumeUuid = sdkSandboxClientAppVolumeUuid;
19.     data.sdkSandboxClientAppPackage = sdkSandboxClientAppPackage;
20.     data.providers = providerList.getList();
21.     data.instrumentationName = instrumentationName;
22.     data.instrumentationArgs = instrumentationArgs;
23.     data.instrumentationWatcher = instrumentationWatcher;
24.     data.instrumentationUiAutomationConnection = instrumentationUiConnection;
25.     data.debugMode = debugMode;
26.     data.enableBinderTracking = enableBinderTracking;
27.     data.trackAllocation = trackAllocation;
28.     data.restrictedBackupMode = isRestrictedBackupMode;
29.     data.persistent = persistent;
30.     data.config = config;
31.     data.compatInfo = compatInfo;
32.     data.initProfilerInfo = profilerInfo;
33.     data.buildSerial = buildSerial;
34.     data.autofillOptions = autofillOptions;
35.     data.contentCaptureOptions = contentCaptureOptions;
36.     data.disabledCompatChanges = disabledCompatChanges;
37.     data.mSerializedSystemFontMap = serializedSystemFontMap;
38.     data.startRequestedElapsedTime = startRequestedElapsedTime;
39.     data.startRequestedUptime = startRequestedUptime;
40.     sendMessage(H.BIND_APPLICATION, data);
41. }

复制代码

说明：

• 发送 BIND_APPLICATION 消息。
  
• 在 H 类中吸收数据
  

ActivityThread.H#handleMessage()

1. public void handleMessage(Message msg) {
2.     switch (msg.what) {
3.         case BIND_APPLICATION:
4.             AppBindData data = (AppBindData)msg.obj;
5.             handleBindApplication(data);
6.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
7.             break;
8.     }
9. }

复制代码

ActivityThread#handleBindApplication()

1. private void handleBindApplication(AppBindData data) {   
2.     // 初始化context
3.     final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);      
4.     // 初始化Instrumentation
5.     if (ii != null) {
6.         initInstrumentation(ii, data, appContext);
7.     } else {
8.         mInstrumentation = new Instrumentation();
9.         mInstrumentation.basicInit(this);
10.     }   
11.     Application app;
12.     try {
13.         // 初始化Application
14.         // 调用LoadedApk#makeApplicationInner()
15.         app = data.info.makeApplicationInner(data.restrictedBackupMode, null);           
16.         mInstrumentation.onCreate(data.instrumentationArgs);        
17.         // 回调Application#onCreate()
18.         mInstrumentation.callApplicationOnCreate(app);
19.     } finally {
20.     }
21. }

复制代码

说明：

• 初始化 Context。
  
• 初始化 Instrumentation。
  
• 初始化 Application。
  
• 回调 Application#onCreate()。
  

LoadedApk#makeApplicationInner()

1. public Application makeApplicationInner(boolean forceDefaultAppClass,
2.                                         Instrumentation instrumentation) {
3.     return makeApplicationInner(forceDefaultAppClass, instrumentation, false);
4. }
6. private Application makeApplicationInner(boolean forceDefaultAppClass,
7.                                          Instrumentation instrumentation, boolean allowDuplicateInstances) {
8.     if (mApplication != null) {
9.         return mApplication;
10.     }
12.     synchronized (sApplications) {
13.         final Application cached = sApplications.get(mPackageName);
14.         if (cached != null) {
15.             if (!allowDuplicateInstances) {
16.                 mApplication = cached;
17.                 return cached;
18.             }
19.         }
20.     }
22.     Application app = null;
24.     final String myProcessName = Process.myProcessName();
25.     String appClass = mApplicationInfo.getCustomApplicationClassNameForProcess(
26.         myProcessName);
29.     try {
30.         final java.lang.ClassLoader cl = getClassLoader();
31.         if (!mPackageName.equals("android")) {
32.             initializeJavaContextClassLoader();
33.         }
34.         // 初始化Application的上下文
35.         ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
36.         // 创建Application实例
37.         app = mActivityThread.mInstrumentation.newApplication(
38.             cl, appClass, appContext);
39.         appContext.setOuterContext(app);
40.     } catch (Exception e) {
41.     }
42.     mActivityThread.mAllApplications.add(app);
43.     mApplication = app;
44.     if (!allowDuplicateInstances) {
45.         synchronized (sApplications) {
46.             sApplications.put(mPackageName, app);
47.         }
48.     }
50.     if (instrumentation != null) {
51.         try {
52.             // 回调Application#onCreate()
53.             instrumentation.callApplicationOnCreate(app);
54.         } catch (Exception e) {
55.         }
56.     }
57.     return app;
58. }

复制代码

说明：

• 初始化 Application 的上下文。
  
• makeApplicationInner() 表示获取或创建 Application 实例。
  
• 回调 Application 的 onCreate()。
  

Instrumentation#newApplication()

1. public Application newApplication(ClassLoader cl, String className, Context context)
2.         throws InstantiationException, IllegalAccessException,
3.         ClassNotFoundException {
4.     Application app = getFactory(context.getPackageName())
5.             .instantiateApplication(cl, className);
6.     app.attach(context);
7.     return app;
8. }

复制代码

Instrumentation#callApplicationOnCreate()

1. public void callApplicationOnCreate(Application app) {
2.     app.onCreate();
3. }

复制代码

ActivityTaskManagerService.LocalService#attachApplication()

1. public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
2.     synchronized (mGlobalLockWithoutBoost) {
3.         try {
4.             // 调用RootWindowContainer#attachApplication()
5.             // 最终调用AttachApplicationHelper#test()
6.             return mRootWindowContainer.attachApplication(wpc);
7.         } finally {           
8.         }
9.     }
10. }

复制代码

RootWindowContainer.AttachApplicationHelper#test()

1. public boolean test(ActivityRecord r) {
2.     if (r.finishing || !r.showToCurrentUser() || !r.visibleIgnoringKeyguard
3.             || r.app != null || mApp.mUid != r.info.applicationInfo.uid
4.             || !mApp.mName.equals(r.processName)) {
5.         return false;
6.     }
8.     try {
9.         // 调用ActivityTaskSupervisor#realStartActivityLocked()
10.         if (mTaskSupervisor.realStartActivityLocked(r, mApp,
11.                 mTop == r && r.getTask().canBeResumed(r) /* andResume */,
12.                 true /* checkConfig */)) {
13.             mHasActivityStarted = true;
14.         }
15.     } catch (RemoteException e) {
16.     }
17.     return false;
18. }

复制代码

说明：

• 最终调用 ActivityTaskSupervisor#realStartActivityLocked()。
  
• 执行 Activity 的启动流程（情况一，历程已启动流程）。
  

ActivityTaskSupervisor#realStartActivityLocked()

资料

https://blog.csdn.net/ss520k/article/details/129147496
https://blog.csdn.net/ss520k/article/details/129147496
https://juejin.cn/user/1116759543786040/posts
https://juejin.cn/post/7211801284709548093

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。