ActivityThread的启动流程

在android9.0的基础上，分析Activity的启动流程。
源码地址：https://www.androidos.net.cn/android/9.0.0_r8/xref

1.ActivityThread的启动流程

ActivityThread是应用的主线程/UI线程，其main（）方法是app的入口方法。
ActivityThread继承于ClientTransactionHandler。

1.1 ActivityThread.main()

public final class ActivityThread extends ClientTransactionHandler {

    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
        ...
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        ...
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
}

main方法说明：
1）初始化Looper（用户在主线程中无需再次初始化Looper）；
2）实例化ActivityThread, 并调用attach方法（内部大量IPC过程）；
3）开启消息循环。

1.2 ActivityThread#attach()

    private void attach(boolean system, long startSeq) {
		...
		// mgr为ActivityManagerService
        final IActivityManager mgr = ActivityManager.getService();
        try {
        	mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
        	throw ex.rethrowFromSystemServer();
        }
		...
    }

attach方法说明：
这里mAppThread为ApplicationThread，是Binder对象，主要用于ActivityThread与AMS之间的通信；
AMS运行在SystemServer进程，ActivityThread调用AMS的方法就是IPC过程。

1.3 ActivityManagerService#attachApplication()

    @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
            Binder.restoreCallingIdentity(origId);
        }
    }

ActivityManagerService#attachApplicationLocked() 方法介绍

    @GuardedBy("this")
    private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
		...
		// IPC调用ApplicationThread的方法，创建application并调用onCreate
		thread.bindApplication(19个参数)
		...
        // 创建Activity并调用onCreate
        if (normalMode) {
            try {
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;
                }
            } catch (Exception e) {
                Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                badApp = true;
            }
        }
        ...
    }

AMS#attachApplicationLocked方法说明：
1） 创建application；
  IPC方式调用ApplicationThread的方法, 创建application也是有一套流程。
2）创建activity。

2.Application的创建过程

2.1 ApplicationThread#bindApplication()

由1.3节可以知道，AMS内部调用ApplicationThread的bindApplication来创建和初始化application.

	public final void bindApplication(19个参数){
		...
		AppBindData data = new AppBindData();
		...
		sendMessage(H.BIND_APPLICATION, data);
	}

从主线程消息队列中取出消息H.BIND_APPLICATION，调用handleBindApplication方法

    private void handleBindApplication(AppBindData data) {
    	...
    	// 1.创建ContextImpl与Instrumentation
    	final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
              	appContext.getOpPackageName());
        try {
             final ClassLoader cl = instrContext.getClassLoader();
             mInstrumentation = (Instrumentation)
                cl.loadClass(data.instrumentationName.getClassName()).newInstance();
            } catch (Exception e) {
                throw new RuntimeException(
                    "Unable to instantiate instrumentation "
                    + data.instrumentationName + ": " + e.toString(), e);
            }
    	// 2.创建Application
    	app = data.info.makeApplication(data.restrictedBackupMode, null);
    	// 3.启动ContentProvider并调用onCreate方法 
    	installContentProviders(app, data.providers);
    	// 4.调用applicaton.onCreate
    	mInstrumentation.callApplicationOnCreate(app);
    	...
    }

2.2 Instrumentation#callApplicationOnCreate()

内部实现就是调用application的onCreate方法。

	public void callApplicationOnCreate(Application app) {
        app.onCreate();
    }

ActivityThread#handleBindApplication方法说明：
1） handleBindApplication方法可分为4个步骤，最终完成了application的创建以及onCreate方法调用；
2）解释了ContentProvider#onCreate方法为什么比Application#onCreate先调用。

3.Activity的创建过程

3.1 ActivityStackSupervisor#attachApplicationLocked()

ActivityStackSupervisor是Activity栈管理类
attachApplicationLocked()内部调用realStartActivityLocked()

    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
			...
			// 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));
			// Schedule transaction.
			mService.getLifecycleManager().scheduleTransaction(clientTransaction);
			...
	}

说明：
android9.0与android8.0对此方法的实现有较大改变，8.0的代码更为直观。
android8.0是直接调用app.thread.scheduleLaunchActivity()。

3.2 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();
        }
    }

3.3 ClientTransaction#schedule()

// 这是隐藏的类 @hide，所以在sdk中检索不到
public class ClientTransaction implements Parcelable, ObjectPoolItem {
    /** Target client. */
    private IApplicationThread mClient;
    
    // 3.1节调用此方法获取该类实例
    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;
    }
    
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }
    ...
}

说明：
mClient从调用3.1节调用关系可知，其为ApplicationThread的实例对象。
因此schedule()实际上调用的是ApplicationThread#scheduleTransaction

    private class ApplicationThread extends IApplicationThread.Stub {
    	...
    	
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
    }

调用主线程ActivityThread父类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);
    }
    ...
}

主线程消息队列，分发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;

3.4 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) {
    	...
    	for (int i = 0; i < size; ++i) {
    		final ClientTransactionItem item = callbacks.get(i);
   	 		... 
    		item.execute(mTransactionHandler, token, mPendingActions);
 	   }
    ...
    }

说明：此处item实为3.1节中的LaunchActivityItem
LaunchActivityItem#execute

    @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为ActivityThread， ActivityThread是ClientTransactionHandler 的实现类。
由此，进入ActivityThread#handleLaunchActivity流程

3.5 ActivityThread#handleLaunchActivity()

    @Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
            ...
            final Activity a = performLaunchActivity(r, customIntent);
    }

流程进入我们熟悉的performLaunchActivity方法:
其内部会实例一个activity，并调用其attatch方法，后续便是window的创建、添加过程。
到此，Activity的创建流程就结束了。