android线程的生命周期,Android P AMS与ActivityThread处理Activity生命周期--ClientTransactionHandler...

在Android P中，ActivityThread extends ClientTransactionHandler，而ClientTransactionHandler封装了handlexxxActivity的方法。

而AMS控制Activity的生命周期，通过ApplicationThread#scheduleTransaction(ClientTransaction)，而去到应用进程后，具体执行哪个生命周期，看ClientTransaction#addCallback(ClientTransactionItem)中的ClientTransactionItem是什么子类型,还有ClientTransaction.setLifecycleStateRequest(ActivityLifecycleItem);其中可以有多个callback。LaunchActivityItem就是要执行LaunchActivity任务，而PauseActivity则是PauseActivityItem，StopActivity则是StopActivityItem，Destroy Activity则是DestoryActivityItem。

ClientTransactionItem implements BaseClientRequest, Parcelable

ActivityLifecycleItem extends ClientTransactionItem

LaunchActivityItem extends ClientTransactionItem

PauseActivityItem extends ActivityLifecycleItem

StopActivityItem extends ActivityLifecycleItem

DestroyActivityItem extends ActivityLifecycleItem

可以看到AMS能把ClientTransactionItem 传到应用进程是因为它实现了Parcelable。

ApplicationThread#scheduleTransaction(ClientTransaction)：public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {

ActivityThread.this.scheduleTransaction(transaction);

}

ClientTransactionHandler#scheduleTransaction()void scheduleTransaction(ClientTransaction transaction) {

transaction.preExecute(this);

sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);

}

ActivityThread.H.EXECUTE_TRANSACTION的处理：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();

log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

executeCallbacks(transaction);

executeLifecycleState(transaction);

mPendingActions.clear();

log("End resolving transaction");

}

TransactionExecutor#executeCallbacks()public void executeCallbacks(ClientTransaction transaction) {

final List callbacks = transaction.getCallbacks();

if (callbacks == null) {

// No callbacks to execute, return early.

return;

}

log("Resolving callbacks");

final IBinder token = transaction.getActivityToken();

ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

// In case when post-execution state of the last callback matches the final state requested

// for the activity in this transaction, we won't do the last transition here and do it when

// moving to final state instead (because it may contain additional parameters from server).

final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();

final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()

: UNDEFINED;

// Index of the last callback that requests some post-execution state.

final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

final int size = callbacks.size();

for (int i = 0; i < size; ++i) {

final ClientTransactionItem item = callbacks.get(i);

log("Resolving callback: " + item);

final int postExecutionState = item.getPostExecutionState();

final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,

item.getPostExecutionState());

if (closestPreExecutionState != UNDEFINED) {

cycleToPath(r, closestPreExecutionState);

}

//执行重点

item.execute(mTransactionHandler, token, mPendingActions);

item.postExecute(mTransactionHandler, token, mPendingActions);

if (r == null) {

// Launch activity request will create an activity record.

r = mTransactionHandler.getActivityClient(token);

}

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);

}

}

}

那看看LaunchActivityItem的execute：public void execute(ClientTransactionHandler client, IBinder token,

PendingTransactionActions pendingActions) {

Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");

ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,

mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,

mPendingResults, mPendingNewIntents, mIsForward,

mProfilerInfo, client);

//可以看到这里就是调用ActivityThread#handleLaunchActivity()

client.handleLaunchActivity(r, pendingActions, null /* customIntent */);

Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);

}

而在AMS那边，是这样的：

ActivityStackSupervisor#realStartActivityLocked():// Create activity launch transaction.

final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,

r.appToken);

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, app.repProcState, r.icicle,

r.persistentState, results, newIntents, mService.isNextTransitionForward(),

profilerInfo));

// Set desired final state.

final ActivityLifecycleItem lifecycleItem;

if (andResume) {

lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());

} else {

lifecycleItem = PauseActivityItem.obtain();

}

clientTransaction.setLifecycleStateRequest(lifecycleItem);

// Schedule transaction.

mService.getLifecycleManager().scheduleTransaction(clientTransaction);

AMS#getLifecycleManager()ClientLifecycleManager getLifecycleManager() {

return mLifecycleManager;

}

ClientLifecycleManager#scheduleTransaction():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.scheduleTransaction(this);

}

mClient：IApplicationThread

所以最终就调用ApplicationThread#scheduleTransaction(…)