• Android—ATMS应用启动流程

    应用的启动：Launcher应用点击桌面应用，应用启动。

    frameworks\base\core\java\android\app\Activity.java：

    启动一个Activity我们很熟悉，就是startActivity：

    1.     public void startActivity(Intent intent, @Nullable Bundle options) {
    2.         if (options != null) {
    3.             startActivityForResult(intent, -1, options);
    4.         } else {
    5.             // Note we want to go through this call for compatibility with
    6.             // applications that may have overridden the method.
    7.             startActivityForResult(intent, -1);
    8.         }
    9.     }
    10.  
    11.     public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
    12.         startActivityForResult(intent, requestCode, null);
    13.     }
    14.  
    15.     public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
    16.         ....
    17.             Instrumentation.ActivityResult ar =
    18.                 mInstrumentation.execStartActivity(
    19.                     this, mMainThread.getApplicationThread(), mToken, this,
    20.                     intent, requestCode, options);
    21.         ....
    22.     }

    看execStartActivity方法的参数，mToken是一个IBinder，与mInstrumentation和mMainThread都在调用activity的attach方法时赋的值。

    接下来继续跟进execStartActivity

    1.     public ActivityResult execStartActivity(
    2.             Context who, IBinder contextThread, IBinder token, Activity target,
    3.             Intent intent, int requestCode, Bundle options) {
    4.         ....
    5.         try {
    6.             intent.migrateExtraStreamToClipData();
    7.             intent.prepareToLeaveProcess(who);
    8.             int result = ActivityTaskManager.getService()
    9.                 .startActivity(whoThread, who.getBasePackageName(), intent,
    10.                         intent.resolveTypeIfNeeded(who.getContentResolver()),
    11.                         token, target != null ? target.mEmbeddedID : null,
    12.                         requestCode, 0, null, options);
    13.             checkStartActivityResult(result, intent);
    14.         } catch (RemoteException e) {
    15.             throw new RuntimeException("Failure from system", e);
    16.         }
    17.         return null;
    18.     }

    这里调用了ActivityTaskManager.getService().startActivity()这个方法进行了跳转。

    我们先看ActivityTaskManager.getService()

    1.     public static IActivityTaskManager getService() {
    2.         return IActivityTaskManagerSingleton.get();
    3.     }
    4.  
    5.     public final T get() {
    6.         synchronized (this) {
    7.             if (mInstance == null) {
    8.                 mInstance = create();
    9.             }
    10.             return mInstance;
    11.         }
    12.     }
    13.  
    14.     @UnsupportedAppUsage(trackingBug = 129726065)
    15.     private static final Singleton IActivityTaskManagerSingleton =
    16.             new Singleton() {
    17.                 @Override
    18.                 protected IActivityTaskManager create() {
    19.                     final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
    20.                     return IActivityTaskManager.Stub.asInterface(b);
    21.                 }
    22.             };

    ActivityTaskManager.getService()中先用ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE)获取了IBinder对象，按照之前分析Binder，我们知道这里可能是一个BPBinder。

    然后我们将这个BPBinder再转化为IActivityTaskManager接口对象。

    我们可以继续看下ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);

    1.     public static IBinder getService(String name) {
    2.         try {
    3.             IBinder service = sCache.get(name);
    4.             if (service != null) {
    5.                 return service;
    6.             } else {
    7.                 return Binder.allowBlocking(rawGetService(name));
    8.             }
    9.         } catch (RemoteException e) {
    10.             Log.e(TAG, "error in getService", e);
    11.         }
    12.         return null;
    13.     }
    14.  
    15.     private static IBinder rawGetService(String name) throws RemoteException {
    16.         final IBinder binder = getIServiceManager().getService(name);
    17.         ....
    18.         return binder;
    19.     }
    20.  
    21.     private static IServiceManager getIServiceManager() {
    22.         if (sServiceManager != null) {
    23.             return sServiceManager;
    24.         }
    25.  
    26.         // Find the service manager
    27.         sServiceManager = ServiceManagerNative
    28.                 .asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
    29.         return sServiceManager;
    30.     }
    31.

    getIServiceManager()我们之前分析过了，就是获取ServiceManagerProxy，ServiceManagerProxy是用BinderProxy封装成的，BinderProxy里面有Native的BPBinder的弱引用对象，所以ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);最后就是向BnServiceManager获取到该服务对象。

    回到ActivityTaskManager.getService(Context.ACTIVITY_TASK_SERVICE).startActivity()

    现在我们知道了ActivityTaskManager.getService(Context.ACTIVITY_TASK_SERVICE)是获取IActivityTaskManager对应的服务，那么我们应该怎么找到对应的服务实体？

    我们全局找一下ACTIVITY_TASK_SERVICE或者IActivityTaskManager.Stub

    frameworks\base\services\core\java\com\android\server\wm\ActivityTaskManagerService.java：

    1.     public class ActivityTaskManagerService extends IActivityTaskManager.Stub   
    2.  
    3.     public static final class Lifecycle extends SystemService {
    4.         private final ActivityTaskManagerService mService;
    5.  
    6.         public Lifecycle(Context context) {
    7.             super(context);
    8.             mService = new ActivityTaskManagerService(context);
    9.         }
    10.  
    11.         @Override
    12.         public void onStart() {
    13.             publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
    14.             mService.start();
    15.         }
    16.         ....
    17.     }

    找到了一块熟悉的代码，Lifecycle是ATMS的内部类，这里我们之前分析过，publishBinderService就是向ServiceManager添加该服务，因为ATMS使用了AIDL，所以onTransact方法在ATMS的Stub类里面，我们这里直接看ATMS的startActivity方法

    1.     public final int startActivity(IApplicationThread caller, String callingPackage,
    2.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
    3.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    4.         return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
    5.                 resultWho, requestCode, startFlags, profilerInfo, bOptions,
    6.                 UserHandle.getCallingUserId());
    7.     }
    8.  
    9.     @Override
    10.     public int startActivityAsUser(IApplicationThread caller, String callingPackage,
    11.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
    12.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    13.         return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
    14.                 resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
    15.                 true /*validateIncomingUser*/);
    16.     }
    17.  
    18.     int startActivityAsUser(IApplicationThread caller, String callingPackage,
    19.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
    20.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
    21.             boolean validateIncomingUser) {
    22.         enforceNotIsolatedCaller("startActivityAsUser");
    23.  
    24.         userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
    25.                 Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
    26.  
    27.         // TODO: Switch to user app stacks here.
    28.         return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
    29.                 .setCaller(caller)
    30.                 .setCallingPackage(callingPackage)
    31.                 .setResolvedType(resolvedType)
    32.                 .setResultTo(resultTo)
    33.                 .setResultWho(resultWho)
    34.                 .setRequestCode(requestCode)
    35.                 .setStartFlags(startFlags)
    36.                 .setProfilerInfo(profilerInfo)
    37.                 .setActivityOptions(bOptions)
    38.                 .setMayWait(userId)
    39.                 .execute();
    40.  
    41.     }

    obtainStarter返回的是ActivityStarter对象，这里set了很多参数最后执行execute方法，这里注意调用setMayWait。

    1.     ActivityStarter setMayWait(int userId) {
    2.         mRequest.mayWait = true;
    3.         mRequest.userId = userId;
    4.  
    5.         return this;
    6.     }
    7.     
    8.     int execute() {
    9.         try {
    10.             // TODO(b/64750076): Look into passing request directly to these methods to allow
    11.             // for transactional diffs and preprocessing.
    12.             if (mRequest.mayWait) {
    13.                 return startActivityMayWait(mRequest.caller, mRequest.callingUid,
    14.                         mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
    15.                         mRequest.intent, mRequest.resolvedType,
    16.                         mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
    17.                         mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
    18.                         mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
    19.                         mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
    20.                         mRequest.inTask, mRequest.reason,
    21.                         mRequest.allowPendingRemoteAnimationRegistryLookup,
    22.                         mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
    23.             } else {
    24.                 return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
    25.                         mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
    26.                         mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
    27.                         mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
    28.                         mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
    29.                         mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
    30.                         mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
    31.                         mRequest.outActivity, mRequest.inTask, mRequest.reason,
    32.                         mRequest.allowPendingRemoteAnimationRegistryLookup,
    33.                         mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
    34.             }
    35.         } finally {
    36.             onExecutionComplete();
    37.         }
    38.     }

     mRequest.mayWait为true，走startActivityMayWait

    1.    private int startActivityMayWait(IApplicationThread caller,....) {
    2.         ....
    3.         ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
    4.         ....
    5.         // Collect information about the target of the Intent.
    6.         ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
    7.         synchronized (mService.mGlobalLock) {
    8.             .....
    9.             final ActivityRecord[] outRecord = new ActivityRecord[1];
    10.             int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
    11.                     voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
    12.                     callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
    13.                     ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
    14.                     allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
    15.                     allowBackgroundActivityStart);
    16.             ....
    17.             if (outResult != null) {
    18.                 outResult.result = res;
    19.                 final ActivityRecord r = outRecord[0];
    20.                 switch(res) {
    21.                     case START_SUCCESS: {
    22.                         mSupervisor.mWaitingActivityLaunched.add(outResult);
    23.                         do {
    24.                             try {
    25.                                 mService.mGlobalLock.wait();
    26.                             } catch (InterruptedException e) {
    27.                             }
    28.                         } while (outResult.result != START_TASK_TO_FRONT
    29.                                 && !outResult.timeout && outResult.who == null);
    30.                         if (outResult.result == START_TASK_TO_FRONT) {
    31.                             res = START_TASK_TO_FRONT;
    32.                         }
    33.                         break;
    34.                     }
    35.                     case START_DELIVERED_TO_TOP: {
    36.                         outResult.timeout = false;
    37.                         outResult.who = r.mActivityComponent;
    38.                         outResult.totalTime = 0;
    39.                         break;
    40.                     }
    41.                     case START_TASK_TO_FRONT: {
    42.                         .....
    43.                         break;
    44.                     }
    45.                 }
    46.             }
    47.             return res;
    48.         }
    49.     }
    50.  
    51.     private int startActivity(IApplicationThread caller, Intent intent, ....) {
    52.         if (TextUtils.isEmpty(reason)) {
    53.             throw new IllegalArgumentException("Need to specify a reason.");
    54.         }
    55.         mLastStartReason = reason;
    56.         mLastStartActivityTimeMs = System.currentTimeMillis();
    57.         mLastStartActivityRecord[0] = null;
    58.  
    59.         mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
    60.                 aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
    61.                 callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
    62.                 options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
    63.                 inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
    64.                 allowBackgroundActivityStart);
    65.  
    66.         if (outActivity != null) {
    67.             // mLastStartActivityRecord[0] is set in the call to startActivity above.
    68.             outActivity[0] = mLastStartActivityRecord[0];
    69.         }
    70.  
    71.         return getExternalResult(mLastStartActivityResult);
    72.     }
    73.  
    74.     private int startActivity(IApplicationThread caller, Intent intent, ....) {
    75.         .....
    76.         final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
    77.                 true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
    78.         mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outActivity[0]);
    79.         return res;
    80.     }
    81.  
    82.     private int startActivity(final ActivityRecord r, .....) {
    83.         int result = START_CANCELED;
    84.         final ActivityStack startedActivityStack;
    85.         try {
    86.             mService.mWindowManager.deferSurfaceLayout();
    87.             result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
    88.                     startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
    89.         } 
    90.         ......
    91.  
    92.         return result;
    93.     }
    94.  
    95.    private int startActivityUnchecked(final ActivityRecord r, ....) {
    96.         .....
    97.         mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
    98.                 mOptions);
    99.         if (mDoResume) {
    100.             final ActivityRecord topTaskActivity =
    101.                     mStartActivity.getTaskRecord().topRunningActivityLocked();
    102.             if (!mTargetStack.isFocusable()
    103.                     || (topTaskActivity != null && topTaskActivity.mTaskOverlay
    104.                     && mStartActivity != topTaskActivity)) {
    105.                 // If the activity is not focusable, we can't resume it, but still would like to
    106.                 // make sure it becomes visible as it starts (this will also trigger entry
    107.                 // animation). An example of this are PIP activities.
    108.                 // Also, we don't want to resume activities in a task that currently has an overlay
    109.                 // as the starting activity just needs to be in the visible paused state until the
    110.                 // over is removed.
    111.                 mTargetStack.ensureActivitiesVisibleLocked(mStartActivity, 0, !PRESERVE_WINDOWS);
    112.                 // Go ahead and tell window manager to execute app transition for this activity
    113.                 // since the app transition will not be triggered through the resume channel.
    114.                 mTargetStack.getDisplay().mDisplayContent.executeAppTransition();
    115.             } else {
    116.                 // If the target stack was not previously focusable (previous top running activity
    117.                 // on that stack was not visible) then any prior calls to move the stack to the
    118.                 // will not update the focused stack.  If starting the new activity now allows the
    119.                 // task stack to be focusable, then ensure that we now update the focused stack
    120.                 // accordingly.
    121.                 if (mTargetStack.isFocusable()
    122.                         && !mRootActivityContainer.isTopDisplayFocusedStack(mTargetStack)) {
    123.                     mTargetStack.moveToFront("startActivityUnchecked");
    124.                 }
    125.                 mRootActivityContainer.resumeFocusedStacksTopActivities(
    126.                         mTargetStack, mStartActivity, mOptions);
    127.             }
    128.         } else if (mStartActivity != null) {
    129.             mSupervisor.mRecentTasks.add(mStartActivity.getTaskRecord());
    130.         }
    131.         mRootActivityContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
    132.  
    133.         mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTaskRecord(),
    134.                 preferredWindowingMode, mPreferredDisplayId, mTargetStack);
    135.  
    136.         return START_SUCCESS;
    137.     }
    138.

    startActivityUnchecked()调用了mTargetStack.startActivityLocked()，这个方法比较重要。

    1.     void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
    2.             boolean newTask, boolean keepCurTransition, ActivityOptions options) {
    3.         TaskRecord rTask = r.getTaskRecord();
    4.         final int taskId = rTask.taskId;
    5.         final boolean allowMoveToFront = options == null || !options.getAvoidMoveToFront();
    6.         // mLaunchTaskBehind tasks get placed at the back of the task stack.
    7.         if (!r.mLaunchTaskBehind && allowMoveToFront
    8.                 && (taskForIdLocked(taskId) == null || newTask)) {
    9.             // Last activity in task had been removed or ActivityManagerService is reusing task.
    10.             // Insert or replace.
    11.             // Might not even be in.
    12.             insertTaskAtTop(rTask, r);
    13.         }
    14.         TaskRecord task = null;
    15.         if (!newTask) {
    16.             // If starting in an existing task, find where that is...
    17.             boolean startIt = true;
    18.             for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
    19.                 task = mTaskHistory.get(taskNdx);
    20.                 if (task.getTopActivity() == null) {
    21.                     // All activities in task are finishing.
    22.                     continue;
    23.                 }
    24.                 if (task == rTask) {
    25.                     // Here it is!  Now, if this is not yet visible to the
    26.                     // user, then just add it without starting; it will
    27.                     // get started when the user navigates back to it.
    28.                     if (!startIt) {
    29.                         if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "
    30.                                 + task, new RuntimeException("here").fillInStackTrace());
    31.                         r.createAppWindowToken();
    32.                         ActivityOptions.abort(options);
    33.                         return;
    34.                     }
    35.                     break;
    36.                 } else if (task.numFullscreen > 0) {
    37.                     startIt = false;
    38.                 }
    39.             }
    40.         }

    startActivityLocked方法就是找到要启动的Activity的TaskRecord，并将activity插入到合适位置。 这样activity对应ActivityRecord就加入到对应ActivityStack中的对应的TaskRecord中了。

    mRootActivityContainer.resumeFocusedStacksTopActivities(mTargetStack, mStartActivity, mOptions);

    frameworks\base\services\core\java\com\android\server\wm\RootActivityContainer.java：

    1.     boolean resumeFocusedStacksTopActivities(
    2.             ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    3.         ....
    4.         if (targetStack != null && (targetStack.isTopStackOnDisplay()
    5.                 || getTopDisplayFocusedStack() == targetStack)) {
    6.             result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    7.         }
    8.         ....
    9.         return result;
    10.     }
    11.  
    12.     boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    13.         ....
    14.         result = resumeTopActivityInnerLocked(prev, options);
    15.         ....
    16.         return result;
    17.     }
    18.  
    19.     private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    20.         ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
    21.         ....
    22.         if (next.attachedToProcess()) {
    23.             .....
    24.         } else {
    25.             .....
    26.             mStackSupervisor.startSpecificActivityLocked(next, true, true);
    27.         }
    28.         return true;
    29.     }
    30.  
    31.     void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
    32.         // Is this activity's application already running?
    33.         final WindowProcessController wpc =
    34.                 mService.getProcessController(r.processName, r.info.applicationInfo.uid);
    35.  
    36.         boolean knownToBeDead = false;
    37.         if (wpc != null && wpc.hasThread()) {
    38.             ....
    39.                 realStartActivityLocked(r, wpc, andResume, checkConfig);
    40.                 return;
    41.             ....
    42.         }
    43.             // Post message to start process to avoid possible deadlock of calling into AMS with the ATMS lock held.
    44.             final Message msg = PooledLambda.obtainMessage(
    45.                     ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
    46.                     r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
    47.             mService.mH.sendMessage(msg);
    48.             ....
    49.     }

    显然应用还没启动，所以会走到下面的sendMessage，我们可以看到参数里ActivityManagerInternal::startProcess方法，ActivityManagerInternal是个抽象类。

    mService.mH是什么呢

    final ActivityTaskManagerService mService；

    H mH;

    所以mService.mH.sendMessage(msg);发送到了ATMS的Handler。

    AMS中有的内部类LocalService继承了ActivityManagerInternal，

       public final class LocalService extends ActivityManagerInternal

    frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java:

    1.         public void startProcess(String processName, ApplicationInfo info,
    2.                 boolean knownToBeDead, String hostingType, ComponentName hostingName) {
    3.                 synchronized (ActivityManagerService.this) {
    4.                     startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
    5.                             new HostingRecord(hostingType, hostingName),
    6.                             false /* allowWhileBooting */, false /* isolated */,
    7.                             true /* keepIfLarge */);
    8.                 }
    9.         }
    10.  
    11.     final ProcessRecord startProcessLocked(String processName,
    12.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,
    13.             HostingRecord hostingRecord, boolean allowWhileBooting,
    14.             boolean isolated, boolean keepIfLarge) {
    15.         return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
    16.                 hostingRecord, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
    17.                 null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
    18.                 null /* crashHandler */);
    19.     }

    frameworks\base\services\core\java\com\android\server\am\ProcessList.java:

    1.     final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,...) {
    2.         ProcessRecord app;
    3.         if (app == null) {
    4.             app = newProcessRecordLocked(info, processName, isolated, isolatedUid, hostingRecord);
    5.             .....
    6.         } else {
    7.             // If this is a new package in the process, add the package to the list
    8.             app.addPackage(info.packageName, info.longVersionCode, mService.mProcessStats);
    9.         }
    10.         final boolean success = startProcessLocked(app, hostingRecord, abiOverride);
    11.         return success ? app : null;
    12.     }
    13.  
    14.     final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
    15.             String abiOverride) {
    16.         return startProcessLocked(app, hostingRecord,
    17.                 false /* disableHiddenApiChecks */, false /* mountExtStorageFull */, abiOverride);
    18.     }
    19.  
    20.     boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
    21.             boolean disableHiddenApiChecks, boolean mountExtStorageFull,
    22.             String abiOverride) {
    23.             AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
    24.             ....
    25.             // Start the process.  It will either succeed and return a result containing
    26.             // the PID of the new process, or else throw a RuntimeException.
    27.             final String entryPoint = "android.app.ActivityThread";
    28.             return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
    29.                     runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
    30.                     startTime);
    31.         } catch (RuntimeException e) {
    32.             mService.forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
    33.                     false, false, true, false, false, app.userId, "start failure");
    34.             return false;
    35.         }
    36.     }
    37.  
    38.     boolean startProcessLocked(HostingRecord hostingRecord, ....) {
    39.         ....
    40.         final Process.ProcessStartResult startResult = startProcess(hostingRecord,
    41.                         entryPoint, app,
    42.                         uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
    43.                         invokeWith, startTime);
    44.                 handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
    45.                         startSeq, false);
    46.         return app.pid > 0;
    47.     }
    48.  
    49.     private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, ....) {
    50.         try {
    51.             final Process.ProcessStartResult startResult;
    52.             if (hostingRecord.usesWebviewZygote()) {
    53.                 startResult = startWebView(entryPoint,
    54.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
    55.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
    56.                         app.info.dataDir, null, app.info.packageName,
    57.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
    58.             } else if (hostingRecord.usesAppZygote()) {
    59.                 final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
    60.  
    61.                 startResult = appZygote.getProcess().start(entryPoint,
    62.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
    63.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
    64.                         app.info.dataDir, null, app.info.packageName,
    65.                         /*useUsapPool=*/ false,
    66.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
    67.             } else {
    68.                 startResult = Process.start(entryPoint,
    69.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
    70.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
    71.                         app.info.dataDir, invokeWith, app.info.packageName,
    72.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
    73.             }
    74.             return startResult;
    75.         } finally {
    76.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    77.         }
    78.     }

    frameworks\base\core\java\android\os\Process.java:

    1.     public static ProcessStartResult start(@NonNull final String processClass,
    2.                                            @Nullable final String niceName,
    3.                                            int uid, int gid, @Nullable int[] gids,
    4.                                            int runtimeFlags,
    5.                                            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.                                            @Nullable String packageName,
    13.                                            @Nullable String[] zygoteArgs) {
    14.         return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
    15.                     runtimeFlags, mountExternal, targetSdkVersion, seInfo,
    16.                     abi, instructionSet, appDataDir, invokeWith, packageName,
    17.                     /*useUsapPool=*/ true, zygoteArgs);
    18.     }

    frameworks\base\core\java\android\os\ZygoteProcess.java:

    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.                                                   boolean useUsapPool,
    13.                                                   @Nullable String[] zygoteArgs) {
    14.         // TODO (chriswailes): Is there a better place to check this value?
    15.         if (fetchUsapPoolEnabledPropWithMinInterval()) {
    16.             informZygotesOfUsapPoolStatus();
    17.         }
    18.  
    19.         try {
    20.             return startViaZygote(processClass, niceName, uid, gid, gids,
    21.                     runtimeFlags, mountExternal, targetSdkVersion, seInfo,
    22.                     abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
    23.                     packageName, useUsapPool, zygoteArgs);
    24.         } catch (ZygoteStartFailedEx ex) {
    25.             Log.e(LOG_TAG,
    26.                     "Starting VM process through Zygote failed");
    27.         }
    28.     }
    29.  
    30.     private Process.ProcessStartResult startViaZygote(@NonNull final String processClass,
    31.                                                       @Nullable final String niceName,
    32.                                                       final int uid, final int gid,
    33.                                                       @Nullable final int[] gids,
    34.                                                       int runtimeFlags, int mountExternal,
    35.                                                       int targetSdkVersion,
    36.                                                       @Nullable String seInfo,
    37.                                                       @NonNull String abi,
    38.                                                       @Nullable String instructionSet,
    39.                                                       @Nullable String appDataDir,
    40.                                                       @Nullable String invokeWith,
    41.                                                       boolean startChildZygote,
    42.                                                       @Nullable String packageName,
    43.                                                       boolean useUsapPool,
    44.                                                       @Nullable String[] extraArgs)
    45.                                                       throws ZygoteStartFailedEx {
    46.         ArrayList argsForZygote = new ArrayList<>();
    47.  
    48.         // --runtime-args, --setuid=, --setgid=,
    49.         // and --setgroups= must go first
    50.         argsForZygote.add("--runtime-args");
    51.         argsForZygote.add("--setuid=" + uid);
    52.         argsForZygote.add("--setgid=" + gid);
    53.         argsForZygote.add("--runtime-flags=" + runtimeFlags);
    54.         if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
    55.             argsForZygote.add("--mount-external-default");
    56.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
    57.             argsForZygote.add("--mount-external-read");
    58.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
    59.             argsForZygote.add("--mount-external-write");
    60.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_FULL) {
    61.             argsForZygote.add("--mount-external-full");
    62.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_INSTALLER) {
    63.             argsForZygote.add("--mount-external-installer");
    64.         } else if (mountExternal == Zygote.MOUNT_EXTERNAL_LEGACY) {
    65.             argsForZygote.add("--mount-external-legacy");
    66.         }
    67.  
    68.         argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
    69.  
    70.         // --setgroups is a comma-separated list
    71.         if (gids != null && gids.length > 0) {
    72.             StringBuilder sb = new StringBuilder();
    73.             sb.append("--setgroups=");
    74.  
    75.             int sz = gids.length;
    76.             for (int i = 0; i < sz; i++) {
    77.                 if (i != 0) {
    78.                     sb.append(',');
    79.                 }
    80.                 sb.append(gids[i]);
    81.             }
    82.  
    83.             argsForZygote.add(sb.toString());
    84.         }
    85.  
    86.         if (niceName != null) {
    87.             argsForZygote.add("--nice-name=" + niceName);
    88.         }
    89.  
    90.         if (seInfo != null) {
    91.             argsForZygote.add("--seinfo=" + seInfo);
    92.         }
    93.  
    94.         if (instructionSet != null) {
    95.             argsForZygote.add("--instruction-set=" + instructionSet);
    96.         }
    97.  
    98.         if (appDataDir != null) {
    99.             argsForZygote.add("--app-data-dir=" + appDataDir);
    100.         }
    101.  
    102.         if (invokeWith != null) {
    103.             argsForZygote.add("--invoke-with");
    104.             argsForZygote.add(invokeWith);
    105.         }
    106.  
    107.         if (startChildZygote) {
    108.             argsForZygote.add("--start-child-zygote");
    109.         }
    110.  
    111.         if (packageName != null) {
    112.             argsForZygote.add("--package-name=" + packageName);
    113.         }
    114.  
    115.         argsForZygote.add(processClass);
    116.  
    117.         if (extraArgs != null) {
    118.             Collections.addAll(argsForZygote, extraArgs);
    119.         }
    120.  
    121.         synchronized(mLock) {
    122.             // The USAP pool can not be used if the application will not use the systems graphics
    123.             // driver.  If that driver is requested use the Zygote application start path.
    124.             return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
    125.                                               useUsapPool,
    126.                                               argsForZygote);
    127.         }
    128.     }
    129.  
    130.     private Process.ProcessStartResult zygoteSendArgsAndGetResult(
    131.             ZygoteState zygoteState, boolean useUsapPool, @NonNull ArrayList args)
    132.             throws ZygoteStartFailedEx {
    133.         ....
    134.         return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
    135.     }
    136.  
    137.     private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
    138.             ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
    139.         try {
    140.             final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
    141.             final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
    142.  
    143.             zygoteWriter.write(msgStr);
    144.             zygoteWriter.flush();
    145.  
    146.             // Always read the entire result from the input stream to avoid leaving
    147.             // bytes in the stream for future process starts to accidentally stumble
    148.             // upon.
    149.             Process.ProcessStartResult result = new Process.ProcessStartResult();
    150.             result.pid = zygoteInputStream.readInt();
    151.             result.usingWrapper = zygoteInputStream.readBoolean();
    152.  
    153.             if (result.pid < 0) {
    154.                 throw new ZygoteStartFailedEx("fork() failed");
    155.             }
    156.  
    157.             return result;
    158.         } catch (IOException ex) {
    159.             zygoteState.close();
    160.             Log.e(LOG_TAG, "IO Exception while communicating with Zygote - "
    161.                     + ex.toString());
    162.             throw new ZygoteStartFailedEx(ex);
    163.         }
    164.     }

    终于来到与Zygote相关的了，在这前面就是各种判断和配置参数，我们先看openZygoteSocketIfNeeded(abi)

    1.     private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
    2.         try {
    3.             attemptConnectionToPrimaryZygote();
    4.  
    5.             if (primaryZygoteState.matches(abi)) {
    6.                 return primaryZygoteState;
    7.             }
    8.  
    9.             if (mZygoteSecondarySocketAddress != null) {
    10.                 // The primary zygote didn't match. Try the secondary.
    11.                 attemptConnectionToSecondaryZygote();
    12.  
    13.                 if (secondaryZygoteState.matches(abi)) {
    14.                     return secondaryZygoteState;
    15.                 }
    16.             }
    17.         } catch (IOException ioe) {
    18.             throw new ZygoteStartFailedEx("Error connecting to zygote", ioe);
    19.         }
    20.  
    21.         throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
    22.     }
    23.  
    24.     private void attemptConnectionToPrimaryZygote() throws IOException {
    25.         if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
    26.             primaryZygoteState =
    27.                     ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
    28.  
    29.             maybeSetApiBlacklistExemptions(primaryZygoteState, false);
    30.             maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
    31.             maybeSetHiddenApiAccessStatslogSampleRate(primaryZygoteState);
    32.         }
    33.     }
    34.  
    35.         static ZygoteState connect(@NonNull LocalSocketAddress zygoteSocketAddress,
    36.                 @Nullable LocalSocketAddress usapSocketAddress)
    37.                 throws IOException {
    38.  
    39.             DataInputStream zygoteInputStream;
    40.             BufferedWriter zygoteOutputWriter;
    41.             final LocalSocket zygoteSessionSocket = new LocalSocket();
    42.  
    43.             if (zygoteSocketAddress == null) {
    44.                 throw new IllegalArgumentException("zygoteSocketAddress can't be null");
    45.             }
    46.  
    47.             try {
    48.                 zygoteSessionSocket.connect(zygoteSocketAddress);
    49.                 zygoteInputStream = new DataInputStream(zygoteSessionSocket.getInputStream());
    50.                 zygoteOutputWriter =
    51.                         new BufferedWriter(
    52.                                 new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),
    53.                                 Zygote.SOCKET_BUFFER_SIZE);
    54.             } catch (IOException ex) {
    55.                 try {
    56.                     zygoteSessionSocket.close();
    57.                 } catch (IOException ignore) { }
    58.  
    59.                 throw ex;
    60.             }
    61.  
    62.             return new ZygoteState(zygoteSocketAddress, usapSocketAddress,
    63.                                    zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,
    64.                                    getAbiList(zygoteOutputWriter, zygoteInputStream));
    65.         }

    openZygoteSocketIfNeeded方法中连接了Zygote线程的socket，并获取输入输出流对象。

    zygoteSessionSocket.connect(zygoteSocketAddress);

     zygoteSocketAddress是方法参数，是attemptConnectionToPrimaryZygote方法传进来的，参数是mZygoteSocketAddress，mZygoteSocketAddress是ZygoteProcess类的成员变量。

         /**
         * The name of the socket used to communicate with the primary zygote.
         */
        private final LocalSocketAddress mZygoteSocketAddress;

     找一下那里赋值的，

    1.     public ZygoteProcess() {
    2.         mZygoteSocketAddress =
    3.                 new LocalSocketAddress(Zygote.PRIMARY_SOCKET_NAME,
    4.                                        LocalSocketAddress.Namespace.RESERVED);
    5.         mZygoteSecondarySocketAddress =
    6.                 new LocalSocketAddress(Zygote.SECONDARY_SOCKET_NAME,
    7.                                        LocalSocketAddress.Namespace.RESERVED);
    8.  
    9.         mUsapPoolSocketAddress =
    10.                 new LocalSocketAddress(Zygote.USAP_POOL_PRIMARY_SOCKET_NAME,
    11.                                        LocalSocketAddress.Namespace.RESERVED);
    12.         mUsapPoolSecondarySocketAddress =
    13.                 new LocalSocketAddress(Zygote.USAP_POOL_SECONDARY_SOCKET_NAME,
    14.                                        LocalSocketAddress.Namespace.RESERVED);
    15.     }
    16.     public static final String PRIMARY_SOCKET_NAME = "zygote";
    17.     public static final String SECONDARY_SOCKET_NAME = "zygote_secondary";

    所以zygoteSessionSocket.connect(zygoteSocketAddress)相当于

    zygoteSessionSocket.connect("zygote");这个值有点熟悉，我们回到ZygoteInit的main函数看下。

    frameworks\base\core\java\com\android\internal\os\ZygoteInit.java：

    1.     public static void main(String argv[]) {
    2.         ZygoteServer zygoteServer = null
    3.         Runnable caller;
    4.         try {
    5.             ....
    6.             String zygoteSocketName = "zygote";
    7.             final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
    8.             ....
    9.             zygoteServer = new ZygoteServer(isPrimaryZygote);
    10.             Log.i(TAG, "Accepting command socket connections");
    11.             // The select loop returns early in the child process after a fork and
    12.             // loops forever in the zygote.
    13.             caller = zygoteServer.runSelectLoop(abiList);
    14.         } catch (Throwable ex) {
    15.             Log.e(TAG, "System zygote died with exception", ex);
    16.             throw ex;
    17.         } finally {
    18.             if (zygoteServer != null) {
    19.                 zygoteServer.closeServerSocket();
    20.             }
    21.         }
    22.         if (caller != null) {
    23.             caller.run();
    24.         }
    25.     }
    26.  
    27.     ZygoteServer(boolean isPrimaryZygote) {
    28.         mUsapPoolEventFD = Zygote.getUsapPoolEventFD();
    29.  
    30.         if (isPrimaryZygote) {
    31.             mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);
    32.             mUsapPoolSocket =
    33.                     Zygote.createManagedSocketFromInitSocket(
    34.                             Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);
    35.         } else {
    36.             mZygoteSocket = Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);
    37.             mUsapPoolSocket =
    38.                     Zygote.createManagedSocketFromInitSocket(
    39.                             Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);
    40.         }
    41.  
    42.         fetchUsapPoolPolicyProps();
    43.  
    44.         mUsapPoolSupported = true;
    45.     }

    main里面创建了ZygoteServer，这里的isPrimaryZygote为true，我们看到了熟悉的常量Zygote.PRIMARY_SOCKET_NAME，所以这里用“zyogte”创建了Socket服务器，如果isPrimaryZygote为false的话就是第二个socket地址。我们在连接的时候连不上第一个socket服务器也会去尝试连接第二个。

    main最后

    caller = zygoteServer.runSelectLoop(abiList);

    caller.run();

    是开启了Socket轮询，对于请求的处理在之前的文章已经分析过了。

    Android—Zygote的启动与工作

    就是接收到socket连接的时候会去调用native层的fork方法创建一个新的进程。

    我们在ProcessList.java的startProcessLocked方法中将

    final String entryPoint = "android.app.ActivityThread";

    作为参数最后传到socket，socket收到请求数据后，在ZygoteConnection的processOneCommand方法中会用反射执行ActivityThread的main函数。

    1.     protected static Runnable findStaticMain(String className, String[] argv,
    2.             ClassLoader classLoader) {
    3.         Class cl;
    4.  
    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.         }
    12.  
    13.         Method m;
    14.         try {
    15.             m = cl.getMethod("main", new Class[] { String[].class });
    16.         } catch (NoSuchMethodException ex) {
    17.             throw new RuntimeException(
    18.                     "Missing static main on " + className, ex);
    19.         } catch (SecurityException ex) {
    20.             throw new RuntimeException(
    21.                     "Problem getting static main on " + className, ex);
    22.         }
    23.  
    24.         int modifiers = m.getModifiers();
    25.         if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
    26.             throw new RuntimeException(
    27.                     "Main method is not public and static on " + className);
    28.         }
    29.  
    30.         /*
    31.          * This throw gets caught in ZygoteInit.main(), which responds
    32.          * by invoking the exception's run() method. This arrangement
    33.          * clears up all the stack frames that were required in setting
    34.          * up the process.
    35.          */
    36.         return new MethodAndArgsCaller(m, argv);
    37.     }

    我们看ActivityThread的main方法

    frameworks\base\core\java\android\app\ActivityThread.java：

    1.     public static void main(String[] args) {
    2.         ...
    3.         Looper.prepareMainLooper();
    4.         ...
    5.         ActivityThread thread = new ActivityThread();
    6.         thread.attach(false, startSeq);
    7.         ...
    8.         Looper.loop();
    9.     }

    main中先去创建主线程的Looper然后去生成ActivityThread对象然后调用attach方法，最后去开启轮询。

    1.     @UnsupportedAppUsage
    2.     private void attach(boolean system, long startSeq) {
    3.         sCurrentActivityThread = this;
    4.         mSystemThread = system;
    5.         if (!system) {
    6.             ....
    7.             final IActivityManager mgr = ActivityManager.getService();
    8.             try {
    9.                 mgr.attachApplication(mAppThread, startSeq);
    10.             } catch (RemoteException ex) {
    11.                 throw ex.rethrowFromSystemServer();
    12.             }
    13.             // Watch for getting close to heap limit.
    14.             BinderInternal.addGcWatcher(new Runnable() {
    15.                 @Override public void run() {
    16.                     ....
    17.             });
    18.         } else {
    19.             ...
    20.         }
    21.  
    22.         ViewRootImpl.ConfigChangedCallback configChangedCallback
    23.                 = (Configuration globalConfig) -> {
    24.             synchronized (mResourcesManager) {
    25.                 ....
    26.         };
    27.         ViewRootImpl.addConfigCallback(configChangedCallback);
    28.     }

    attach里面如果是systemServer的进程就走else，IActivityManager对应的是AMS，我们直接看AMS的attachApplication方法

    1.     @Override
    2.     public final void attachApplication(IApplicationThread thread, long startSeq) {
    3.         synchronized (this) {
    4.             ...
    5.             attachApplicationLocked(thread, callingPid, callingUid, startSeq);
    6.             Binder.restoreCallingIdentity(origId);
    7.         }
    8.     }
    9.  
    10.     private final boolean attachApplicationLocked(IApplicationThread thread,
    11.             int pid, int callingUid, long startSeq) {
    12.         ProcessRecord app;
    13.         long startTime = SystemClock.uptimeMillis();
    14.         long bindApplicationTimeMillis;
    15.         ....
    16.         app = mPidsSelfLocked.get(pid);
    17.         // If this application record is still attached to a previous
    18.         // process, clean it up now.
    19.         if (app.thread != null) {
    20.             handleAppDiedLocked(app, true, true);
    21.         }
    22.         app.makeActive(thread, mProcessStats);
    23.         //mProcessesReady这个变量在AMS的 systemReady 中被赋值为true，
    24.         //所以这里的normalMode也为true
    25.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);    
    26.         if (normalMode) {
    27.             try {
    28.                 didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
    29.             } catch (Exception e) {
    30.                 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
    31.                 badApp = true;
    32.             }
    33.         }
    34.         return true;
    35.     }

    这里的mAtmInternal是ActivityTaskManagerInternal对象。我们知道ATMS有个内部类LocalService继承了该类。

    frameworks\base\services\core\java\com\android\server\wm\ActivityTaskManagerService.java：

    1.         public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
    2.             synchronized (mGlobalLockWithoutBoost) {
    3.                 return mRootActivityContainer.attachApplication(wpc);
    4.             }
    5.         }

    frameworks\base\services\core\java\com\android\server\wm\RootActivityContainer.java：

    1.     boolean attachApplication(WindowProcessController app) throws RemoteException {
    2.         final String processName = app.mName;
    3.         boolean didSomething = false;
    4.         for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
    5.             final ActivityDisplay display = mActivityDisplays.get(displayNdx);
    6.             final ActivityStack stack = display.getFocusedStack();
    7.             if (stack != null) {
    8.                 stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
    9.                 final ActivityRecord top = stack.topRunningActivityLocked();
    10.                 final int size = mTmpActivityList.size();
    11.                 for (int i = 0; i < size; i++) {
    12.                     final ActivityRecord activity = mTmpActivityList.get(i);
    13.                     if (activity.app == null && app.mUid == activity.info.applicationInfo.uid
    14.                             && processName.equals(activity.processName)) {
    15.                         try {
    16.                             if (mStackSupervisor.realStartActivityLocked(activity, app,
    17.                                     top == activity /* andResume */, true /* checkConfig */)) {
    18.                                 didSomething = true;
    19.                             }
    20.                         } catch (RemoteException e) {
    21.                             Slog.w(TAG, "Exception in new application when starting activity "
    22.                                     + top.intent.getComponent().flattenToShortString(), e);
    23.                             throw e;
    24.                         }
    25.                     }
    26.                 }
    27.             }
    28.         }
    29.         if (!didSomething) {
    30.             ensureActivitiesVisible(null, 0, false /* preserve_windows */);
    31.         }
    32.         return didSomething;
    33.     }

    这里取了所有可见的activity，循环作为realStartActivityLocked方法参数

    frameworks\base\services\core\java\com\android\server\wm\ActivityStackSupervisor.java：

    1.     boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
    2.             boolean andResume, boolean checkConfig) throws RemoteException {
    3.         // 直到所有的 onPause() 执行结束才会去启动新的 activity
    4.         if (!mRootActivityContainer.allPausedActivitiesComplete()) {
    5.             return false;
    6.         }
    7.         try {
    8.                 // Create activity launch transaction.
    9.                 final ClientTransaction clientTransaction = ClientTransaction.obtain(
    10.                         proc.getThread(), r.appToken);
    11.                 clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
    12.                         System.identityHashCode(r), r.info,
    13.                         // TODO: Have this take the merged configuration instead of separate global
    14.                         // and override configs.
    15.                         mergedConfiguration.getGlobalConfiguration(),
    16.                         mergedConfiguration.getOverrideConfiguration(), r.compat,
    17.                         r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
    18.                         r.icicle, r.persistentState, results, newIntents,
    19.                         dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
    20.                                 r.assistToken));
    21.                 // Set desired final state.
    22.                 final ActivityLifecycleItem lifecycleItem;
    23.                 if (andResume) {
    24.                     lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
    25.                 } else {
    26.                     lifecycleItem = PauseActivityItem.obtain();
    27.                 }
    28.                 clientTransaction.setLifecycleStateRequest(lifecycleItem);
    29.                 // Schedule transaction.
    30.                 mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    31.                 .....
    32.             } catch (RemoteException e) {
    33.                 ...
    34.             }
    35.         } finally {
    36.             endDeferResume();
    37.         }
    38.         .....
    39.         return true;
    40.     }

    final ClientTransaction clientTransaction = ClientTransaction.obtain( proc.getThread(), r.appToken);

    clientTransaction.addCallback(LaunchActivityItem.obtain(...));

    重点：这里获取了一个ClientTransaction对象，然后调用addCallback添加了LaunchActivityItem对象。

    mService.getLifecycleManager().scheduleTransaction(clientTransaction);

    scheduleTransaction使用到了该对象，我们先看scheduleTransaction方法

    frameworks\base\services\core\java\com\android\server\wm\ClientLifecycleManager.java：

    1.     void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    2.         final IApplicationThread client = transaction.getClient();
    3.         transaction.schedule();
    4.         ....
    5.     }

    frameworks\base\core\java\android\app\servertransaction\ClientTransaction.java：

    1.     public void schedule() throws RemoteException {
    2.         mClient.scheduleTransaction(this);
    3.     }
    4.  
    5.     public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
    6.         ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
    7.         if (instance == null) {
    8.             instance = new ClientTransaction();
    9.         }
    10.         instance.mClient = client;
    11.         instance.mActivityToken = activityToken;
    12.  
    13.         return instance;
    14.     }

    结合final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);

    所以mService.getLifecycleManager().scheduleTransaction(clientTransaction);就是调用了proc.getThread()的scheduleTransaction方法。

    但是proc.getThread()是什么呢？

    我们回头到AMS的attachApplicationLocked方法，

    1.     private final boolean attachApplicationLocked(IApplicationThread thread,
    2.             int pid, int callingUid, long startSeq) {
    3.         ProcessRecord app;
    4.         long startTime = SystemClock.uptimeMillis();
    5.         long bindApplicationTimeMillis;
    6.         ....
    7.         app = mPidsSelfLocked.get(pid);
    8.         // If this application record is still attached to a previous
    9.         // process, clean it up now.
    10.         if (app.thread != null) {
    11.             handleAppDiedLocked(app, true, true);
    12.         }
    13.         app.makeActive(thread, mProcessStats);
    14.         //mProcessesReady这个变量在AMS的 systemReady 中被赋值为true，
    15.         //所以这里的normalMode也为true
    16.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);    
    17.         if (normalMode) {
    18.             try {
    19.                 didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
    20.             } catch (Exception e) {
    21.                 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
    22.                 badApp = true;
    23.             }
    24.         }
    25.         return true;
    26.     }

    发现proc.getThread()是app.getWindowProcessController()，意思就是app.getWindowProcessController().getTread()

    frameworks\base\services\core\java\com\android\server\am\ProcessRecord.java：

    1.     WindowProcessController getWindowProcessController() {
    2.         return mWindowProcessController;
    3.     }
    4.  
    5.     public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
    6.         ....
    7.         thread = _thread;
    8.         mWindowProcessController.setThread(thread);
    9.     }

    我们发现它是在makeActive方法中赋值的，回到AMS的attachApplicationLocked方法，我们可以找到该方法，我们看下传进去的thread是谁。

    最后发现是一开始ActivityThread的attach方法传进来的

    1.     private void attach(boolean system, long startSeq) {
    2.         ....
    3.         mgr.attachApplication(mAppThread, startSeq);
    4.         ....
    5.     }
    6.  
    7.     final ApplicationThread mAppThread = new ApplicationThread();

    所以最终mService.getLifecycleManager().scheduleTransaction(clientTransaction);就是调用了ApplicationThread的scheduleTransaction方法，ApplicationThread是ActivityThread的内部类，所以饶了一大圈最终又回到了ActivityThread。

    1.         public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    2.             ActivityThread.this.scheduleTransaction(transaction);
    3.         }

     这里调用了ActivityThread的scheduleTransaction，ActivityThread继承了ClientTransactionHandler，scheduleTransaction在ClientTransactionHandler类中。

    frameworks\base\core\java\android\app\ClientTransactionHandler.java：

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

    这里把信息发送到ActivityThread的内部类H里面

    1.    case EXECUTE_TRANSACTION:
    2.       final ClientTransaction transaction = (ClientTransaction) msg.obj;
    3.       mTransactionExecutor.execute(transaction);
    4.       break;

    frameworks\base\core\java\android\app\servertransaction\TransactionExecutor.java：

    1.     public void execute(ClientTransaction transaction) {
    2.         ...
    3.         executeCallbacks(transaction);
    4.         executeLifecycleState(transaction);
    5.         ...
    6.     }
    7.  
    8.     public void executeCallbacks(ClientTransaction transaction) {
    9.         final List callbacks = transaction.getCallbacks();
    10.         final int size = callbacks.size();
    11.         for (int i = 0; i < size; ++i) {
    12.             final ClientTransactionItem item = callbacks.get(i);
    13.             item.execute(mTransactionHandler, token, mPendingActions);
    14.             ....
    15.         }
    16.     }

    1.executeCallbacks

    这里拿出了ClientTransaction的callbacks，然后调用callback的execute。

    记得在ActivityStackSupervisor类的realStartActivityLocked方法中

    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),.....);

     我们回去看一下LaunchActivityItem的obtain

    frameworks\base\core\java\android\app\servertransaction\LaunchActivityItem.java：

    1.     public static LaunchActivityItem obtain(Intent intent, int ident, ActivityInfo info,
    2.             Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo,
    3.             String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
    4.             PersistableBundle persistentState, List pendingResults,
    5.             List pendingNewIntents, boolean isForward, ProfilerInfo profilerInfo,
    6.             IBinder assistToken) {
    7.         LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
    8.         if (instance == null) {
    9.             instance = new LaunchActivityItem();
    10.         }
    11.         setValues(instance, intent, ident, info, curConfig, overrideConfig, compatInfo, referrer,
    12.                 voiceInteractor, procState, state, persistentState, pendingResults,
    13.                 pendingNewIntents, isForward, profilerInfo, assistToken);
    14.  
    15.         return instance;
    16.     }

    接下来看LaunchActivityItem的execute

    1.     public void execute(ClientTransactionHandler client, IBinder token,
    2.             PendingTransactionActions pendingActions) {
    3.         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    4.         ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
    5.                 mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
    6.                 mPendingResults, mPendingNewIntents, mIsForward,
    7.                 mProfilerInfo, client, mAssistToken);
    8.         client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    9.         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    10.     }

    这里的client是ActivityThread

    1.     public Activity handleLaunchActivity(ActivityClientRecord r,
    2.             PendingTransactionActions pendingActions, Intent customIntent) {
    3.         ....
    4.         final Activity a = performLaunchActivity(r, customIntent);
    5.         if (a != null) {
    6.             ....
    7.         } else {
    8.             // If there was an error, for any reason, tell the activity manager to stop us.
    9.             try {
    10.                 ActivityTaskManager.getService()
    11.                         .finishActivity(r.token, Activity.RESULT_CANCELED, null,
    12.                                 Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
    13.             } catch (RemoteException ex) {
    14.                 throw ex.rethrowFromSystemServer();
    15.             }
    16.         }
    17.         return a;
    18.     }

     2.executeLifecycleState

    1.     private void executeLifecycleState(ClientTransaction transaction) {
    2.         final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    3.         ....
    4.         lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    5.     }

    想知道这里的lifecycleItem是啥，同样需要回到realStartActivityLocked方法中

                    final ActivityLifecycleItem lifecycleItem;
                    if (andResume) {
                        lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
                    } else {
                        lifecycleItem = PauseActivityItem.obtain();
                    }

    如果start的activity在栈顶，andResume为true。

    frameworks\base\core\java\android\app\servertransaction\ResumeActivityItem.java：

    1.     public void execute(ClientTransactionHandler client, IBinder token,
    2.             PendingTransactionActions pendingActions) {
    3.         client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
    4.                 "RESUME_ACTIVITY");
    5.     }

    frameworks\base\core\java\android\app\servertransaction\PauseActivityItem.java：

    1.     public void execute(ClientTransactionHandler client, IBinder token,
    2.             PendingTransactionActions pendingActions) {
    3.         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
    4.         client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
    5.                 "PAUSE_ACTIVITY_ITEM");
    6.         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    7.     }

    跟LaunchActivityItem类的execute调用ActivityThread的handleLaunchActivity方法一样，XXActivityItem就是去调用ActivityThread对应的handleXXActivity方法。

    总结下来就是ActivityStackSupervisor处理启动activity请求会把该请求封装成一个ClientTransaction，然后执行Activity对应操作时就向ClientTransaction添加对应的XXActivityItem。而ActivityThread是ClientTransaction的处理者，继承了ClientTransactionHandler，根据XXActivityItem调用handleXXActivity，去执行activity的启动、onResume等生命周期活动。

    流程：

  • 相关阅读:
    Haar cascade+opencv检测算法
    Python 环境安装系统教程——PyCharm
    CRM项目记录（四）
    java设计模式和面向对象编程思想
    weapp-tailwindcss - 在开发小程序中使用 tailwindcss 的最佳方式，免费开源，支持国内各家主流小程序平台
    CesiumJS PrimitiveAPI 高级着色入门 - 从参数化几何与 Fabric 材质到着色器 - 上篇
    使用DESeq2进行转录组原始count标准化和差异分析
    OpenCV实现人脸检测（Haar特征）
    计算机毕业论文选题java毕业设计软件源代码SSH健身房管理系统[包运行成功]
    抢滩未来 音视频引领新趋势
  • 原文地址：https://blog.csdn.net/weixin_41939525/article/details/126178948