这是我参与8月更文挑战的第2天，活动详情查看：8月更文挑战
之前的学习记录都是在自己的本地，借着掘金的这次8月活动的机会，也挑战一下自己，开始坚持写点东西。各位看官点点赞，小弟先谢过。
startActivity
在开发过程中我们一般使用的都是一个参数的startActivity方法去启动一个Activity，经过重载最后会调用startActivityForResult方法，第二个参数传入的 -1 表示不需要获取 startActivity 的结果
android.app.Activity
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
......
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
@Override
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
关键代码
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
......
}
......
}
看过上一篇Application初始化文章的对这个mInstrumentation就会很熟悉了，后面会专门对这个类进行一个说明。官方对Instrumentation的注释大概意思为
用于实现应用程序检测代码的基类。当在检测打开的情况下运行时，这个类将在任何应用程序代码之前为您实例化，允许您监视系统与应用程序的所有交互。 Instrumentation实现是通过 AndroidManifest.xml 的 <instrumentation> 标记向系统描述的。
熟悉的Instrumentation
接下来看Instrumentation
android.app.Instrumentation
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
//关键代码
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getBasePackageName(), 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;
}
在看关键代码之前，先看看下面的checkStartActivityResult，因为里面有个我们非常熟悉的报错。
android.app.Instrumentation
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
public static void checkStartActivityResult(int res, Object intent) {
......
switch (res) {
case ActivityManager.START_INTENT_NOT_RESOLVED:
case ActivityManager.START_CLASS_NOT_FOUND:
if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
throw new ActivityNotFoundException(
"Unable to find explicit activity class "
+ ((Intent)intent).getComponent().toShortString()
+ "; have you declared this activity in your AndroidManifest.xml?");
......
}
没有在AndroidManifest注册Activity的时候，报错就是这里出发的，当然他还有其他的检测先不管。继续看关键代码
android.app.Instrumentation
ActivityTaskManager.getService().startActivity()
android.app.Instrumentation.ActivityTaskManager
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
源码中有很多这种通过binde获取或许的方式，这里实际上返回的是一个ActivityTaskManagerService
来到ActivityTaskManagerService
com.android.server.wm.ActivityTaskManagerService
@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());
}
......
@Override
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*/);
}
......
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) {
assertPackageMatchesCallingUid(callingPackage);
enforceNotIsolatedCaller("startActivityAsUser");
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();
}
ActivityStartController getActivityStartController() {
return mActivityStartController;
}
可以看到经过几次调用，最后是调用了getActivityStartController().obtainStarter()
com.android.server.wm.ActivityStartController
ActivityStarter obtainStarter(Intent intent, String reason) {
return mFactory.obtain().setIntent(intent).setReason(reason);
}
返回的是一个ActivityStarter对象，那上面的一堆链式调用，直到执行最后的execute() 肯定也是在ActivityStarter里了。既然找到了线索，那就继续跟踪
ActivityStarter：专门负责一个 Activity 的启动操作。它的主要作用包括解析 Intent、创建 ActivityRecord、如果有可能还要创建 TaskRecord
##ActivityStarter
com.android.server.wm.ActivityStarter
/**
* Resolve necessary information according the request parameters provided earlier, and execute
* the request which begin the journey of starting an activity.
* @return The starter result.
*/
int execute() {
......
res = executeRequest(mRequest);
......
}
之前版本的代码会有很多方法方法执行，SDK30封装在了executeRequest，execute上面的注释已经把这个方法的重要性说的很明白。
· 根据前面提供的请求参数解析必要的信息，并执行启动活动旅程的请求
com.android.server.wm.ActivityStarter
private int executeRequest(Request request) {
......
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
......
}
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
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);
startedActivityStack = handleStartResult(r, result);
mService.continueWindowLayout();
}
}
@VisibleForTesting
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
......
关键代码
mRootWindowContainer.resumeFocusedStacksTopActivities(mTargetStack, mStartActivity, mOptions);
......
}
这个是mRootWindowContainer是RootWindowContainer，和以前的版本完全不一样。之前没有这个类，
com.android.server.wm.RootWindowContainer
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (!mStackSupervisor.readyToResume()) { return false;}
......
if (targetStack != null && (targetStack.isTopStackInDisplayArea()
|| getTopDisplayFocusedStack() == targetStack)) {
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
......
}
· ActivityStack：管理TaskRecord的，包含了多个TaskRecord · ActivityStackSupervisor：管理ActivityStack
mStackSupervisor是ActivityStackSupervisor对象的实例，如果是跟着我一起打开代码的人可能在ActivityStack中找不到mStackSupervisor变量，这个时候，就该去他的父类里看看。果然在ActivityStack的父类Task中，可以看到 targetStack是ActivityStack类型
com.android.server.wm.Task
class Task extends WindowContainer<WindowContainer> {
......
final ActivityStackSupervisor mStackSupervisor;
......
}
继续看方法执行
com.android.server.wm.ActivityStack
@GuardedBy("mService")
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
......
result = resumeTopActivityInnerLocked(prev, options);
......
}
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
......
关键代码
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next);
}
}
......
}
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,ActivityRecord resuming) {
......
mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
......
}
和上面的mStackSupervisor一样，mAtmService是定义在父类Task里的一个ActivityTaskManagerService的实例。
com.android.server.wm.ActivityTaskManagerService
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
mAtmService.getLifecycleManager() 返回的是一个ClientLifecycleManager对象，那scheduleTransaction方法自然也在这里
com.android.server.wm.ClientLifecycleManager
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();
}
}
android.app.servertransaction.ClientTransaction
......
/** Target client. */
private IApplicationThread mClient;
......
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
ApplicationThread
熟悉的IApplicationThread，不用多说，直接去ApplicationThread中找。而且我可以大胆的猜测，最后又是发了消息给H
android.app.ActivityThread
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
咦。。居然没发消息，看来是我错了。ActivityThread类中是没有scheduleTransaction方法的，一般遇到这种情况，直接找其父类
android.app.ClientTransactionHandler
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);
}
emmmm我错了但是没有完全错。最后还是发生了一个H.EXECUTE_TRANSACTION消息
ActivityThread
android.app.ActivityThread
// An executor that performs multi-step transactions.
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
......
class H extends Handler {
......
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();
}
......
}
· TransactionExecutor
android.app.servertransaction.TransactionExecutor
......
private ClientTransactionHandler mTransactionHandler;
......
public void execute(ClientTransaction transaction) {
......
executeCallbacks(transaction);
......
}
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
......
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);
}
}
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
......
//获取这次要执行生命周期的路径path
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);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Transitioning activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " to state: " + getStateName(state));
}
switch (state) {
case ON_CREATE:
关键代码
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r.token, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token, false /* start */);
break;
default:
经过一系列的方法调用execute->executeCallbacks->cycleToPath->performLifecycleSequence,我们终于看到了熟悉的东西，一堆Activity的生命周期。
这边稍微提一下，他有很多case，然后像ON_CREATE其实是一个Int类型的常量，值为1。 上面是对path的一个遍历，这个path是一个数组，里面其实就是这次要执行的所有生命周期的保存，因为我们这里直说Activity的onCreate,所以只看ON_CREATE下的handleLaunchActivity就好.像下面还有一些生命周期，有兴趣的可以自己点进去看看。
mTransactionHandler是ClientTransactionHandler类型的实例，handleLaunchActivity是他的抽象方法，ActivityThread作为其子类，具体实现了handleLaunchActivity方法。
android.app.ClientTransactionHandler
public abstract class ClientTransactionHandler {
......
/** Perform activity launch. */
public abstract Activity handleLaunchActivity(ActivityThread.ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent);
......
}
android.app.ActivityThread
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
......
final Activity a = performLaunchActivity(r, customIntent);
......
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
关键代码1
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);
}
}
......
执行attach，内部创建Window等
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);
......
关键代码2
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
}
如果看过以前Activity启动流程，或者看过《Android开发艺术探索》的小伙看，看到performLaunchActivity方法应该会十分熟悉，马上就要到最后的关键了。
Instrumentation 在Application的初始化流程一文提到过Instrumentation负责Application和Activity的创建和生命周期控制。具体看看他是如何创建Activity的吧。
Instrumentation
android.app.Instrumentation
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);
}
private AppComponentFactory getFactory(String pkg) {
......
return apk.getAppFactory();
}
可以跟踪到instantiateActivity最后是在AppComponentFactory内完成，大胆猜一下，之前的Instrumentation，Application都是通过反射创建的，这个newActivity的参数又是ClassLoader又是className的，八九不离十也是反射吧？(我看代码喜欢带着自己的猜测，如果是我我会怎么去执行，这样看到最后，不管猜对猜错。都会印象比较深刻。如果错了，会恍然大悟，如果猜对了会沾沾自喜)
android.appinstantiateActivity
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
果然是反射。performLaunchActivity在代码1除通过Instrumentation创建除了Activity,在代码2出看名字，也大概是知道执行了Activity的OnCreate方法
android.app.Instrumentation
/**
* Perform calling of an activity's {@link Activity#onCreate}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being created.
* @param icicle The previously frozen state (or null) to pass through to onCreate().
*/
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
可以看到，第二行这个比较关键,直接交给了Activity执行。那基本上，执行到了Activity内部，就接近尾声了。
android.app.Activity
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
@UnsupportedAppUsage
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
dispatchActivityPreCreated(icicle);
mCanEnterPictureInPicture = true;
// initialize mIsInMultiWindowMode and mIsInPictureInPictureMode before onCreate
final int windowingMode = getResources().getConfiguration().windowConfiguration
.getWindowingMode();
mIsInMultiWindowMode = inMultiWindowMode(windowingMode);
mIsInPictureInPictureMode = windowingMode == WINDOWING_MODE_PINNED;
restoreHasCurrentPermissionRequest(icicle);
关键代码
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
EventLogTags.writeWmOnCreateCalled(mIdent, getComponentName().getClassName(),
"performCreate");
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
dispatchActivityPostCreated(icicle);
}
OK，看到Activity执行onCreate，结束。
总结
1.Activity的startActivity最终会调用startActivityForResult方法。再由Instrumentation内部执行execStartActivity方法开始旅程
2.任务经过一系列的类处理ActivityTaskManagerService->ActivityStarter->RootWindowContainer->ActivityStack->ClientLifecycleManager->ClientTransaction->ApplicationThread最终在ApplicationThread里触发ActivityThread父类的scheduleTransaction方法，他内部发送了一个消息。
3.ActivityThread内部类H收到消息后，执行scheduleTransaction，又经过一系列调用后，最后由Instrumentation完成Activity的创建和调用Activity的onCreate方法
