ActivityThread调用TransactionExecutor.cycleToPath执行改变当前生命周期状态， 最后由Instrumentation执行具体的Activity生命周期方法

1.Activity相关方法回调

1.1 attach，onCreate

 //ActivityThread
 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
          //调用attach
         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);
......
         if (r.isPersistable()) {
          //通过Instrumentation调用OnCreate
         mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
         } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
         }
 }

1.2 onStart

//ActivityThread
public void handleStartActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
......
        //通过Instrumentation调用OnStart
        activity.performStart("handleStartActivity");
        r.setState(ON_START);
......
    }

//Activity
final void performStart(String reason) {
......
     //通过Instrumentation调用OnStart
     mInstrumentation.callActivityOnStart(this);
......
}

1.3 onResume,上个页面onStop

//ActivityThread
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
            String reason) {
......
        //通过Instrumentation调用OnResume
        final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
......
        //等待这个页面执行完毕后 执行上个页面的onStop
        Looper.myQueue().addIdleHandler(new Idler());
......
}

2.TransactionExecutor回调ActivityThread相关方法

//使用事务处理程序初始化实例，该实例将执行所有请求的操作
public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
    //clientTransactionHandler为ActivityThread
    mTransactionHandler = clientTransactionHandler;
}

//执行任务
public void execute(ClientTransaction transaction) {
        final IBinder token = transaction.getActivityToken();
        //循环回调请求的所有状态并在适当的时间执行它们（如果有callback 先执行其生命周期回调方法  例： Activity的onCreate,onStart）
        executeCallbacks(transaction);
        //如果有请求，转换到最终状态（生命周期最终回调方法  例：onResume）
        executeLifecycleState(transaction);

        mPendingActions.clear();
    }

 public void executeCallbacks(ClientTransaction transaction) {
 ..........
  //循环执行回调
  for(...){
    final ClientTransactionItem item = callbacks.get(i);
    //执行客户端生命周期方法
    item.execute(mTransactionHandler, token, mPendingActions);
    item.postExecute(mTransactionHandler, token, mPendingActions);
   ..........   
     //客户端状态转换
     cycleToPath(r, postExecutionState, shouldExcludeLastTransition);
    }
 ..........    
    
 }

 private void executeLifecycleState(ClientTransaction transaction) {
..........
   .    //客户端状态转换
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
        // 执行最终转换
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
..........
 }

//在状态之间转换状态
private void cycleToPath(ActivityClientRecord r, int finish,
            boolean excludeLastState) {
        final int start = r.getLifecycleState();
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
        performLifecycleSequence(r, path);
}

//回调ActivityThread各生命周期方法
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            log("Transitioning to state: " + state);
            switch (state) {
                case ON_CREATE:
                    mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                            null /* customIntent */);
                    break;
                case ON_START:
                    mTransactionHandler.handleStartActivity(r, mPendingActions);
                    break;
                case ON_RESUME:
                    mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                            r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                    break;
                case ON_PAUSE:
                    mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                            false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                            "LIFECYCLER_PAUSE_ACTIVITY");
                    break;
                case ON_STOP:
                    mTransactionHandler.handleStopActivity(r.token, false /* show */,
                            0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                            "LIFECYCLER_STOP_ACTIVITY");
                    break;
                case ON_DESTROY:
                    mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                            0 /* configChanges */, false /* getNonConfigInstance */,
                            "performLifecycleSequence. cycling to:" + path.get(size - 1));
                    break;
                case ON_RESTART:
                    mTransactionHandler.performRestartActivity(r.token, false /* start */);
                    break;
                default:
                    throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
            }
        }
}