Android Framework源码——Activity启动流程
前言
Activity 类是 android 应用的关键组件，在日常开发中，绝对少不了组件。既然用了这么久，你知道他的启动流程？作为一个应用层开发者，大多数人可能觉得学习这些对日常开发可能没有太大帮助。但是多了解一下 framework 的代码还是很有必要的，了解系统组件机制，对于一些问题我们也能快速的定位找到问题的所在点，并且在面试的时候也是一个加分项。
本文基于 Android 12 版本源码，从 startActivity 作为切入点，对整个启动流程进行分析。
Activity 启动方式
启动一个 Activity，通常有两种情况，一种是在应用内部启动 Activity，另一种是 Launcher 启动。
-
应用内启动
通过 startActivity 来启动 Activity
-
Launcher 进程启动
Launcher 就是我们桌面程序，当系统开机后， Launcher 也随之被启动，然后将已经安装的 app 显示在桌面上，等到点击某一个 app 的时候就会 fock 一个新的进程，然后启动 Activity
这篇文章主要来看一下应用内启动 Activity 是一个怎样的流程
一，Activity -> ATMS
众所周知，一般情况下Activity 的启动方式有下面种：
- startActivity(Intent intent)：直接启动一个 Activity
- startActivityForResult(Intent intent, int requestCode)：带返回值的启动方式，这种启动方式已经被官方所废弃，取而代之的是
registerForActivityResult(contract, mActivityResultRegistry, callback)
我们从 startActivity 来一步步往下看：
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
......
//execStartActivity
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
//分析启动结果
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
......
} else {
if (options != null) {
//这里最终也是调用 execStartActivity 方法
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}
上面代码中，调用了 execStartActivity 方法，该方法会返回一个启动结果。最下面的的 startActivityFromChild 方法最终也是调用的 execStartActivity。
我们先看一下该方法的参数：
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
}
-
Context who ：传入的是 this，用来启动 Activity 的对象
-
Ibinder contextThread：Binder 对象，具有跨进程通信的能力，传入的是 mMainThread.getApplicationThread()
public ApplicationThread getApplicationThread(){ return mAppThread; } final ApplicationThread mAppThread = new ApplicationThread(); private class ApplicationThread extends IApplicationThread.Stub { ..... }ApplicationThread 是 Activitythread 的内部类，就是通过 AIDL 创建的一个远程服务的接口，用来与服务端进行交互，该对象会被传入到 AMS 中，在 AMS 中回保存他的 client（客户端），这样 AMS 就可以与应用进程进行通信了
-
IBinder token：Binder 对象，指向了服务端一个 ActivityRecord 对象
-
Activity target：当前的 Activity
-
Intent intent, int requestCode, Bundle options ：Intent 对象，请求码和参数。
下面我们来看一下 execStartActivity 方法：
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
//应用端 AIDL 实现类
IApplicationThread whoThread = (IApplicationThread) contextThread;
.......
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
//通过 Binder 调用 ATMS 启动 Activity
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
//获取单例
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton IActivityTaskManagerSingleton =
new Singleton() {
@Override
protected IActivityTaskManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
我们可以用一张图来表示上述的流程：
上面代码中通过 getService 获取到 Binder 对象，然后将 Binder 转成 AIDL 接口所属的类型，接着就可以调用 AIDL 中的方法与服务端进行通信了。
接着调用 ATMS 中的 startActivity() 方法发起启动 Activity 请求，获得启动结果 result。在调用 checkStartActivityResult 方法，传入 result，来判断能否启动 Activity，不能启动就会抛出异常，例如 activity 未在 manifest 中声明等。
二 、ATMS
通过上面的代码可以看出已经调用到了系统的 ATMS 当中，我们来看一下具体的流程
#ActivityTaskManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
#ActivityTaskManagerService.java
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
#ActivityTaskManagerService.java
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
@Nullable String callingFeatureId, Intent intent, String resolvedType,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
//检查调用者权限
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}
上面代码最终调用到了 startActivityAsUser 方法，在内部将所有点的参数都交给了 ActivityStarter ，该类包含了启动的所有逻辑，比如 Intent 解析以及任务栈等。
接着调用了obtainStarter ，该方法通过工厂模式创建了 ActivityStarter 对象，如下所示：
#ActivityStarter.java
static class DefaultFactory implements Factory {
/**
* ActivitySatrter 最大数量
*/
private final int MAX_STARTER_COUNT = 3;
......
//同步池
private SynchronizedPool mStarterPool =
new SynchronizedPool<>(MAX_STARTER_COUNT);
DefaultFactory(ActivityTaskManagerService service,
ActivityTaskSupervisor supervisor, ActivityStartInterceptor interceptor) {
mService = service;
mSupervisor = supervisor;
mInterceptor = interceptor;
}
@Override
public void setController(ActivityStartController controller) {
mController = controller;
}
@Override
public ActivityStarter obtain() {
//从同步池中获取 ActivityStarter 对象
ActivityStarter starter = mStarterPool.acquire();
if (starter == null) {
if (mService.mRootWindowContainer == null) {
throw new IllegalStateException("Too early to start activity.");
}
starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
}
return starter;
}
@Override
public void recycle(ActivityStarter starter) {
starter.reset(true /* clearRequest*/);
mStarterPool.release(starter);
}
}
可以看到，默认的工厂在提供了一个容量为 3 的同步缓存池来缓存 ActivityStarter 对象，该对象创建完成之后，该对象创建完成之后，AMTS 就会将接下来启动 Activity 的操作交给 ActivityStarter 来完成。
#ActivityStarter.java
//根据前面传入的参数解析一下必要的信息，并开始启动 Activity
int execute() {
try {
int res;
synchronized (mService.mGlobalLock) {
.....
res = executeRequest(mRequest);//开始执行请求
.....
return getExternalResult(res);
}
} finally {
onExecutionComplete();
}
}
#ActivityStarter.java
private int executeRequest(Request request) {
.......
//检测Activity启动的权限
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,requestCode, callingPid, callingUid, callingPackage, callingFeatureId,request.ignoreTargetSecurity, inTask != null, callerApp, resultRecord, resultRootTask);
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
callingPid, resolvedType, aInfo.applicationInfo);
abort |= !mService.getPermissionPolicyInternal().checkStartActivity(intent, callingUid,
callingPackage);
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp)
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setLaunchedFromPackage(callingPackage)
.setLaunchedFromFeature(callingFeatureId)
.setIntent(intent)
.setResolvedType(resolvedType)
.setActivityInfo(aInfo)
.setConfiguration(mService.getGlobalConfiguration())
.setResultTo(resultRecord)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setComponentSpecified(request.componentSpecified)
.setRootVoiceInteraction(voiceSession != null)
.setActivityOptions(checkedOptions)
.setSourceRecord(sourceRecord)
.build();
mLastStartActivityRecord = r;
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
return mLastStartActivityResult;
}
上面代码中会进行一些校验和判断权限，包括进程检查，intent检查，权限检查等，后面就会创建 ActivityRecord ，每个 Activity 都会对应一个 ActivityRecord 对象，接着就会调用 startActivityUnchecked 方法对要启动的 Activity 做任务栈管理。
#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;
final Task startedActivityRootTask;
try {
mService.deferWindowLayout();
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
startedActivityRootTask = handleStartResult(r, result);
mService.continueWindowLayout();
}
postStartActivityProcessing(r, result, startedActivityRootTask);
return result;
}
在大多数初步检查已经完成的情况下开始进行下一步确认拥有必要的权限。 上面的核心方法就是 startActivityInner() 用来检查启动所必须要有的权限
#ActivityStarter.java
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
//设置初始化状态
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
//判断启动模式，并且在 mLaunchFlags 上追加对应标记
computeLaunchingTaskFlags();
//设置 Activity 的栈
computeSourceRootTask();
//设置 LaunchFlags 到 intent 上
mIntent.setFlags(mLaunchFlags);
//决定是否应将新活动插入现有任务中。返回null, 如果不是则应将新活动添加到其中的任务进行活动记录
final Task reusedTask = getReusableTask();
......
//reusedTask 为 null 则计算是否存在可以使用的任务栈
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
//是否需要创建栈
final boolean newTask = targetTask == null;
mTargetTask = targetTask;
computeLaunchParams(r, sourceRecord, targetTask);
//检查是否允许在给定任务或新任务上启动活动
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
return startResult;
}
final 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;
}
//如果正在启动的活动与当前位于顶部的活动相同
//则需要检查它是否应该只启动一次
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
//复用或者创建新栈
if (mTargetRootTask == null) {
mTargetRootTask = getLaunchRootTask(mStartActivity, mLaunchFlags, targetTask, mOptions);
}
if (newTask) {
//新建一个 Task
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
//复用之前的 Task
addOrReparentStartingActivity(targetTask, "adding to task");
}
......
if (mDoResume) {
// 调用 resumeFocusedTasksTopActivities方法
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
.....
return START_SUCCESS;
}
在上面方法中，根据启动模式计算出 flag，然后在根据 flag 等条件判断要启动的 Activity 的 ActivityRecord 是需要新创建 Task 栈 还是加入到现有的 Task 栈。
在为 Activity 准备好 Task 栈之后，调用了 mRootWindowContainer.resumeFocuredTasksTopActivities 方法。
#RootWindowContainer.java
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
boolean result = false;
if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
|| getTopDisplayFocusedRootTask() == targetRootTask)) {
result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,deferPause);
}
return result;
}
#Task.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,boolean deferPause) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean someActivityResumed = false;
try {
// Protect against recursion.
mInResumeTopActivity = true;
....
someActivityResumed = resumeTopActivityInnerLocked(prev,options,deferPause);
} finally {
mInResumeTopActivity = false;
}
return someActivityResumed;
}
#Task.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
if (!mAtmService.isBooting() && !mAtmService.isBooted()) {
// Not ready yet!
return false;
}
// 在当前 Task 栈中找到最上层正在运行的 Activity
// 如果这个 Activity 没有获取焦点，那这个 Activity 将会被重新启动
ActivityRecord next = topRunningActivity(true /* focusableOnly */);
if (next.attachedToProcess()) {
......
} else {
......
//调用 ActivityTaskSupervisor.startSpecificActivity
mTaskSupervisor.startSpecificActivity(next, true, true);
}
return true;
}
#ActivityTaskSupervisor.java
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// 获取目标进程
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) {
}
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
// 进程不存在，则创建进程，并启动 Activity
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
如果进程不存在，则会创建进程，如果进程存在，则执行此方法
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
// 创建启动 Activity 的事务
// proc.getThread() 获取的是一个 IApplicationThread 对象
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final boolean isTransitionForward = r.isTransitionForward();
// 为事务设置 Callback LaunchActivityItem，在客户端时会被调用
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken,
activityClientController,
r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
r.getLaunchedFromBubble()));
// 生命周期对象
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
// 设置生命周期请求
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// 执行事务
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
return true;
}
上面代码的核心就是创建事务实例，然后来启动 Activity 。
ClientTransaction 是一个容器，里面包含了一些列的消息，这些消息会被发送到客户端，这些消息包括了一系列的回调和一个最终的生命周期状态。
ActivityLifecycleItem 用来请求 Activity 应该到达那个生命周期。
ClientLifecycleManager 用来执行事务
接着上面的代码往下走，就到了 scheduleTransaction()：
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
// AIDL 接口，在客户端被实现，也就是 app 中
final IApplicationThread client = transaction.getClient();
//执行事务
transaction.schedule();
if (!(client instanceof Binder)) {
transaction.recycle();
}
}
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
mClient 就是 IApplicationThread 的实例，这里是一个 IPC 调用，会直接调用到 App 进程中，并传入了 this，也就是 ClientTransaction 对象。
IApplicationThread 是 ApplicationThread 所实现的，他是 ActivityThread 的内部类：
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
我们用一张图来描述一下上面的流程
在上面代码中检查 intent 以及各种权限，并且会获取启动模式，设置启动 Activity 的Task，最后判断 Activity 所在的进程是否存活，如果不存在则创建，如果存在则会通过 IPC 回调到 ApplicationThread 中去。
三、ActivityThread
通过上面，我们知道了启动 Activity 最终有回调到 ApplicationThread，而它又是 ActivityThread 的子类。所以 上面代码最终调用到了 ActivityThread 的父类 ClientTransactionHandler 中:
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);//处理
//发送消息
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//创建的时候传入了 ActivityThread 实例
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
#ActivityThread$H
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
transaction.recycle();
}
break;
上面代码中通过 TransactionExecutor 来执行事务:
public void execute(ClientTransaction transaction) {
//执行回调
executeCallbacks(transaction);
//处理生命周期状态
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
//处理生命周期状态
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// 切换到对应的生命周期
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState();
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path, transaction);
}
//执行生命周期状态
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
由于是新启动的 Activity，所以最开始执行的是 ON_CREATE 状态，也就是 handleLaunchActivity 方法, 而 mTransactionHandler 则是从构造方法中传入的，所以这里调用你的就是 ActivityThread 中的方法。
#ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
//获取 Activity 的实例
final Activity a = performLaunchActivity(r, customIntent);
return a;
}
#ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
//反射创建 Activity
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
......
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
//如果没有 Application ，则进行创建
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
....
// 加载资源
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
// 调用 attach 方法
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, r.shareableActivityToken);
//回调 onCreate 方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
}
//设置当前状态
r.setState(ON_CREATE);
......
}
return activity;
}
回调到 ActivityThread 后，会发送一个 EXECUTE_TRANSACTION 消息，处理 system_server 传过来的 ClientTransaction。
具体的处理是在 TransactionExecutor 的 execute 方法中完成的，在里面会先执行各种回调，然后处理并切换到对应的生命周期。在根据对应的什么周期执行对应的方法。由于这里是新建的 aCTIVITY ，所以状态是 ON_CREATE，就会执行 handleLaunchActivity 方法。
接着就会调用 performLaunchActivity 创建 Activity 的实例，调用 attach 初始化 activity，最后回调 activity 中的 onCreate 方法。
总结一下流程
- 调用 Activity 的 startActivity 方法来启动目标 Activity
- 接着就会调用到 Instrunmentation 的 execStartActivity 方法，通过获取 ATMS 的 binder 代理对象，然后调用到 ATMS 的 startActivity 中去
- 调用到 ATMS 中后，会执行到
ActivityStarter的 execute 方法，内部最终执行到了 executeRequest ，接着就会进行一些校验和判断权限，包括进程检查，intent检查，权限检查等，后面就会创建ActivityRecord，用来保存 Activity 的相关信息， - 然后就会根据启动模式计算 flag ，设置启动 Activity 的 Task 栈。
- 在 ActivityTaskSupervisor 中检查要启动的 Activity 进程是否存在，存在则向客户端进程 ApplicationThread 回调启动 Activity，否则就创建进程。
- 会调到 ActivityThread 后在 TransactionExecute 中开始执行system_server回调回来的事务，处理各种回调，切换到对应的生命周期
- 最后又回调到 ActivityThread 的 handleLaunchActivity 来启动 Activity。在其中调用了 performLaunchActivity 方法。
- 在 performLaunchActivity 中通过反射创建 Activity 实例，如果没有 Application 则先进行创建，然后再调用Activity 的 attach 方法进行初始化，最后回调 activity 的 onCreate 方法。
最后
文章到这里就结束了，本文主要是分析了一下应用内 Activity 的启动过程，由于我对整个启动的细节也不是非常了解，所以文章中可能有一些错误的地方，如果有还请指出，谢谢。如果对你有用请用你发财的小手点个赞！
需要更多的Android Framework源码资料的可以扫描下方二维码领取！
本文转自 https://juejin.cn/post/7179901192229617724，如有侵权，请联系删除。
Android Framework学习指南，全家桶学习资料（含 Framework 开发揭秘、内核解析及高频面试真题）
Framework 即应用框架层，是 Android 架构 的关键组成部分，为我们开发应用程序提供了非常多的API，使得开发者通过简单调用API即可开始APP的开发，而不用详细了解 Android 系统纷繁复杂的底层知识。
为帮助大家了解 Framework 在整个 Android 架构中的功能与构造，系统的学习和掌握Android framework，这里特意联合了阿里P7架构师和谷歌技术团队共同整理了一份 Android framework 全家桶学习资料。
内容概要：《Android Framework 开发揭秘》；Android Framework 高频面试题总结；Android Framework 精编内核解析；Android 11.0 最新 Framework解析。
内容特点：条理清晰，含图像化表示更加易懂。
由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android Framework进阶学习指南》完整文档的可扫描下方卡片免费获取~
《Android Framework 开发揭秘》
目录
第一章 系统启动流程分析
● 第一节 Android启动概览
● 第二节 init.rc解析
● 第三节 Zygote
● 面试题
第二章 Binder解析
● 第一节 宏观认识Binder
● 第二节 binder的jni方法注册
● 第三节 binder驱动
● 第四节 数据结构
● 第五节 启动service_manager
● 第六节 获取service_manager
● 第七节 addService流程
● 第八节 Binder面试题全解析
第三章 Handler解析
● 第一节 源码分析
● 第二节 难点问题
● 第三节 Handler常见面试题
第四章 AMS解析
● 第一节 引言
● 第二节 Android架构
● 第三节 通信方式
● 第四节 系统启动系列
● 第五节 AMS
● 第六节 AMS面试题解析
第五章 WMS解析
● 第一节Activity与Window相关概念
● 第二节 Android窗口管理服务WindowManagerService计算Activity窗口大
● 第三节Android窗口管理服务WindowManagerService对窗口的组织方式分析
● 第四节 Android窗口管理服务WindowManagerService对输入法窗口（Input
● 第五节 Android窗口管理服务WindowManagerService对壁纸窗口（Wallpap
● 第六节Android窗口管理服务WindowManagerService计算窗口Z轴位置的过程分析
● 第七节Android窗口管理服务WindowManagerService显示Activity组件的启
● 第八节Android窗口管理服务WindowManagerService切换Activity窗口（A
● 第九节 Android窗口管理服务WindowManagerService显示窗口动画的原理分析
第六章PKMS Android10.0 源码解读
● 第一节 前言 PKMS是什么东西
● 第二节 PKMS概述信息
● 第三节 PKMS角色位置
● 第四节 PKMS启动过程分析
● 第五节 APK的扫描
● 第六节 PMS之权限扫描
● 第七节 PackageManagerService大综合笔记
由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android Framework进阶学习指南》完整文档的可扫描下方卡片免费获取~
《Android Framework 精编内核解析》
目录
第一章 深入解析Binder
● 第一节 Binder系列—开篇
● 第二节 Binder Driver初探
● 第三节 Binder Driver再探
● 第四节 Binder启动ServiceManager
● 第五节 获取ServiceManager
● 第六节 注册服务(addService)
● 第七节 获取服务(getService)
● 第八节 Framework层分析
● 第九节 如何使用Binder
● 第十节 如何使用AIDL
● 第十一节 Binder总结
● 第十二节 Binder面试题全解析
第二章 深入解析Handler消息机制
● 第一节 宏观理论分析与Message源码分析
● 第二节 MessageQueue的源码分析
● 第三节 Looper的源码分析
● 第四节 Handler的源码分析
● 第五节 Handler机制实现原理总结
● 第六节 Handler面试题全解析
第三章 Dalvik VM进程系统
● 第一节 Android系统启动-综述
● 第二节 Init篇
● 第三节 zygote篇
● 第四节 SystemServer上篇
● 第五节 SystemServer下篇
第四章 深入解析WMS
● 第一节 WMS概述
● 第二节 WMS的诞生
第五章 PackageMS启动
● 第一节 PackageMS相关框架类
● 第二节 PackageMS启动过程
第六章 AMS 面试专题
● 第一节 AMS
由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android Framework进阶学习指南》完整文档的可扫描下方卡片免费获取~
目录
第一章 系统启动
● 第一节 Android系统结构
● 第二节 Android是怎么启动的
● 第三节 Android 11.0系统启动之init进程
● 第四节 Android11.0系统启动之Zygote进程
● 第五节 Android 11.0 系统启动之SystemServer进程
● 第六节 Android 11.0 系统服务之ActivityMnagerService-AMS启动流程
● 第七节 Android11.0系统启动之Launcher(桌面)启动流程
● 第八节 Android11.0应用进程创建过程以及Zygote的fork流程
● 第九节 Android 11.0 PackageManagerService（一）工作原理及启动流程
● 第十节 Android 11.0 PackageManagerService-APK安装流程
第二章 日志系统篇
● 第一节 Android11.0 日志系统分析-logd、logcat 指令说明、分类和属性
第三章 Binder通信原理
● 第一节 Android11.0 Binder通信原理(一)Binder、HwBinder、VndBinder概要
● 第二节 Android11.0 Binder通信原理(二)-Binder入门篇
● 第三节 Android11.0 Binder通信原理(三)-ServiceManager篇
● 第四节 Android11.0 Binder通信原理(四)-Native-C\C++实例分析
● 第五节 Android11.0 Binder通信原理(五)-Binder驱动分析
● 第六节 Android11.0 Binder通信原理(六)-Binder数据如何完成定向打击
● 第七节 Android11.0 Binder通信原理(七)-Framework binder示例
● 第八节 Android11.0 Binder通信原理(八)-Framework层分析
● 第九节 Android11.0 Binder通信原理(九)-AIDL Binder示例
● 第十节 Android11.0 Binder通信原理(十)-AIDL原理分析-Proxy-Stub设计模式
● 第十一节 Android11.0 Binder通信原理(十一)-Binder总结
第四章 HwBinder通信原理
● 第一节 HwBinder入门篇-Android10.0 HwBinder通信原理(一)
● 第二节 HIDL详解-Android10.0 HwBinder通信原理(二)
● 第三节 HIDL示例-C++服务创建Client验证-Android10.0 HwBinder通信原理(三)
● 第四节 HIDL示例-JAVA服务创建-Client验证-Android10.0 HwBinder通信原理(四)
● 第五节 HwServiceManager篇-Android10.0 HwBinder通信原理(五)
● 第六节 Native层HIDL服务的注册原理-Android10.0 HwBinder通信原理(六)
● 第七节 JAVA层HIDL服务的注册原理-Android10.0 HwBinder通信原理
● 第八节 HwBinder驱动篇-Android10.0 HwBinder通信原理
● 第九节 HwBinder原理总结-Android10.0 HwBinder通信原理
第五章 编译原理
● 第一节 编译系统入门篇-Android10.0编译系统
● 第二节 编译环境初始化-Android11.0编译系统
● 第三节 make编译过程-Android11.0编译系统（三）
● 第四节 Image打包流程-Android11.0编译系统（四）
● 第五节 Kati详解-Android11.0编译系统
● 第六节 Blueprint简介-Android11.0编译系统-
● 第七节 Blueprint代码详细分析-Android11.0编译系统
由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android Framework进阶学习指南》完整文档的可扫描下方卡片免费获取~
《Android Framework 高频面试题总结》
目录
第一章 AMS、PMS
● 第一节 AMS概述
● 第二节 AMS的启动流程
● 第三节 AMS与进程启动
● 第四节 AMS家族
● 第五节 PMS前言
第二章 Activity 启动流程，App 启动流程
● 第一节 Activity的启动模式
● 第二节 什么是Zygote进程
● 第三节 Zygote进程的启动流程
● 第四节 SystemServer进程启动流程
● 第五节 启动服务
第三章 Binder 机制（IPC、AIDL 的使用）
● 第一节 什么是AIDL以及如何使用（★★★★）
● 第二节 AIDL的全称是什么?如何工作?能处理哪些类型的数据？（★★★）
● 第三节 Android的IPC通信方式，线程（进程间）通信机制有哪些
第四章 为什么使用 Parcelable，好处是什么？
● 第一节 实现机制
第五****章 Android 图像显示相关流程，Vsync 信号等
由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android Framework进阶学习指南》完整文档的可扫描下方卡片免费获取~
更多学习资料，加微信免费领取~
