一、AMS是如何被管理的

如我们在Android 11(R)启动流程中介绍的一样，AMS和ATMS是在SystemServer中被启动的

ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);

由SystemServiceManager启动具体的服务，从代码可以看出这里启动的是ActivityTaskManagerService.Lifecycle，并没有直接启动ActivityTaskManagerService。这是因为ActivityTaskManagerService只能有一个父类，要继承IActivityTaskManager.Stub，如果想要使用SystemService统一管理atms服务，但atms又无法在继承SystemService。因此需要实现了一个内部静态内部类Lifecycle来继承SystemService并且实例化ActivityTaskManagerService。

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {.....}

public static final class Lifecycle extends SystemService {private final ActivityTaskManagerService mService;public Lifecycle(Context context) {super(context);mService = new ActivityTaskManagerService(context);}@Overridepublic void onStart() {publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);mService.start();}public ActivityTaskManagerService getService() {return mService;}
}

然后通过publishBinderService将服务公布到了ServiceManager中，application就可以通过ServiceManager拿到AMS进行通信

publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);

二、AMS 的启动

在ams的start函数中，初始化了很多服务，还添加了很多服务到servicemanager中

private void start() {removeAllProcessGroups();mProcessCpuThread.start();//启动cpu监控线程mBatteryStatsService.publish();//注册电池状态和权限管理服务mAppOpsService.publish();Slog.d("AppOps", "AppOpsService published");LocalServices.addService(ActivityManagerInternal.class, mInternal);mActivityTaskManager.onActivityManagerInternalAdded();mPendingIntentController.onActivityManagerInternalAdded();// Wait for the synchronized block started in mProcessCpuThread,// so that any other access to mProcessCpuTracker from main thread// will be blocked during mProcessCpuTracker initialization.try {mProcessCpuInitLatch.await();} catch (InterruptedException e) {Slog.wtf(TAG, "Interrupted wait during start", e);Thread.currentThread().interrupt();throw new IllegalStateException("Interrupted wait during start");}
}//初始化电源管理服务
SystemServer.java   mActivityManagerService.initPowerManagement
//核心内容，为APP进程安排系统进程以便后期监控
SystemServer.java    mActivityManagerService.setSystemProcess();

public void setSystemProcess() {try {//添加ams服务到ServiceManagerServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);//添加ProcessStats服务到ServiceManagerServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);//添加meminfo服务到ServiceManagerServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,DUMP_FLAG_PRIORITY_HIGH);//添加gfxinfo服务到ServiceManager  图像信息ServiceManager.addService("gfxinfo", new GraphicsBinder(this));//添加dbinfo服务到ServiceManager  数据库信息ServiceManager.addService("dbinfo", new DbBinder(this));if (MONITOR_CPU_USAGE) {//添加cpuinfo服务到ServiceManager  cpu信息ServiceManager.addService("cpuinfo", new CpuBinder(this),/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);}//添加permission服务到ServiceManager  权限和进程信息ServiceManager.addService("permission", new PermissionController(this));//添加processinfo服务到ServiceManager  进程信息ServiceManager.addService("processinfo", new ProcessInfoService(this));//添加cacheinfo服务到ServiceManager  缓存信息ServiceManager.addService("cacheinfo", new CacheBinder(this));ApplicationInfo info = mContext.getPackageManager().getApplicationInfo("android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());synchronized (this) {//创建ProcessRecord维护进程的相关信息ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,false,0,new HostingRecord("system"));app.setPersistent(true);app.pid = app.mPidForCompact = MY_PID;app.getWindowProcessController().setPid(MY_PID);app.maxAdj = ProcessList.SYSTEM_ADJ;app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);addPidLocked(app);mProcessList.updateLruProcessLocked(app, false, null);updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);}} catch (PackageManager.NameNotFoundException e) {throw new RuntimeException("Unable to find android system package", e);}// Start watching app ops after we and the package manager are up and running.mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,new IAppOpsCallback.Stub() {@Override public void opChanged(int op, int uid, String packageName) {if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {if (getAppOpsManager().checkOpNoThrow(op, uid, packageName)!= AppOpsManager.MODE_ALLOWED) {runInBackgroundDisabled(uid);}}}});final int[] cameraOp = {AppOpsManager.OP_CAMERA};mAppOpsService.startWatchingActive(cameraOp, new IAppOpsActiveCallback.Stub() {@Overridepublic void opActiveChanged(int op, int uid, String packageName, boolean active) {cameraActiveChanged(uid, active);}});
}

三、Application 进程启动流程

在做activity流程分析之前，先明确一下AMS和ATMS的不同，ATMS是在android 11版本从AMS中分离出来的

ATMS:只做activity的管理

AMS：管理四大组件

首先看下Activity启动的流程图

启动方式一般有两种

1.在launcher里面点击启动

2.在某一个app里面去启动另外一个app

APP进程的启动

在启动activity时会判断进程是否存在

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;//进程创建的情况下直接启动activityif (wpc != null && wpc.hasThread()) {try {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();//进程不存在，为app启动一个进程mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}

ActivityStackSupervisor.java  startSpecificActivity（判断app进程是否存在，存在时启动activity，不存在时去创建进程） -》

ActivityManagerService.java -> LocalService ->  startProcess -》

startProcessLocked-》

ProcessList.java . startProcessLocked （这里会经过多个startProcessLocked ）-》

startProcess-》

Process.start-》

ZYGOTE_PROCESS.start-》

startViaZygote-》

zygoteSendArgsAndGetResult-》

attemptZygoteSendArgsAndGetResult-》

zygoteWriter.write(msgStr);  发送socket消息给zygote

可以看到startProcessLocked最后返回一个ProcessRecord，processrecord就是进程在ams层面的表现形式。所有的ProcessRecord都由mProcessList进行统一管理。

ProcessList.java中有个mLruProcesses维持所有正在运行的进程。

/*** List of running applications, sorted by recent usage.* The first entry in the list is the least recently used.*/
final ArrayList<ProcessRecord> mLruProcesses = new ArrayList<ProcessRecord>();

在zygote进程中，启动了socket服务器去监听消息

zygoteServer = new ZygoteServer(isPrimaryZygote);
caller = zygoteServer.runSelectLoop(abiList);

runSelectLoop-》

Zygote.forkAndSpecialize-》

nativeForkAndSpecialize-》

com_android_internal_os_Zygote_nativeForkAndSpecialize-》

fork-》

pid ==0表示子进程

-》zygoteServer.closeServerSocket();关掉socket服务器，避免多服务器问题-》

handleChildProc-》

ZygoteInit.zygoteInit-》

public static final Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,String[] argv, ClassLoader classLoader) {if (RuntimeInit.DEBUG) {Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");}Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");RuntimeInit.redirectLogStreams();RuntimeInit.commonInit();//初始化运行环境ZygoteInit.nativeZygoteInit();//启动Binderreturn RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,classLoader);
}

RuntimeInit.commonInit();//初始化运行环境

ZygoteInit.nativeZygoteInit();-》

          app_main.cpp   onZygoteInit-》

           new ProcessState->

           mDriverFD(open_driver(driver) //初始化binder驱动

proc->startThreadPool  //启动Binder线程池

RuntimeInit.applicationInit -》

findStaticMain-》

getMethod  //这里通过反射找到ActivityThread中的main函数

最后在ZygoteInit.java中会调用caller.run();在通过invoke调用main函数。

上面代码逻辑画成流程图

四、AMS如何获取application的binder

在ActivityThread.java中创建了ActivityThread对象，调用attch函数将application的binder给到AMS

ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);private void attach(boolean system, long startSeq) {
......if (!system) {android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",UserHandle.myUserId());final IActivityManager mgr = ActivityManager.getService();mgr.attachApplication(mAppThread, startSeq);
......
}

ActivityManagerService.java   attachApplication-》

attachApplicationLocked

在attachApplicationLocked核心是类型为ProcessRecord 的 app变量。

同时在ProcessRecord中有一个很重要的变量，如下图。

在attachApplicationLocked中会调用下面这行将thread设置给ProcessRecord

app.makeActive(thread, mProcessStats);

因此后面AMS如果要调用app 的binder，只需要通过

final ProcessList mProcessList = new ProcessList();这个变量拿到

五、AMS用app的binder做了什么？

AMS在将binder传递给ProcessRecord之前，还会调用bindApplication，实际上是调用的ActivityThread.java的bindApplication函数。

构建Application 对象，用Application来管理相关生命周期等

这个函数里面会调用安装provider组件

ams对application的持有链条

然后去调用application的onCreate，这里意味着application已经启动

mInstrumentation.callApplicationOnCreate(app);public void callApplicationOnCreate(Application app) {app.onCreate();
}

最后，在ams中会将app 添加到 mProcessList列表中

mProcessList.updateLruProcessLocked(app, false, null);mLruProcesses.add(index, app);

接下来就会去管理activity的生命周期

mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);public boolean attachApplication(WindowProcessController wpc) throws RemoteException {synchronized (mGlobalLockWithoutBoost) {if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);}try {return mRootWindowContainer.attachApplication(wpc);} finally {Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);}}
}

六、Activity生命周期全流程

ActivityStarter类用于解析activity启动参数

ActivityTaskManagerService.java  startActivityAsUser -》

getActivityStartController().obtainStarter  -》

mFactory.obtain-》mStarterPool.acquire();  这里从Factory的pool中拿ActivityStarter对象，这样可以减小内存抖动。这里获取ActivityStarter对象后会设置caller等，最后调用execute。

这里的设置变量最后都保存在ActivityStarter的内部类Request中，

return getActivityStartController().obtainStarter(intent, "startActivityAsUser").setCaller(caller).setCallingPackage(callingPackage).setCallingFeatureId(callingFeatureId).setResolvedType(resolvedType).setResultTo(resultTo).setResultWho(resultWho).setRequestCode(requestCode).setStartFlags(startFlags).setProfilerInfo(profilerInfo).setActivityOptions(bOptions).setUserId(userId).execute();

execute-》

executeRequest  executeRequest中会读取request中的参数-》

new ActivityRecord  

创建出目标ActivityRecord  对象，存到传入数组0索引上。在ams中，这里构建一个activity实例

-》mController.doPendingActivityLaunches(false);

这里去启动因为各种原因导致pending的activity

-》startActivityUnchecked  此次需要启动的activity

-》startActivityInner

    @VisibleForTestingint startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, boolean doResume, ActivityOptions options, Task inTask,boolean restrictedBgActivity, NeededUriGrants intentGrants) {......//判断是否是新任务,如果是，targetTaskTop将为null，否则，targetTaskTop指向目标任务栈中栈顶        没有Finishing的Activityfinal ActivityRecord targetTaskTop = newTask? null : targetTask.getTopNonFinishingActivity();if (targetTaskTop != null) {// Recycle the target task for this launch.startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);if (startResult != START_SUCCESS) {return startResult;}} else {mAddingToTask = true;}
.....if (mTargetStack == null) {mTargetStack = getLaunchStack(mStartActivity, mLaunchFlags, targetTask, mOptions);}//调用RootTask，startActivitymTargetStack.startActivityLocked(mStartActivity,topStack != null ? topStack.getTopNonFinishingActivity() : null, newTask,}

-》mTargetStack.startActivityLocked  启动黑白屏

-》mRootWindowContainer.resumeFocusedStacksTopActivities

RootWindowContainer是窗口容器（WindowContainer）的根容器，管理了所有窗口容器，

设备商所有的窗口（Window）、显示（Display）都是由它来管理的

//resumeFocusedStacksTopActivities 会恢复对应任务栈顶部的Activity

-》resumeTopActivityUncheckedLocked

//开始activity的协议阶段，在栈中进行管理activity

-》startPausingLocked

如果有正在运行的activity，执行它的onpause生命周期

-》next.attachedToProcess() 这里判断为false

-》mStackSupervisor.startSpecificActivity     ActivityStackSupervisor是管理activitystack的类

     将activity启动封装成一个事务，事务最终要传递给App

-》realStartActivityLocked  进程存在直接进入启动activity

-》

//组要包含两个内容：一个是要处理的一系列的生命周期事件
//还有一个是这个Client在执行一系列事件后最终的LifeCycle状态
//一系列的事件是由callback的列表控制，而最终的lifecycle状态则由mLifecycleStateRequest控制public class ClientTransaction implements Parcelable, ObjectPoolItem {
.../** A list of individual callbacks to a client. */@UnsupportedAppUsageprivate List<ClientTransactionItem> mActivityCallbacks;/** Target client activity. Might be null if the entire transaction is targeting an app. *///目标进程的activityprivate IBinder mActivityToken;/** Target client. *///目标进程private IApplicationThread mClient;
}boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,boolean andResume, boolean checkConfig) throws RemoteException {//创建ClientTransaction对象final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);//添加LaunchActivityItemclientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),System.identityHashCode(r), r.info,// TODO: Have this take the merged configuration instead of separate global// and override configs.mergedConfiguration.getGlobalConfiguration(),mergedConfiguration.getOverrideConfiguration(), r.compat,r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),r.getSavedState(), r.getPersistentSavedState(), results, newIntents,dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));final ActivityLifecycleItem lifecycleItem;if (andResume) {lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());} else {lifecycleItem = PauseActivityItem.obtain();}clientTransaction.setLifecycleStateRequest(lifecycleItem);// Schedule transaction.//获取生命周期管理类  ClientLifeCycleManager，并执行事务mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}

/*** Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.* @param transaction A sequence of client transaction items.* @throws RemoteException** @see ClientTransaction*/
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {final IApplicationThread client = transaction.getClient();transaction.schedule();if (!(client instanceof Binder)) {// If client is not an instance of Binder - it's a remote call and at this point it is// safe to recycle the object. All objects used for local calls will be recycled after// the transaction is executed on client in ActivityThread.transaction.recycle();}
}//通过mClient 也就是IApplicationThread跨进程调用到应用进程
/*** Schedule the transaction after it was initialized. It will be send to client and all its* individual parts will be applied in the following sequence:* 1. The client calls {@link #preExecute(ClientTransactionHandler)}, which triggers all work*    that needs to be done before actually scheduling the transaction for callbacks and*    lifecycle state request.* 2. The transaction message is scheduled.* 3. The client calls {@link TransactionExecutor#execute(ClientTransaction)}, which executes*    all callbacks and necessary lifecycle transitions.*/
public void schedule() throws RemoteException {mClient.scheduleTransaction(this);
}从这里开始一次垮进程调用，调用到ActivityThread.java里面的scheduleTransactionpublic abstract class ClientTransactionHandler {// Schedule phase related logic and handlers./** Prepare and schedule transaction for execution. */void scheduleTransaction(ClientTransaction transaction) {transaction.preExecute(this);sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);}
......
}//最终执行到ActivityThread.java中case EXECUTE_TRANSACTION:final ClientTransaction transaction = (ClientTransaction) msg.obj;mTransactionExecutor.execute(transaction);if (isSystem()) {// Client transactions inside system process are recycled on the client side// instead of ClientLifecycleManager to avoid being cleared before this// message is handled.transaction.recycle();}// TODO(lifecycler): Recycle locally scheduled transactions.break;

TransactionExecutor.java    execute

这里的executeCallbacks 和executeLifecycleState执行的都是ams中添加后过来的，下面先看executeCallbacks流程

    public void execute(ClientTransaction transaction) {......executeCallbacks(transaction);executeLifecycleState(transaction);mPendingActions.clear();if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");}

-》executeCallbacks

//遍历callbacks数组
for (int i = 0; i < size; ++i) {//从callbacks数组中取出itemfinal ClientTransactionItem item = callbacks.get(i);if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callback: " + item);final int postExecutionState = item.getPostExecutionState();final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,item.getPostExecutionState());if (closestPreExecutionState != UNDEFINED) {cycleToPath(r, closestPreExecutionState, transaction);}//调用launchActivityItem的execute方法item.execute(mTransactionHandler, token, mPendingActions);item.postExecute(mTransactionHandler, token, mPendingActions);if (r == null) {// Launch activity request will create an activity record.r = mTransactionHandler.getActivityClient(token);}if (postExecutionState != UNDEFINED && r != null) {// Skip the very last transition and perform it by explicit state request instead.final boolean shouldExcludeLastTransition =i == lastCallbackRequestingState && finalState == postExecutionState;cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);}
}

-》item.execute

-》LaunchActivityItem.java   

    @Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,mPendingResults, mPendingNewIntents, mIsForward,mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);client.handleLaunchActivity(r, pendingActions, null /* customIntent */);Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);}

public void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,mPendingResults, mPendingNewIntents, mIsForward,mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);client.handleLaunchActivity(r, pendingActions, null /* customIntent */);Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}//activity的真实实例/** Activity client record, used for bookkeeping for the real {@link Activity} instance. */public static final class ActivityClientRecord {}

 -》performLaunchActivity

-》

activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);

-》

//会在这个方法中创建Activity的phonewindow,并绑定对应的WindowManager
activity.attach(appContext, this, getInstrumentation(), r.token,r.ident, app, r.intent, r.activityInfo, title, r.parent,r.embeddedID, r.lastNonConfigurationInstances, config,r.referrer, r.voiceInteractor, window, r.configCallback,r.assistToken);

-》

{
............//设置mLifecycleState为ON_CREATE，调用activity的onCreateif (r.isPersistable()) {mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);} else {mInstrumentation.callActivityOnCreate(activity, r.state);}if (!activity.mCalled) {throw new SuperNotCalledException("Activity " + r.intent.getComponent().toShortString() +" did not call through to super.onCreate()");}r.activity = activity;mLastReportedWindowingMode.put(activity.getActivityToken(),config.windowConfiguration.getWindowingMode());}//设置mLifecycleState 为ON_CREATEr.setState(ON_CREATE);

再看executeLifecycleState流程

    private void executeLifecycleState(ClientTransaction transaction) {//获取ActivityLifeCycleItem，这里获取的是我们之前添加的ResumeActivityItemfinal ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();if (lifecycleItem == null) {// No lifecycle request, return early.return;}............// Cycle to the state right before the final requested state.//ResumeActivityItem 的getTargetState 是ON_RESUMEcycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);// Execute the final transition with proper parameters.//执行ResumeActivityItem的executelifecycleItem.execute(mTransactionHandler, token, mPendingActions);lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);}

executeLifecycleState去获取ActivityLifecycleItem的值，这个值是在构建clientTransaction时在ActivityStackSupervisor.java中设置的

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

然后进入cycleToPath函数

private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,ClientTransaction transaction) {final int start = r.getLifecycleState();//这里的start是ON_CREATEif (DEBUG_RESOLVER) {Slog.d(TAG, tId(transaction) + "Cycle activity: "+ getShortActivityName(r.token, mTransactionHandler)+ " from: " + getStateName(start) + " to: " + getStateName(finish)+ " excludeLastState: " + excludeLastState);}//这里的start是ON_CREATE,finish是ON_RESUME//调用getLifecyclePath返回的path包含ON_START  和  ON_RESUME//这里是Activity 执行onStart 函数的关键所在final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);//执行path中的相关的生命周期函数performLifecycleSequence(r, path, transaction);
}

-》mHelper.getLifecyclePath

        -》

if (finish >= start) {//走到此分支  3 >= 1if (start == ON_START && finish == ON_STOP) {// A case when we from start to stop state soon, we don't need to go// through the resumed, paused state.mLifecycleSequence.add(ON_STOP);} else {// just go there// start 为 1，i <= 3，add会将 2 3 都加入到mlifecyclesqquence中for (int i = start + 1; i <= finish; i++) {mLifecycleSequence.add(i);}}// Remove last transition in case we want to perform it with some specific params.//因为excludeLastState 为true，所以删除掉ON_RESUME状态if (excludeLastState && mLifecycleSequence.size() != 0) {mLifecycleSequence.remove(mLifecycleSequence.size() - 1);}
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path,ClientTransaction transaction) {//通过mHelper调用getLifecyclePath返回的path,是ON_START
state = path.get(i);
switch (state) {
....case ON_START:mTransactionHandler.handleStartActivity(r.token, mPendingActions);
}
....
}

        -》activity.performStart

-》ResumeActivityItem.java    lifecycleItem.execute

-》client.handleResumeActivity

-》ActivityThread.java  handleResumeActivity

-》performResumeActivity

-》r.activity.performResume

MainActivity启动流程-生命周期触发器触发执行阶段

启动activity的activity stop阶段

 activity resume之后，往handler里面添加了一个事件

Looper.myQueue().addIdleHandler(new Idler());

private class Idler implements MessageQueue.IdleHandler {@Overridepublic final boolean queueIdle() {
.......if (a != null) {mNewActivities = null;IActivityTaskManager am = ActivityTaskManager.getService();ActivityClientRecord prev;do {if (localLOGV) Slog.v(TAG, "Reporting idle of " + a +" finished=" +(a.activity != null && a.activity.mFinished));if (a.activity != null && !a.activity.mFinished) {try {am.activityIdle(a.token, a.createdConfig, stopProfiling);a.createdConfig = null;} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}}prev = a;a = a.nextIdle;prev.nextIdle = null;} while (a != null);}
...........}
}

可以看到，在handler空闲阶段，会去执行ams里面的activityIdle

-》mStackSupervisor.activityIdleInternal

-》processStoppingAndFinishingActivities

private void processStoppingAndFinishingActivities(ActivityRecord launchedActivity,boolean processPausingActivities, String reason) {//在这个数组里面遍历需要暂停的activityfor (int i = mStoppingActivities.size() - 1; i >= 0; --i) {final ActivityRecord s = mStoppingActivities.get(i);final boolean animating = s.isAnimating(TRANSITION | PARENTS,ANIMATION_TYPE_APP_TRANSITION | ANIMATION_TYPE_RECENTS);if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + s.nowVisible+ " animating=" + animating + " finishing=" + s.finishing);if (!animating || mService.mShuttingDown) {if (!processPausingActivities && s.isState(PAUSING)) {// Defer processing pausing activities in this iteration and reschedule// a delayed idle to reprocess it againremoveIdleTimeoutForActivity(launchedActivity);scheduleIdleTimeout(launchedActivity);continue;}if (DEBUG_STATES) Slog.v(TAG, "Ready to stop: " + s);if (readyToStopActivities == null) {readyToStopActivities = new ArrayList<>();}readyToStopActivities.add(s);mStoppingActivities.remove(i);}}//轮询然后调用stop 或 destroyfor (int i = 0; i < numReadyStops; i++) {final ActivityRecord r = readyToStopActivities.get(i);if (r.isInHistory()) {if (r.finishing) {// TODO(b/137329632): Wait for idle of the right activity, not just any.r.destroyIfPossible(reason);} else {r.stopIfPossible();}}}}

-》stopIfPossible

-》mAtmService.getLifecycleManager().scheduleTransaction

-》ClientLifecycleManager.java   scheduleTransaction  封装ClientTransaction

void scheduleTransaction(@NonNull IApplicationThread client,@NonNull ClientTransactionItem callback) throws RemoteException {final ClientTransaction clientTransaction = transactionWithCallback(client,null /* activityToken */, callback);scheduleTransaction(clientTransaction);
}