StartActivity原理（二），Android9.0 Activity启动原理
同系列往期文章：
以及相关代码：GitHub:Magic-Plugin-in
Android源码 : Android code search
声明：本篇帖子基于Android-28-9.0版本
上一篇说到Activity启动流程第一步————ActivityOnPause流程，那么这一期，紧接着正式开始讲真正的startActivity原理。
startActivity的流程和activity的pause流程紧密相关，被启动的Activity实际上是在启动者执行完onPause流程之后紧接着启动的。
上一篇我们讲到activity 执行pause流程的一个关键类PauseActivityItem：
public class PauseActivityItem extends ActivityLifecycleItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
"PAUSE_ACTIVITY_ITEM");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
if (mDontReport) {
return;
}
try {
// TODO(lifecycler): Use interface callback instead of AMS.
ActivityManager.getService().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
//*^____^**^____^*
}
在这个类有两个关键的方法execute和postExecute,在上一篇我们知道，activity的pause流程在execute()中执行到ActivityThread的handlePauseActivity方法中再一步步到达Activity的onPause的onPause；而新启动的Activity则是在这个类的postExecute()方法中开始的。
我们记住这个前提，接下来就开始startActivity的流程。
可以看到，在postExecute中，执行了ActivityManager.getService().activityPaused(token)，我们看ActivityManagerService的代码：
代码-1-
@Override
public final void activityPaused(IBinder token) {
final long origId = Binder.clearCallingIdentity();
synchronized(this) {
ActivityStack stack = ActivityRecord.getStackLocked(token);
if (stack != null) {
stack.activityPausedLocked(token, false);
}
}
Binder.restoreCallingIdentity(origId);
}
调用ActivityStack的activityPausedLocked(token, false):
代码-2-
final void activityPausedLocked(IBinder token, boolean timeout) {
//省略代码(●'◡'●)
//关键代码
completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
//确保该显示的Activity可见
mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}
代码-3-
private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
if (resumeNext) {
final ActivityStack topStack = mStackSupervisor.getFocusedStack();
if (!topStack.shouldSleepOrShutDownActivities()) {
mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
} else {
checkReadyForSleep();
ActivityRecord top = topStack.topRunningActivityLocked();
if (top == null || (prev != null && top != prev)) {
// If there are no more activities available to run, do resume anyway to start
// something. Also if the top activity on the stack is not the just paused
// activity, we need to go ahead and resume it to ensure we complete an
// in-flight app switch.
// 关键代码
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
}
}
mStackSupervisor.ensureActivitiesVisibleLocked(resuming, 0, !PRESERVE_WINDOWS);
}
再次回到ActivityStackSupervisor
代码-4-
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (!readyToResume()) {
return false;
}
// 关键代码
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || !r.isState(RESUMED)) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.isState(RESUMED)) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
关键代码targetStack.resumeTopActivityUncheckedLocked(target, targetOptions)
代码-5-
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mStackSupervisor.inResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
// Protect against recursion.
mStackSupervisor.inResumeTopActivity = true;
//关键代码
result = resumeTopActivityInnerLocked(prev, options);
// When resuming the top activity, it may be necessary to pause the top activity (for
// example, returning to the lock screen. We suppress the normal pause logic in
// {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
// end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
// to ensure any necessary pause logic occurs. In the case where the Activity will be
// shown regardless of the lock screen, the call to
// {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
return result;
}
关键代码resumeTopActivityInnerLocked(prev, options)
代码-6-
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//省略大量大量代码
mStackSupervisor.startSpecificActivityLocked(next, true, false);
return true;
}
这段代码非常的长，做了很多工作，包括前面推出的Activity的动画等等，仅仅看最后的关键代码，再次回到ActivityStackSupervisor
代码-7-
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
getLaunchTimeTracker().setLaunchTime(r);
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
// Don't add this if it is a platform component that is marked
// to run in multiple processes, because this is actually
// part of the framework so doesn't make sense to track as a
// separate apk in the process.
app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
mService.mProcessStats);
}
//关键代码
realStartActivityLocked(r, app, 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.
}
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
关键代码realStartActivityLocked(r, app, andResume, checkConfig)
代码-8-
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
//......
// Create activity launch transaction.
// 创建启动Activity的transaction
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
//重点代码，添加callBack
clientTransaction.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, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));
// Set desired final state.
//创建 ResumeActivityItem
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
//重点代码，添加lifecycleStateRequest
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
// 执行transaction
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
//......
}
看到这段代码是否比较熟悉，在Activity的pause流程中一模一样！
这里做了三件事；
- 1.创建ClientTransaction；
- 2.创建执行启动Activity的ActivityLifecyclerItem（LaunceActivityItem、ResumeActivityItem都是它的子类）并添加到ClientTransaction的callback；
- 3.创建执行ResumeActivity的ActivityLifecyclerItem，并添加到ClientTransaction的liefeCycleStateRequest
接下来看最后一行代码ActivityManagerService获取到ClientLifecycleManager：
代码-9-
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();
}
}
上一篇Activity的pause流程，一模一样的方法：
ClientTransaction
代码-10-
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
在**代码-9-**可知mClient是IApplicationThread,而它的实例是ActivityThread的内部类ApplicationThread也是成员变量
代码-11-
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
它又调用ActivityThread.scheduleTransaction方法，搜索一圈找不到scheduleTransaction,上一篇我说过，ActivityThread派生自ClientTransactionHandler,在父类中看这个方法：
代码-12-
public 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);
}
}
看关键代码sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);，先记住这个常量ActivityThread.H.EXECUTE_TRANSACTION；
sendMessage没有实现，回看ActivityThread:
代码-13-
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1) {
sendMessage(what, obj, arg1, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2) {
sendMessage(what, obj, arg1, arg2, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) Slog.v(
TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
+ ": " + arg1 + " / " + obj);
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
通过多个多态调用，最终调用mH.sendMessage(msg)，mH就是我们的主线程Handler-H，不多说大家都知道。接下来搜索EXECUTE_TRANSACTION:
在ActivityThread内部类H中
代码-14-
class H extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
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;
}
}
关键代码mTransactionExecutor.execute(transaction)
代码-15-
public class TransactionExecutor {
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
//关键代码
executeCallbacks(transaction);
//重点代码
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
}
回顾**代码-8-**中，给ClientTransaction设置了calback也就是LaunchActivityItem，同时设置了lifecycleStateRequest-ResumeActivityItem；
也就是说，这里会执行LaunchActivity的流程和ResumeActivity的流程
这与上一篇我们讲Activity的pause流程是不是一模一样，不同的是，在Pause的流程没有executeCallbacks。
resumeActivity不是重点，不深入扩展，我们聚焦于executeCallbacks：
代码-16-
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
//..............
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
log("Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState);
}
//关键代码
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);
}
}
}
我们看LaunchActivityItem:
代码-17-
public class LaunchActivityItem extends ClientTransactionItem {
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);
//关键代码
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
}
LaunchActivityItem及其父类没有实现postExecute方法，我们只看execute以及其关键代码。
再次回到ActivityThread（它是ClientTransactionHandler的子类，父类并未实现盖房发，所以这里为了方便不引入代码了直接使用ActivityThread：
代码-18-
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
//...............
final Activity a = performLaunchActivity(r, customIntent);
//...............
return a;
}
接下来的代码掀起了本篇最后一幕，performLaunchActivity比较重要,我不进行删减全部贴出来：
代码-19-
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
//1.重点代码，为Activity生成Context
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
//2.重点代码，生成Activity的实例
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
appContext.setOuterContext(activity);
//3.重点代码，关联当前Applicaton
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);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
checkAndBlockForNetworkAccess();
activity.mStartedActivity = false;
//设置主体
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
//4.关键代码，执行Activity的onCreate生命周期方法
if (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;
}
r.setState(ON_CREATE);
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
这里几个重点代码都比较重要，Activity关联Application，关联Context以及Resource都是在这里完成的。
上面的注释比较清晰，我不再多赘述，只额外补充 第2处重点代码–生成Activity的实例，查看代码mInstrumentation.newActivity:
代码-20-
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
String pkg = intent != null && intent.getComponent() != null
? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
AppComponentFactory.instantiateActivity:
代码-21-
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
使用ClassLoader加载Activity的Class对象并构造出实例。
好的，回归主线mInstrumentation.callActivityOnCreate,我们回到了最初的地方Instrumentation：
代码-22-
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
//关键代码
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
最终，这趟旅程回到了Activity中：
代码-23-
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
//最终的最终
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
}
我们Activity正常重写的都是一个参数的onCreate方法，最终就执行到了onCreate()
OK!到这里，我们的Activity启动的流程圆满结束！
从Activity的startActivity出发，到Instrumentation到ActivityManagerService再到ActivityThread，一路经历了崎岖坎坷最后兜兜转转又回到了Activity中。这就好像是我们的人生一样，怀揣梦想，一路经历挫折磨难，经历了风风雨雨，我们成长了，变得更强了，仍然不改初心，回归本心，就像那句话说的
——————走出半生，归来仍是少年！
最后献上流程图：
![![流程图][5]](https://img-blog.csdnimg.cn/direct/2246cd834fe0489eaf99115356ef52ff.png)
后续我会继续补充
插件化原理（二）—— 启动插件Activity
插件化原理（三）—— 使用插件资源
敬请期待😁😁😁
418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
