本文基于Android28,以Activity#startActivity(Intent intent)开始为入口
@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);
}
}
// 最终方法都是调用的startActivityForResult
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
接着继续看Activity#startActivityForResult(@RequiresPermission Intent intent, int requestCode,@Nullable Bundle options)的源码
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
//mParent常用于ActivityGroup,但是ActivityGroup已废弃,所以一般的Activity都是走这里
if (mParent == null) {
//启动一个新的Activity,核心功能位于mMainThread.getApplicationThread()。
//Instrumentation类是用于监视system和application交互的类。
//在最终启动activity的地方会用到Instrumentation
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
//发送调用onActivityResult的消息
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
// If this start is requesting a result, we can avoid making
// the activity visible until the result is received. Setting
// this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
// activity hidden during this time, to avoid flickering.
// This can only be done when a result is requested because
// that guarantees we will get information back when the
// activity is finished, no matter what happens to it.
mStartedActivity = true;
}
cancelInputsAndStartExitTransition(options);
// TODO Consider clearing/flushing other event sources and events for child windows.
} else {
//ActitityGroup内部的Activity则会走这里,实现方式其实是一样的
if (options != null) {
mParent.startActivityFromChild(this, intent, requestCode, options);
} else {
// Note we want to go through this method for compatibility with
// existing applications that may have overridden it.
mParent.startActivityFromChild(this, intent, requestCode);
}
}
}
真正执行打开Activity是在mInstrumentation#execStartActivity方法中实现的,接着继续看到Instrumentation#execStartActivity方法里面:
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
if (mActivityMonitors != null) {
synchronized (mSync) {
//遍历ActivityMonitor,看是否存在这个Activity
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
ActivityResult result = null;
if (am.ignoreMatchingSpecificIntents()) {
result = am.onStartActivity(intent);
}
if (result != null) {
am.mHits++;
return result;
} else if (am.match(who, null, intent)) {
am.mHits++;
//如果//当该monitor阻塞activity启动,也就是目标Activity无法打开就直接return
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
//如果存在就跳出循环
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
//真正的startActivity的方法,其实核心功能在whoThread的scheduleLaunchActivity完成的
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
//用于检查打开Activity异常的方法,比如常见的Activity没在AndroidManifest的话,
//会抛出“...have you declared this activity in your AndroidManifest.xml?”异常
//内部实现是各种情况下需要抛出的异常信息
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
此处的ActivityManager#getService()#startActivity,是定义在ActivityManagerService的方法,进入ActivityManagerService查看startActivity的内容如下:
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
boolean validateIncomingUser) {
enforceNotIsolatedCaller("startActivity");
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
//mActivityStartController.obtainStarter()获取得到的是ActivityStarter;
//ActivityStarter主要负责处理intenth和flags、选择启动的task、复用Activity等逻辑
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
.execute();
}
最终将会调用到ActivityManagerService#startActivityAsUser,并且在ActivityManagerService#startActivityAsUser中在execute()的时候调用ActivityStarter#execute(),具体内容如下:
int execute() {
try {
// TODO(b/64750076): Look into passing request directly to these methods to allow
// for transactional diffs and preprocessing.
// 上面调用了setMayWait(),所以mRequest.mayWait为true,执行startActivityMayWait()。
// ActivityStarter.startActivityMayWait() 的参数mRequest.inTask是一个ActivityRecord,默认是null
if (mRequest.mayWait) {
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
} else {
return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
mRequest.outActivity, mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
}
} finally {
onExecutionComplete();
}
}
ActivityStarter#execute()中mRequest.mayWait无论true或false,最终都会走到ActivityStarter#startActivityUnchecked的方法,并且在ActivityStarter#startActivityUnchecked()决定任务栈,确定启动模式,是否调用deliverNewIntent,复用Activity等判断,具体的内容如下:
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
...省略部分代码...
// 选择或者创建TaskRecord
// mLaunchFlags & FLAG_ACTIVITY_NEW_TASK 是true,会走setTaskFromReuseOrCreateNewTask()创建一个新的TaskRecord
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
// 创建新的TaskRecord
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
// 创建新的TaskRecord
setTaskToCurrentTopOrCreateNewTask();
}
// mStartActivity = r;mStartActivity表示准备启动的Activity
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
mService.mWindowManager.executeAppTransition();
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
//将启动的Activity的栈移动到前台
mTargetStack.moveToFront("startActivityUnchecked");
}
//mSupervisor 准备mStartAcitivity到栈顶,
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
}
}
...省略部分代码...
}
ActivityStarter构建了Activity的ActivityRecord和TaskRecord,做完了前期的准备工作了,下面就开始了对栈顶的Activity的停止和启动新的Activity。
mSupervisor是ActivityStackSupervisor,它负责管理ActivityStack,所以mSupervisor.resumeFocusedStackTopActivityLocked既是ActivityStackSupervisor#resumeFocusedStackTopActivityLocked方法
ActivityStackSupervisor#resumeFocusedStackTopActivityLocked内容如下:
boolean resumeFocusedStackTopActivityLocked() {
return resumeFocusedStackTopActivityLocked(null, null, null);
}
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;
}
这时候ActivityStarter已经把目标栈移动到前台,所以会到ActivityStack的resumeTopActivityUncheckedLocked(),在ActivityStack#resumeTopActivityUncheckedLocked()方法里面会调用到ActivityStack#resumeTopActivityInnerLocked()
// 在resumeTopActivityInnerLocked里暂停之前活动的Activity和把要启动的Activity添加到栈顶
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
if (mResumedActivity != null) {
// 暂停之前的Activity
pausing |= startPausingLocked(userLeaving, false, next, false);
}
if (next.app != null && next.app.thread != null) {
// activtiy存在,resume
mStackSupervisor.scheduleResumeTopActivities();
} else {
//创建进程,冷启动Activity。或者已启动App,重新启动Activity
StackSupervisor.startSpecificActivityLocked(next, true, false);
}
}
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean pauseImmediately) {
...省略部分代码...
// mService是AMS,prev.app.thread是ApplicationThread
mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
PauseActivityItem.obtain(prev.finishing, userLeaving,
prev.configChangeFlags, pauseImmediately));
...省略部分代码...
}
mService.getLifecycleManager()获取到是ClientLifecycleManager,这个类负责执行ActivityLifecycleItem,就是生命周期的任务,如PauseActivityItem、ResumeActivtyItem,每次执行最后会跟ActivityThread交互。
ClientLifecycleManager#scheduleTransaction方法代码:
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
@NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
stateRequest);
scheduleTransaction(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();
}
}
//ClientTransaction#schedule
public void schedule() throws RemoteException {
// mClient是IApplicationThread
mClient.scheduleTransaction(this);
}
ActivityLifecycleItem会被包装在ClientTransaction里面,如如PauseActivityItem、ResumeActivtyItem。
这里走到了IApplicationThread,而IApplicationThread的实体是ActivityThread内部类ApplicationThread,它是一个binder对象,IApplicationThread是它远程接口。
// ActivityThread#ApplicationThread#scheduleTransaction
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
在这里已经到达ActivityThread,但是并不在主线程。没错,接下来就是用Handler切换线程的时候。
但是在这里你搜不到ActivityThread的scheduleTransaction(),原因是在ActivityThread继承了ClientTransactionHandler,ClientTransactionHandler实现了schedueleTransaction()
// ClientTransactionHandler
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
abstract void sendMessage(int what, Object obj);
//ActivityThread#sendMessage
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, 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);
}
//在ActivityThread.H.EXECUTE_TRANSACTION最终会走ActivityThread#H#handleMessage里面的这段代码
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#execute
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
}
//executeLifecycleState()也是会执行ActivityLifecycleItem.execute
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (r == null) {
return;
}
// Cycle to the state right before the final requested state.
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
其中LifecycleItem会走execute(),postExecute()等方法,也就是走PauseActivtyItem或者ResumeActivitItem的execute(),并切换到主线程。至此从startActivity开始创建一个activity并且将其添加到主线程的流程就结束了!