- LauncherActivity就是桌面Activity，我们点击应用图标，进入我们的MainActivity。 首先执行LauncherActivity的onListItemClick方法，方法如下
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
Intent intent = intentForPosition(position);
// 调用 startActivity
startActivity(intent);
}
调用了其父类Activity的startActivity方法
2.查看Activity的startActivity方法
@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);
}
}
\
可以看到最终调用了startActivityForResult方法
@Override
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public void startActivityForResult(
String who, Intent intent, int requestCode, @Nullable Bundle options) {
Uri referrer = onProvideReferrer();
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
options = transferSpringboardActivityOptions(options);
// Instrumentation 执行 execStartActivity 方法
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, who,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, who, requestCode,
ar.getResultCode(), ar.getResultData());
}
cancelInputsAndStartExitTransition(options);
}
看到是由Instrumentation执行execStartActivity方法
3.查看Instrumentation类中的execStartActivity方法
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
// 省略部分代码
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
// 通过ActivityTaskManagerService的startActivity方法
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getBasePackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token, target,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
可以看到通过ActivityTaskManagerService的startActivity方法来调用
4.查看ActivityTaskManagerService的startActivity
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) {
// 省略部分代码
// TODO: Switch to user app stacks here.
// 获取 ActivityStartController 获取 ActivityStarter 执行 execurte 方法
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();
}
ActivityTaskManagerService的startActivity方法经过层层调用会执行startActivityAsUser方法，然后通过ActivityStarter调用execute方法来启动activity
5.查看ActivityStarter的execute方法
int execute() {
//省略代码
// 执行该方法
res = executeRequest(mRequest);
//省略代码
}
在该方法中执行了executeRequest方法
// 执行 startActivityUnchecked 方法
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
其中执行startActivityUnchecked方法
最终会调用startActivityInner方法
然后关注该方法中的deliverToCurrentTopIfNeeded方法
// If the activity being launched is the same as the one currently at the top, then
// we need to check if it should only be launched once.
final ActivityStack topStack = mRootWindowContainer.getTopDisplayFocusedStack();
if (topStack != null) {
// 注意这个方法
startResult = deliverToCurrentTopIfNeeded(topStack, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
6.在该方法中mRootWindowContainer调用了resumeFocusedStacksTopActivities方法
if (mDoResume) {
// 如果mDoResume为true 表示要显示这个activity,则调用这个方法
mRootWindowContainer.resumeFocusedStacksTopActivities();
}
resumeFocusedStacksTopActivities方法种调用了resumeTopActivityUncheckedLocked方法
if (focusedStack != null) {
// 注意这个方法
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetStack == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
- focusedStack就是ActivityStack,查看ActivityStack的resumeTopActivityUncheckedLocked方法看到调用resumeTopActivityInnerLocked方法
// 显示当前任务栈中的Top顶部的Activity
result = resumeTopActivityInnerLocked(prev, options);
在该方法中经过层层调用执行了startSpecificActivity方法
// 这里 启动activity
mStackSupervisor.startSpecificActivity(next, true, false);
8.查看ActivityStackSupervisor类中的startSpecificActivity方法
// 真正启动activity
realStartActivityLocked(r, wpc, andResume, checkConfig);
层层调用调用了下面代码
// Create activity launch transaction.
// 创建activity 启动的 transaction
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
//省略代码
// Schedule transaction.
// 通过 ActivityTaskManagerService 获取LifecycleManager 调用 transaction
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
9.这里的LifecleManager就是ClientLifecycleManager，查看ClientLifecycleManager类种的scheduleTransaction方法
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
// 这里执行了ClientTransaction的schedule方法
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();
}
}
10.执行了ClientTransaction类中的schedule方法
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
11.这里的mClient就是ActivityThread,查看ActivityThread\
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//ActivityThread.this就是 ClientTransactionHandler ，因为ActivityThread 继承自 ClientTransactionHandler
ActivityThread.this.scheduleTransaction(transaction);
}
12.查看ClientTransactionHandler的scheduleTransaction方法
void scheduleTransaction(ClientTransaction transaction) {
// 这里调用了 ClientTransaction 的 preExecute 方法
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
13.发了个message给ActivityThread的H
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
//通过 TransactionExecutor 执行
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;
14.查看mTransactionExecutor.execute方法
// 执行这个方法
executeCallbacks(transaction);
查看该方法
// 这个方法里面调用了创建activity实例的方法
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
// cycleToPath中调用了下面的方法
// 这里的 mTransactionHandler 是 ClientTransactionHandler
// 而 ActivityThread 继承自 ClientTransactionHandler 所以调用的是
// ActivityThread 的 handleLaunchActivity 方法
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
15.又回到的ActivityThread,调用了handleLaunchActivity方法，其中又调用了performLaunchActivity方法
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);\
16.回到Instrumentation中最后是调用了AppComponentFactory的instantiateActivity方法，通过反射创建了Activity\
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
// 这里用发射的方式创建了activity
return (Activity) cl.loadClass(className).newInstance();
}
