首次启动App，Activity的onCreate方法是如何被调用的？

上一篇，我们知道了Application的onCreate方法是如何被调用的，这次来看Activity的onCreate方法又是如何被调用的呢。

同样是先来到ActivityTread中，看Main方法里面的thread.attach()：

//ActivityThread.java
public static void main(String[] args) {
    ......
    //省略一部分代码
 
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
 
     ......
    //省略一部分代码
 
}

//ActivityThread.java
@UnsupportedAppUsage
private void attach(boolean system, long startSeq) {
    //省略一部分代码
 
    //是在进行AMS跨进程的binder通信
    final IActivityManager mgr = ActivityManager.getService();
    try {
          mgr.attachApplication(mAppThread, startSeq);
            } catch (RemoteException ex) {
          throw ex.rethrowFromSystemServer();
        }
 
     ......
    //省略一部分代码
    
}

接着看mgr.attachApplication(mAppThread, startSeq);这里的mgr就是ActiviityManagerService：

//ActivityManagerService.java
@Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        if (thread == null) {
            throw new SecurityException("Invalid application interface");
        }
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
            Binder.restoreCallingIdentity(origId);
        }
    }

继续看attachApplicationLocked(thread, callingPid, callingUid, startSeq);

//ActivityManagerService.java
@GuardedBy("this")
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
 

     if (normalMode) {
            try {
                //mStackSupervisor，该类是Activity配置信息管理
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;
                }
            } catch (Exception e) {
                Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                badApp = true;
            }
        }
    
 
}

这里的mStackSupervisor,它是ActivityStackSupervisor类，用于对Activity配置信息管理，继续看(mStackSupervisor.attachApplicationLocked(app)方法：

//ActivityStackSupervisor
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {

......
/
realStartActivityLocked(activity, app, top == activity /* andResume */, true /* checkConfig */))

}

realStartActivityLocked方法，在这里主要做提取MainActivity数据传入：

//ActivityStackSupervisor
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
......

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

......

//具体的回调执行
 mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}

ClientTransaction类 是app事物调度类，所有Activity相关生命周期由他完成；

ClientTransaction.obtain(app.thread, r.appToken)方法，app.thread就是ApplicationThread；

clientTransaction.addCallback(LaunchActivityItem.obtain())添加回调，传入的是一个LaunchActivityItem对象，它的父类是ClientTransactionItem，它还有其他字类比如PauseActivityItem,LaunchActivityItem,StopActivityItem,ResumeActivityItem,DestroyActivityItem，用于关联对应的生命周期，在这里我们传入的是LaunchActivityItem，记住这个后面有用到。

mService.getLifecycleManager().scheduleTransaction(clientTransaction);就是具体的回调执行：

//ClientLifecycleManager.java
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();
        }
    }

继续看 transaction.schedule()：

//ClientTransaction.java
public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

这里的mClient，就是前面ClientTransaction.obtain(app.thread,r.appToken);传进来的app.thread，也就是ActivityThread.ApplicationThread，即scheduleTransaction(this)，要回调到ActivityThread.ApplicationThread去：

//ActivityThread.java
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        //这里调用的是ActivityThread父类的   scheduleTransaction                
       ActivityThread.this.scheduleTransaction(transaction);
        }

//ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

此处调用ActivityThread父类的scheduleTransaction方法，发送事件EXECUTE_TRANSACTION：

//ActivityThread.java
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;

因为我们之前传进来的是LaunchActivityItem对象，所以这里执行的是LaunchActivityItem的execute(）：

//LaunchActivityItem.java
@Override
    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);
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

此处调用到client.handleLaunchActivity，即调用的是ActivityThread.handleLaunchActivity:

//ActivityThread.java
@Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {

......

    //这里生成Actiivty
    final Activity a = performLaunchActivity(r, customIntent);

}

performLaunchActivity具体生成activity对象：

//ActivityThread.java

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

        .......
        
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        try {
            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);
            }
        }

        ......

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

}

这里主要是由反射生成具体的Activity对象，Activity对象生成后，调用activity.attach()，该方法有个关键步骤就是在初始化PhoneWindow对象：

//Activity.java
final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback) {

        ......

        mWindow = new PhoneWindow(this, window, activityConfigCallback);

}

再回去ActivityThread的performLaunchActivity（）:

//ActivityThread.java

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {


        ......
        
        if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }

}

//Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

最终调用的是Activity对象的onCreate。