一、引言
基于前篇所介绍的Activity启动模式、应用进程中启动Activity的相关流程，以及中篇所介绍的Android FrameWork中启动Activity的相关流程，现对Android Q上从Android Framework层通过Binder的方式调用到应用进程启动Activity的相关流程进行一个简单的介绍，当然写这篇博客的另一个目的是为了更好的理解Android Q上如何去实现Android插件化，毕竟Android中的插件化就是基于应用进程层面对Android Framework的Hook。
另外需要说明的一下是，虽然前篇和中篇是基于Android P的相关源码进行介绍的，但是在这一块儿的代码逻辑上Android P和Android Q并没有太多的变化，因此不用担心该篇博客和前面博客的不连续性。
二、源码
1、Android Framework层与应用进程的Binder通信
在Android Framework的Activity启动流程中最后会走到类ActivityStackSupervisor的realStartActivityLocked方法中，在这个方法中会通过ActivityThread中的Binder对象实现Android Framework层与应用进程之间的通信工作，其中核心的代码如下：
........
//传入要启动Activity所在应用进程的Binder对象生成ClientTransaction对象，用于后续通过Binder的方式调用到应用进程中
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
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.icicle, r.persistentState, results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),r.assistToken));
//设置该次Activity要进入的最终状态
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//在类ClientLifecycleManager中调用ClientTransaction的schedule方法
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
........
经过一系列的中转最后会调用到类ClientTransaction的schedule方法中，里面的实现很简单，就是通过Binder的方式直接调用到应用进程里面。代码如下：
//这里需要注意一下该类是实现了Parcelable接口的，说明是一个被序列化的对象，可以在进程间被传递
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
这里的mClient对象就是在方法realStartActivityLocked中所传入的应用进程的ApplicationThread这个Binder对象，而这个Binder对象的定义以及实例对象都存在于应用进程的ActivityThread中，所以我们直接跳转到ActivityThread中走接下来的流程。
2、进入到应用进程内部
在Android O及其以上在ActivityThread中启动Activity的方式不再是直接调用到scheduleLaunchActivity然后通过Handler的方式调用handleLaunchActivity方法启动Activity；而取了左右摇摆的方式，在各个类之间不停的来回调用最后走到ActivityThread的handleLaunchActivity方法中启动Activity。
2.1 ActivityThread的起点
从Android FrameWork到应用层启动Activity，是通过ActivityThread中的Binder类的scheduleTransaction作为起点的，在该方法中啥也没有干，就只是单纯的调用了一下ActivityThread从父类那里继承过来的scheduleTransaction方法。
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
所以直接走到Activity的实现类ClientTransactionHandler中看看具体的实现：
void scheduleTransaction(ClientTransaction transaction) {
//做一些启动Activity之前的初始化工作
transaction.preExecute(this);
//这一步有又调用到了ActivityThread的Handler中
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
这里暂时先省略掉那些不必要的代码：
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
transaction.recycle();
}
break;
2.2 TransactionExecutor
接着继续调用到类TransactionExecutor的execute方法中
public void execute(ClientTransaction transaction) {
//获取的是windowManager token,在ActivityRecord中通过当前ActivityRecord和Intent生成的实例对象
final IBinder token = transaction.getActivityToken();
if (token != null) {
//获取真正需要被摧毁的Activity列表
final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
mTransactionHandler.getActivitiesToBeDestroyed();
final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
if (destroyItem != null) {
//如果接下来要执行的动作就是销毁该Activity，则从需要被真正销毁的列表中移除该Activity相对对应的信息
if (transaction.getLifecycleStateRequest() == destroyItem) {
activitiesToBeDestroyed.remove(token);
}
//该Activity从来没有真正被启动过，则啥也不做
if (mTransactionHandler.getActivityClient(token) == null) {
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
//在这个函数中则会真正的调用到ActivityThread中的handleLaunchActivity方法中开始执行onCreate方法
executeCallbacks(transaction);
//执行后续的onStart、onResume方法
executeLifecycleState(transaction);
mPendingActions.clear();
}
这里省略掉executeCallbacks方法中不关心的代码部分：
......
for (int i = 0; i < size; ++i) {
......
//这里就是调用到上面在ActivityStackSupervisor的realStartActivityLocked方法中所设置的callBack中了，即LaunchActivityItem中
item.execute(mTransactionHandler, token, mPendingActions);
//activity加1
item.postExecute(mTransactionHandler, token, mPendingActions);
.....
}
......
看一下核心的execute方法中做了什么。
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
//首先生成对应ActivityClientRecord对象，该类是ActivityThread中的内部类
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client, mAssistToken);
//接着就开始创建并启动Activity了，这个后续再介绍
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
我们继续着看TransactionExecutor的executeLifecycleState方法，在该方法中会执行到ActivityThread的handleStartActivity方法以及handleResumeActivity方法。
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
.....
//计算出Activity的起始状态到需要到达的最终状态所需要经历的中间状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
//这里就是执行Resume相关的函数了
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
2.2 ActivityThread执行Activity的生命周期
2.2.1 handleLaunchActivity
该方法中并没有做太多其他事情，主要是做了一些初始化的工作，比如初始化硬件加速渲染器、初始化WindowManager实例等，接着就调用到了performLaunchActivity方法中，因为代码比较简单，所以直接略过到performLaunchActivity方法中；
2.2.2 performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
//获取LoadedApk对象，会经历如下的步骤：
//（1）首先会根据包名去mPackages查找是否已经生成对应的LoadedApk对象，如果有则直接返回；
//（2）否则根据对应的信息生成对应的LoadedApk对象并保存到mPackages集合中并返回
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
//这里就是生成对应到ComponentName对象
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);
}
//首先获取上述生成到LoadedApk中到Classloader对象，如果没有则生成默认到Classloader对象
//生成对应到ContextImpl对象
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
//通过上述生成的Classloader对象去加载对应Activity并生成实例对象
java.lang.ClassLoader cl = appContext.getClassLoader();
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 {
//生成应用对应的aplication实例对象（如果没有自定义则使用默认的Application），并调用其onCreate方法，所以知道了为什么Application对象会比Activity先调用了
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
........
if (activity != null) {
appContext.setOuterContext(activity);
//初始化当前Activity对象
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);
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;
//调用当前Activity onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
//自定义到Activity中没有调用super方法
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
}
//设置当前Activity的生命周期
r.setState(ON_CREATE);
//保存运行在当前进程中到Activity
synchronized (mResourcesManager) {
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的onStart和onResume生命周期了，还记得在前面提到的类TransactionExecutor的performLifecycleSequence方法吗？就是在这里面开始一步一步调用到Activity的onStart方法中的。所以接下来就是方法handleStartActivity了
2.2.3 handleStartActivity
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions) {
//这个Activity就是在方法performLaunchActivit所生成的对象
final Activity activity = r.activity;
if (r.activity == null) {
return;
}
//在设置当前Activity状态为onCreate的时候被置为了true
if (!r.stopped) {
throw new IllegalStateException("Can't start activity that is not stopped.");
}
//判断是否被finish了，比如在onCreate中调用了finish方法
if (r.activity.mFinished) {
return;
}
// 在该方法中通过Instrumentation调用到Activity的onCreate方法中
activity.performStart("handleStartActivity");
//设置当前Activity的状态为onStart
r.setState(ON_START);
if (pendingActions == null) {
// No more work to do.
return;
}
.....
}
简单的看一下performStart方法。
2.2.4 handleStartActivity
final void performStart(String reason) {
.....
mCalled = false;
//调用到Activity的onStart方法中
mInstrumentation.callActivityOnStart(this);
if (!mCalled) {
throw new SuperNotCalledException(
"Activity " + mComponent.toShortString() +
" did not call through to super.onStart()");
}
.....
}
接下来就是调用onResume方法的基本流程了。
2.2.5 performResumeActivity
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
String reason) {
final ActivityClientRecord r = mActivities.get(token);
if (localLOGV) {
Slog.v(TAG, "Performing resume of " + r + " finished=" + r.activity.mFinished);
}
//判断Activity是否需要被finish，如果需要则啥也不做
if (r == null || r.activity.mFinished) {
return null;
}
//当前Activity已经处于了onResume状态则啥也不做
if (r.getLifecycleState() == ON_RESUME) {
if (!finalStateRequest) {
final RuntimeException e = new IllegalStateException(
"Trying to resume activity which is already resumed");
Slog.e(TAG, e.getMessage(), e);
Slog.e(TAG, r.getStateString());
}
return null;
}
//是否是这次启动Activity事务的最终状态
if (finalStateRequest) {
r.hideForNow = false;
r.activity.mStartedActivity = false;
}
try {
r.activity.onStateNotSaved();
r.activity.mFragments.noteStateNotSaved();
checkAndBlockForNetworkAccess();
//存在onNewIntent，简单来说就是需要调用到Activity的onNewIntent方法
if (r.pendingIntents != null) {
deliverNewIntents(r, r.pendingIntents);
r.pendingIntents = null;
}
//存在onActivityFotResult函数待回调
if (r.pendingResults != null) {
deliverResults(r, r.pendingResults, reason);
r.pendingResults = null;
}
//调用Activity的onResume方法
r.activity.performResume(r.startsNotResumed, reason);
r.state = null;
r.persistentState = null;
//设置当前Activity状态为onResume
r.setState(ON_RESUME);
reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException("Unable to resume activity "
+ r.intent.getComponent().toShortString() + ": " + e.toString(), e);
}
}
return r;
}
三、总结
上述就是在android应用层Activity生命周期从onCreate->onResume的一个大致流程了。
android源码查看地址：
