学习笔记：
Android 10.0 launcher 启动流程
Android 13 Launcher 基础熟悉(一)
Android 13 Launcher 数据加载分析（二）
Android 13 Launcher3 数据库及Workspace 的数据加载与绑定（三）
在前面SystemUI启动流程中说到，在SystemServer中会去启动各种系统服务，这里的launcher也是启动的此中一个服务ActivityManagerService去启动的。在android10之前，系统四大组件的启动都是在ActivityManagerService中，在android10中，单独抽出了一个ActivityTaskManagerService，重要负责Activity的管理和调理。这里先来看下ActivityManagerService服务的启动：
// SystemServer.javaprivate void startBootstrapServices() { ... ... // Activity manager runs the show. traceBeginAndSlog("StartActivityManager"); // TODO: Might need to move after migration to WM. ActivityTaskManagerService atm = mSystemServiceManager.startService( ActivityTaskManagerService.Lifecycle.class).getService(); mActivityManagerService = ActivityManagerService.Lifecycle.startService( mSystemServiceManager, atm); mActivityManagerService.setSystemServiceManager(mSystemServiceManager); mActivityManagerService.setInstaller(installer); mWindowManagerGlobalLock = atm.getGlobalLock(); traceEnd(); ... ...}当SystemServiceManager调用 startService() 时，就会通过反射去创建传进去的class，然后在调用创建对象的 onStart() 方法，这里就是去初始化ActivityTaskManagerService和ActivityManagerService对象，并不会去启动launcher，而且系统服务启动分为三块：
// SystemServer.javastartBootstrapServices(); // 启动引导服务startCoreServices(); // 启动核心折务startOtherServices(); // 启动其他服务在startOtherServices（）中可以看到：
// SystemServer.javaprivate void startOtherServices() { ... ... // We now tell the activity manager it is okay to run third party // code. It will call back into us once it has gotten to the state // where third party code can really run (but before it has actually // started launching the initial applications), for us to complete our // initialization. mActivityManagerService.systemReady(() -> { ... ... });}这就分析在全部服务初始化完成后，在这里会关照ActivityManagerService的systemReady()启动 launcher 的历程。
下面一起来看 launcher 是怎样被启动起来的：
// ActivityManagerService.javapublic void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) { ... ... mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady"); ... ... mAtmInternal.resumeTopActivities(false /* scheduleIdle */); ... ...}mAtmInternal范例是ActivityTaskManagerInternal，这是一个抽象类，实在现是ActivityTaskManagerService的内部类LocalService：
// ActivityTaskManagerService.javafinal class LocalService extends ActivityTaskManagerInternal { ... ... @Override public boolean startHomeOnAllDisplays(int userId, String reason) { synchronized (mGlobalLock) { return mRootActivityContainer.startHomeOnAllDisplays(userId, reason); } } ... ... @Override public void resumeTopActivities(boolean scheduleIdle){ synchronized (mGlobalLock){ mRootActivityContainer.resumeFocusedStacksTopActivities(); if(scheduleIdle){ mStackSupervisor.scheduleIdleLocked(); } } } ... ...}这里的mRootActivityContainer范例是RootActivityContainer，按照文档上的分析，这是一个暂时类，重要是将ActivityStackSupervisor.java中的一部门逻辑分离出来，在android11中，这个类就已经找不到了。更换成了RootWindowContainer，这里我们跟进 mRootActivityContainer.startHomeOnAllDisplays() 方法看，终极会调用到：startHomeOnDisplay() :
// RootActivityContainer.javaboolean startHomeOnDisplay(int userId,String reason,int displayId,boolean allowInstrumenting,boolean fromHomeKey){ // Fallback to top focused display if the displayId is invalid. if(displayId==INVALID_DISPLAY){ displayId=getTopDisplayFocusedStack().mDisplayId; } Intent homeIntent=null; ActivityInfo aInfo=null; if(displayId==DEFAULT_DISPLAY){ //拿到需要启动launcher的intent，通过resolveHomeActivity解析出需要启动的Activity homeIntent=mService.getHomeIntent(); aInfo=resolveHomeActivity(userId,homeIntent); }else if(shouldPlaceSecondaryHomeOnDisplay(displayId)){ Pair<ActivityInfo, Intent> info=resolveSecondaryHomeActivity(userId,displayId); aInfo=info.first; homeIntent=info.second; } if(aInfo==null||homeIntent==null){ return false; } if(!canStartHomeOnDisplay(aInfo,displayId,allowInstrumenting)){ return false; } // Updates the home component of the intent. homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName,aInfo.name)); homeIntent.setFlags(homeIntent.getFlags()|FLAG_ACTIVITY_NEW_TASK); // Updates the extra information of the intent. if(fromHomeKey){ homeIntent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY,true); } // Update the reason for ANR debugging to verify if the user activity is the one that // actually launched. final String myReason=reason+":"+userId+":"+UserHandle.getUserId( aInfo.applicationInfo.uid)+":"+displayId; mService.getActivityStartController().startHomeActivity(homeIntent,aInfo,myReason, displayId); return true;}这里可以分为两步看：
1、通过ActivityTaskManagerService的getHomeIntent（）获取到需要启动的intent，在通过resolveHomeActivity（）解析出需要启动Activity的信息，
2、mService.getActivityStartController()获取到的是ActivityStartController，这个类的重要作用是用于控制委派启动的Activity。
先来看下ActivityTaskManagerService的getHomeIntent() :
// ActivityTaskManagerService.java Intent getHomeIntent() { Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null); intent.setComponent(mTopComponent); intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING); if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) { intent.addCategory(Intent.CATEGORY_HOME); } return intent; }注意看 intent.addCategory(Intent.CATEGORY_HOME) ，这个代表的就是要启动Activity的意图，通常来说，整个系统的只会有一个应用会在清单文件中配置CATEGORY_HOME，如果配置了多个，系统在启动的时间就会要求用户手动去选择哪个作为启动应用，如果在系统设置应用中举行配置了，就会选择配置的谁人应用启动。（这个 CATEGORY_HOME 配置，说白了就只有 launcher 程序才会有）。
回到主线，接着看mService.getActivityStartController().startHomeActivity() :
// ActivityStartController.java void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason, TaskDisplayArea taskDisplayArea) { final ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN); if (!ActivityRecord.isResolverActivity(aInfo.name)) { // The resolver activity shouldn't be put in home stack because when the foreground is // standard type activity, the resolver activity should be put on the top of current // foreground instead of bring home stack to front. options.setLaunchActivityType(ACTIVITY_TYPE_HOME); } final int displayId = taskDisplayArea.getDisplayId(); options.setLaunchDisplayId(displayId); options.setLaunchTaskDisplayArea(taskDisplayArea.mRemoteToken .toWindowContainerToken()); // The home activity will be started later, defer resuming to avoid unneccerary operations // (e.g. start home recursively) when creating home stack. mSupervisor.beginDeferResume(); final ActivityStack homeStack; try { // Make sure home stack exists on display area. homeStack = taskDisplayArea.getOrCreateRootHomeTask(ON_TOP); } finally { mSupervisor.endDeferResume(); } mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason) .setOutActivity(tmpOutRecord) .setCallingUid(0) .setActivityInfo(aInfo) .setActivityOptions(options.toBundle()) .execute(); mLastHomeActivityStartRecord = tmpOutRecord[0]; if (homeStack.mInResumeTopActivity) { // If we are in resume section already, home activity will be initialized, but not // resumed (to avoid recursive resume) and will stay that way until something pokes it // again. We need to schedule another resume. mSupervisor.scheduleResumeTopActivities(); } } /** * @return A starter to configure and execute starting an activity. It is valid until after * {@link ActivityStarter#execute} is invoked. At that point, the starter should be * considered invalid and no longer modified or used. */ ActivityStarter obtainStarter(Intent intent, String reason) { return mFactory.obtain().setIntent(intent).setReason(reason); }这里重要是先获取一个ActivityStarter（重要用于启动Activity），然后把需要的参数设置进去，末了再调用它的ActivityStarter.execute（）方法：
// ActivityStarter.javaint execute() { try { ... ... final LaunchingState launchingState; synchronized (mService.mGlobalLock) { final ActivityRecord caller = ActivityRecord.forTokenLocked(mRequest.resultTo); // 通过ActivityMetricsLogger.notifyActivityLaunching创建LaunchingState并记载创建Activity开始的时间 launchingState = mSupervisor.getActivityMetricsLogger().notifyActivityLaunching( mRequest.intent, caller); } ... ... // 实行启动请求 res = executeRequest(mRequest); ... ... // Notify ActivityMetricsLogger that the activity has launched. // ActivityMetricsLogger will then wait for the windows to be drawn and populate // WaitResult. // 通过ActivityMetricsLogger.notifyActivityLaunched记载Activity启动完成的时间 mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res, mLastStartActivityRecord); // 同时将Request.waitResult添加到ActivityStackSupervisor的mWaitingActivityLaunched中，等待窗口绘制完成 return getExternalResult(mRequest.waitResult == null ? res : waitForResult(res, mLastStartActivityRecord)); } finally { onExecutionComplete(); } } 通过上面代码我们知道，启动是在 executeRequest() 方法里：
// ActivityStarter.java private int executeRequest(Request request) { ... ... //调用 startActivityUnchecked mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession, request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask, restrictedBgActivity, intentGrants); return mLastStartActivityResult; }ActivityStarter.startActivityUnchecked()
// ActivityStarter.java private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, Task inTask, boolean restrictedBgActivity, NeededUriGrants intentGrants) { int result = START_CANCELED; ... ... try { //延时布局 mService.deferWindowLayout(); //实行startActivityInner result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor, startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants); } finally { //规复布局 mService.continueWindowLayout(); } ... ... return result; }ActivityStarter.startActivityInner()
int startActivityInner() { ... ... if (mDoResume) { //ActivityRecord 记载着 Activity 信息 final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked(); if (!mTargetStack.isTopActivityFocusable() || (topTaskActivity != null && topTaskActivity.isTaskOverlay() && mStartActivity != topTaskActivity)) { mTargetStack.getDisplay().mDisplayContent.executeAppTransition(); } else { //实行resumeFocusedStacksTopActivities mRootWindowContainer.resumeFocusedStacksTopActivities( mTargetStack, mStartActivity, mOptions); } } ... ... return START_SUCCESS; }RootWindowContainer.resumeFocusedStacksTopActivities()
// RootWindowContainer.javaboolean resumeFocusedStacksTopActivities( ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) { ... ... //如果是栈顶Activity，启动resumeTopActivityUncheckedLocked if (targetStack != null && (targetStack.isTopStackInDisplayArea() || getTopDisplayFocusedStack() == targetStack)) { result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions); } ... ... if (!resumedOnDisplay) { //获取栈顶的 ActivityRecord final ActivityStack focusedStack = display.getFocusedStack(); if (focusedStack != null) { //实行resumeTopActivityUncheckedLocked result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions); }else if (targetStack == null) { result |= resumeHomeActivity(null /* prev */, "no-focusable-task", display.getDefaultTaskDisplayArea()); } } return result;}ActivityStack.resumeTopActivityUncheckedLocked()
// ActivityStack.java boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) { if (mInResumeTopActivity) { // Don't even start recursing. return false; } boolean result = false; try { mInResumeTopActivity = true; // 实行 resumeTopActivityInnerLocked, // 终极调用到 ActivityStackSupervisor.startSpecificActivity() result = resumeTopActivityInnerLocked(prev, options); final ActivityRecord next = topRunningActivity(true /* focusableOnly */); if (next == null || !next.canTurnScreenOn()) { checkReadyForSleep(); } } finally { mInResumeTopActivity = false; } return result; }ActivityStackSupervisor.startSpecificActivity()
// ActivityStackSupervisor.java void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) { // Is this activity's application already running? final WindowProcessController wpc = mService.getProcessController(r.processName, r.info.applicationInfo.uid); boolean knownToBeDead = false; //历程存在 if (wpc != null && wpc.hasThread()) { try { //真正启动Activity方法 realStartActivityLocked(r, wpc, andResume, checkConfig); return; } catch (RemoteException e) { Slog.w(TAG, "Exception when starting activity " + r.intent.getComponent().flattenToShortString(), e); } // If a dead object exception was thrown -- fall through to // restart the application. knownToBeDead = true; } r.notifyUnknownVisibilityLaunchedForKeyguardTransition(); final boolean isTop = andResume && r.isTopRunningActivity(); //历程不存在 mService =ATMS mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity"); }startSpecificActivity() 这个方法是关键方法，如果历程已经存在直接实行 realStartActivityLocked 去启动 Activity，历程不存在则通过AMS去创建 Socket，然后关照 Zygote 去 fork 历程。由于这里第一次创建，以是会走到 startProcessAsync() 。
Launcher启动流程调用栈：
创建Socket创建毗连
ActivityTaskManagerService.startProcessAsync()
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop, String hostingType) { try { if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) { Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "dispatchingStartProcess:" + activity.processName); } // Post message to start process to avoid possible deadlock of calling into AMS with the // ATMS lock held. final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess, mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead, isTop, hostingType, activity.intent.getComponent()); mH.sendMessage(m); } finally { Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER); } }通过handler发消息实行ActivityManagerInternal.startProcess() ，内部又转调用ActivityManagerService.startProcessLocked() :
@GuardedBy("this") final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, boolean keepIfLarge) { return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge, null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */, null /* crashHandler */); }mProcessList范例是ProcessList，这是一个历程管理类，形貌了历程的adj值，当系统资源吃紧时，就会根据这里形貌的adj去判定杀死哪个应用来释放资源，可以通过adb shell dumpsys meminfo来检察当前全部历程的分类环境，接着来看下ProcessList.startProcessLocked():
// ProcessList.java final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord, boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) { ProcessRecord app; ... ... checkSlow(startTime, "startProcess: stepping in to startProcess"); final boolean success = startProcessLocked(app, hostingRecord, abiOverride); checkSlow(startTime, "startProcess: done starting proc!"); return success ? app : null; } boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord, boolean disableHiddenApiChecks, boolean mountExtStorageFull, String abiOverride) { ... ... try { ... ... // Start the process. It will either succeed and return a result containing // the PID of the new process, or else throw a RuntimeException. final String entryPoint = "android.app.ActivityThread"; return startProcessLocked(hostingRecord, entryPoint, app, uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith, startTime); } catch (RuntimeException e) { Slog.e(ActivityManagerService.TAG, "Failure starting process " + app.processName, e); // Something went very wrong while trying to start this process; one // common case is when the package is frozen due to an active // upgrade. To recover, clean up any active bookkeeping related to // starting this process. (We already invoked this method once when // the package was initially frozen through KILL_APPLICATION_MSG, so // it doesn't hurt to use it again.) mService.forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid), false, false, true, false, false, app.userId, "start failure"); return false; } } boolean startProcessLocked(HostingRecord hostingRecord,String entryPoint, ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal, String seInfo, String requiredAbi, String instructionSet, String invokeWith,long startTime) { ... ... final Process.ProcessStartResult startResult = startProcess(app.hostingRecord,entryPoint, app, app.startUid, gids, runtimeFlags, mountExternal,app.seInfo, requiredAbi, instructionSet, invokeWith, app.startTime); ... ... } private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint, ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal, String seInfo, String requiredAbi, String instructionSet, String invokeWith, long startTime) { try { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " + app.processName); checkSlow(startTime, "startProcess: asking zygote to start proc"); final Process.ProcessStartResult startResult; if (hostingRecord.usesWebviewZygote()) { ... ... } else if (hostingRecord.usesAppZygote()) { final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app); startResult = appZygote.getProcess().start(entryPoint, app.processName, uid, uid, gids, runtimeFlags, mountExternal, app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet, app.info.dataDir, null, app.info.packageName, /*useUsapPool=*/ false, new String[] {PROC_START_SEQ_IDENT + app.startSeq}); } else { ... ... } checkSlow(startTime, "startProcess: returned from zygote!"); return startResult; } finally { Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); } }这里有几个我们需要关注的点，一个是第二个方法界说的entryPoint="android.app.ActivityThread"，这个就是背面创建历程时会通过反射调用到的类，再来看末了一个方法，这里会实行else if语句，也就是实行ZygoteProcess的start（）方法。终极到 ZygoteProcess 的attemptUsapSendArgsAndGetResult 通过 Socket 通讯，fork 一个新的 Launcher 历程，调用过程如图：
ZygoteProcess.attemptZygoteSendArgsAndGetResult()
// ZygoteProcess.java private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult( ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx { try { final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter; final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream; zygoteWriter.write(msgStr);把应用历程的一些参数写给前面毗连的zygote历程 zygoteWriter.flush();//进入Zygote历程，处于壅闭状态 //从socket中得到zygote创建的应用pid，赋值给 ProcessStartResult的对象 Process.ProcessStartResult result = new Process.ProcessStartResult(); result.pid = zygoteInputStream.readInt(); result.usingWrapper = zygoteInputStream.readBoolean(); return result; } catch (IOException ex) { zygoteState.close(); } }Zygote历程处置惩罚
ZygoteInit.main
public static void main(String argv[]) { Runnable caller; if (startSystemServer) { //Zygote Fork出的第一个历程 SystmeServer Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer); if (r != null) { r.run(); return; } } //循环等待fork出其他的应用历程，好比Launcher caller = zygoteServer.runSelectLoop(abiList); ... if (caller != null) { caller.run(); //实行runSelectLoop返回的Runnable对象，进入子历程 }}ZygoteServer.runSelectLoop
Runnable runSelectLoop(String abiList) { while (true) { int pollReturnValue; try { //epoll机制 循环 pollReturnValue = Os.poll(pollFDs, pollTimeoutMs); } catch (ErrnoException ex) { throw new RuntimeException("poll failed", ex); } ... //来了消息后，调用processOneCommand()来举行历程的处置惩罚 final Runnable command = connection.processOneCommand(this); } }ZygoteConnection.processOneCommand
Runnable processOneCommand(ZygoteServer zygoteServer) { //fork历程，得到新历程pid //pid=0 表现Zygote fork子历程乐成 //pid > 0 表现子历程 的真正的PID pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids, parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo, parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote, parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mIsTopApp, parsedArgs.mPkgDataInfoList, parsedArgs.mWhitelistedDataInfoList, parsedArgs.mBindMountAppDataDirs, parsedArgs.mBindMountAppStorageDirs); try { //fork乐成，第一次返回的pid = 0 if (pid == 0) { return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote); } else { handleParentProc(pid, serverPipeFd); return null; }}** ZygoteConnection.handleChildProc**
这里重要实行到 ZygoteInit.zygoteInit，zygoteInit 举行一些环境的初始化、启动Binder历程等利用，终极反射实行 ActivityThread.main
private Runnable handleChildProc(ZygoteArguments parsedArgs, FileDescriptor pipeFd, boolean isZygote) { closeSocket(); Zygote.setAppProcessName(parsedArgs, TAG); if (!isZygote) { //App历程将会调用到这里，终极反射实行ActivityThread.main return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mDisabledCompatChanges, parsedArgs.mRemainingArgs, null /* classLoader */); } else { return ZygoteInit.childZygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mRemainingArgs, null /* classLoader */); } }Zygote历程调用栈:
ActivityThread中处置惩罚
Zygote fork出了 Launcher 的历程，并把接下来的 Launcher 启动任务交给了 ActivityThread 来举行，接下来我们就从 ActivityThread.main方法来分析 Launcher 的创建过程。
// ActivityThread.java public static void main(String[] args) { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); ... ... //创建主线程Looper Looper.prepareMainLooper(); ... ... ActivityThread thread = new ActivityThread(); //实行attach ... ... thread.attach(false, startSeq); //开启循环 ... ... Looper.loop(); throw new RuntimeException("Main thread loop unexpectedly exited"); }这里就是android层面分别为一个应用历程的开始，初始化一个looper，也就是android中说的主线程，并开始looper循环，这里调用到了ActivitThread.attach() :
// ActivityThread.java private void attach(boolean system, long startSeq) { sCurrentActivityThread = this; mSystemThread = system; if (!system) { ... ... // 这里会拿到ActivityManagerService的署理 final IActivityManager mgr = ActivityManager.getService(); try { //应用的句柄发给AMS，从而使AMS可以管理新历程 mgr.attachApplication(mAppThread, startSeq); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } ... ... } else { // 在前面讲Zygote历程的时间，里面创建ActivityThread就会实行到这里 } //当系统配置发生变更时会实行这个回调 ViewRootImpl.ConfigChangedCallback configChangedCallback = (Configuration globalConfig) -> { ... ... }; ViewRootImpl.addConfigCallback(configChangedCallback); }这里会实行if语句里面的内容，mAppThread的范例是ApplicationThread，这个类的重要作用是在ActivityManagerService中回调回ActivityThread中来，mgr是ActivityManagerService的署理，在实行它的ActivityManagerService.attachApplication() 方法：
// ActivityManagerService.java public final void attachApplication(IApplicationThread thread, long startSeq) { synchronized (this) { int callingPid = Binder.getCallingPid(); final int callingUid = Binder.getCallingUid(); final long origId = Binder.clearCallingIdentity(); attachApplicationLocked(thread, callingPid, callingUid, startSeq); Binder.restoreCallingIdentity(origId); } }ActivityManagerService.attachApplicationLocked()
调用AMS的 attachApplication()，终极层层调用到 ActivityStackSupervisor 的 realStartActivityLocked，真正准备去启动Activity。
private final boolean attachApplicationLocked(IApplicationThread thread,int pid, int callingUid, long startSeq) { ... ... //这里会去调用ActivityThrea的bindApplication(),也就是会去创建Application thread.bindApplication(... ...) ... ... //如果当前的Application记载仍旧依附到之前的历程中，则清理掉 if (app.thread != null) { handleAppDiedLocked(app, true, true); } ... ... // See if the top visible activity is waiting to run in this process... if (normalMode) { try { //调用ActivityTaskManagerService的attachApplication()，终极层层调用到ActivityStackSupervisor.java的 realStartActivityLocked() didSomething = mAtmInternal.attachApplication(app.getWindowProcessController()); } catch (Exception e) { Slog.wtf(TAG, "Exception thrown launching activities in " + app, e); badApp = true; } } ... ... }这里通过AMS终极会调用到ActivityStackSupervisor.realStartActivityLocked()：
// ActivityStackSupervisor.java boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException { //确保全部的Activity实行了onPause才会往下继续实行 if (!mRootActivityContainer.allPausedActivitiesComplete()) { // While there are activities pausing we skipping starting any new activities until // pauses are complete. NOTE: that we also do this for activities that are starting in // the paused state because they will first be resumed then paused on the client side. if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE, "realStartActivityLocked: Skipping start of r=" + r + " some activities pausing..."); return false; } ... ... try { ... ... try{ ... ... // Create activity launch transaction. final ClientTransaction clientTransaction = ClientTransaction.obtain( proc.getThread(), r.appToken); final DisplayContent dc = r.getDisplay().mDisplayContent; //在回调序列的末端添加一条消息 clientTransaction.addCallback(LaunchActivityItem.obtain(... ...)); // Set desired final state. final ActivityLifecycleItem lifecycleItem; if (andResume) { lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward()); } else { lifecycleItem = PauseActivityItem.obtain(); } //添加末了实行的生命周期状态 clientTransaction.setLifecycleStateRequest(lifecycleItem); // 这里实在就是实行ClientTransaction的schedule()方法 mService.getLifecycleManager().scheduleTransaction(clientTransaction); ... ... } catch (RemoteException e) { if (r.launchFailed) { // 第二次启动失败，finish activity并放弃启动 Slog.e(TAG, "Second failure launching " + r.intent.getComponent().flattenToShortString() + ", giving up", e); proc.appDied(); stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null, "2nd-crash", false); return false; } //第一次启动失败，实验重启历程 r.launchFailed = true; proc.removeActivity(r); throw e; } } finally { endDeferResume(); } ... ... return true; }ActivityThread调用栈:
小结
至此已经走到 realStartActivityLocked，接下来就是 Activity 的启动流程，Activity 启动下篇文章会单独分析。总结一下 Launcher 启动流程，Launcher的启动颠末了三个阶段：
1、SystemServer 创建AMS和ATMS，通过 SystemReady 进入 LauncherActivity 的调用
2、Zygote 历程 fork 出 Launcher 历程，通过 Socket 举行通讯
3、进入 ActivityThread 的处置惩罚，完成 Launcher 的 Acitivty 启动 |
