在之前的分析里面,ActivityStarter在计算完源activty栈,目标activty栈和启动模式后,把后续的启动流程交给RootWindowContainer了。在resumeFocusedStacksTopActivities方法里面继续启动流程。resumeFocusedStacksTopActivities这个方法我自己的理解是恢复当前正在聚焦的stack顶部的activity,也就是把我们的activity压到栈顶。
// RootWindowContainer是窗口容器(WindowContainer)的根容器,管理了所有窗口容器,
// 设备上所有的窗口(Window)、显示(Display)都是由它来管理的。
// resumeFocusedStacksTopActivities会恢复对应任务栈顶部的Activity。这个方法会检查一些可见性相关的属性
// 如果当前需要resume的activityStack 是可见的,这个时候才resume. 而可见性是由RootWindowContainer中的窗口控制的。
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
......
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
......
}
在之前解析参数的步骤中已经创建好了ActivityRecord,接下来就是栈去管理和启动ActivityRecord的过程了。由RootWindowContainer调用到ActivityStack的resumeTopActivityInnerLocked方法,这个方法基于栈里面的各种情况去管理启动流程
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
......
//要启动的Activity
ActivityRecord next = topRunningActivity(true /* focusableOnly */);
......
// 停止当前的Activity
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next);// 停止当前的Activity
}
//next 就是要启动的这个ActivityRecord,它是一个全新的ActivityRecord,所以这个地方返回值是 false
//我们到目前为止只是创建了一个ActivityRecord,还没有和进程关联起来
if (next.attachedToProcess()) { //为false
......
}else{
......
//启动指定的Activity
mStackSupervisor.startSpecificActivity(next, true, true);
}
}
在这个函数里面根据栈里面的各种情况去管理启动流程,然后执行源Activity的onPase方法,把onPase包装成一个事务,让源Activity处于可见但不可交互状态;接下来就会走到ActivityStackSupervisor里面的startSpecificActivity方法
ActivityStackSupervisor用于管理ActivityStack,ActivityStackSupervisor会将Activity生命周期封装成一个ClientTranstion事务
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
......
// 进程已经创建的话,直接启动activity
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
......
//进程不存在的话,为app启动一个进程
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
可以看到代码来到之前分析过的Application启动流程,如果activity所在的进程未创建过,就通过ZygoteProcess发送socket信息通知zygote去fork出app进程,如果进程已经被创建了,则会走realStartActivityLocked方法区真正启动Activity。
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
......
/**主要包含两个内容: 一个是 要处理的一系列的生命周期事件,还有一个是这个Client在直线完这一系列事件后最终的lifecycle状态
一系列的事件是由callback 的列表控制,而最终的lifecycle状态则由mLifecycleStateRequest 控制*/
// Create activity launch transaction.
// 创建 clientTransaction 对象
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
// 添加LaunchActivityItem
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, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
//需要Rusume的话,设置ResumeActivityItem到clientTransaction中
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
// 获取生命周期管理类 ClientLifecycleManager,并执行事务
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
......
/**
主要包含两个内容: 一个是 要处理的一系列的生命周期事件,
还有一个是这个Client在执行一系列事件后最终的lifecycle状态
一系列的事件是由callback 的列表控制,而最终的lifecycle状态则由mLifecycleStateRequest 控制
*/
public class ClientTransaction implements Parcelable, ObjectPoolItem {
/** A list of individual callbacks to a client. */
@UnsupportedAppUsage
//生命周期的一系列的函数
private List<ClientTransactionItem> mActivityCallbacks;
/**
* Final lifecycle state in which the client activity should be after the transaction is
* executed.
*/
//执行完一系列生命周期后,最终的生命周期的状态
private ActivityLifecycleItem mLifecycleStateRequest;
/** Target client. */
//目标进程
private IApplicationThread mClient;
/** Target client activity. Might be null if the entire transaction is targeting an app. */
//目标进程对应的Binder
private IBinder mActivityToken;
......
// 通过 mClient 也就是IApplicationThread跨进程调用到应用进程
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
private ClientTransaction() {}
/** Obtain an instance initialized with provided params. */
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;
return instance;
}
......
ClientTransaction里面有一个List,这个列表里面存储的是AMS希望App里面的Activity执行的生命周期事件的集合,ActivityLifecycleItem是AMS希望App执行完所有生命周期后,最终的生命周期状态。还有一个IApplicationThread 代表目标进程,IBinder 标识目标进程对应的binder。
ClientTransaction必须要实现Parcelable接口,ClientTransaction里面包含AMS希望App进程的Activity执行的生命周期事件的集合,这些生命周期事件会通过AMS和App进程跨进程通信,把ClientTransaction传递给App进程,最后由App进程执行这些Activity的生命周期事件。
AMS把希望要启动的Activity所执行的生命周期,执行完生命周期后的最终生命周期状态,Activty所在的进程,所在进程的Binder都封装成了一个ClientTransaction。
我们来看一下是怎么封装的。
// 添加LaunchActivityItem
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, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
if (andResume) {
//需要Rusume的话,设置ResumeActivityItem到clientTransaction中
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//获取生命周期管理类 ClientLifecycleManager,并执行事务
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
谷歌工程师先把LaunchActivityItem生命周期事件塞到clientTransaction里面,然后谷歌工程师认为启动activity应该在onresume生命周期终止,所以把ResumeActivityItem生命周期事件赋值给clientTransaction的mLifecycleStateRequest成为最终的生命周期状态。最后通过ClientLifecycleManager生命周期管理类把我们封装好的生命周期事务从AMS所在的进程System_service传递到App进程。
class ClientLifecycleManager {
// TODO(lifecycler): Implement building transactions or global transaction.
// TODO(lifecycler): Use object pools for transactions and transaction items.
/**
* Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.
* @param transaction A sequence of client transaction items.
* @throws RemoteException
*
* @see 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,对ClientTransaction 做了一层封装,方便AMS调用ClientTransaction。scheduleTransaction方法最后会执行到ClientTransaction的schedule方法,最后通过ClientTransaction里面的App的Binder进行跨进程通信,把ClientTransaction给发出去。这里的Binder是ActivityThread的attach方法传递过来的。
// 通过 mClient 也就是IApplicationThread跨进程调用到应用进程
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
最后跑到ActivityThread里面执行scheduleTransaction方法
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
ActivityThread是继承ClientTransactionHandler,最后会执行这个抽象类里面的scheduleTransaction方法
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);
}
......
ClientTransactionHandler 的scheduleTransaction通过sendMessage发送一个message消息到主线程,最后回到ActivityThread里面
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();
}
至此完成了AMS到App进程的跨进程通信,然后由Binder线程池里面的子线程切换到主线程。