應(yīng)用進(jìn)程啟動的入口函數(shù)main()方法中，會調(diào)用Looper相關(guān)的初始化和循環(huán)方法，從而讓主線程的Looper進(jìn)入循環(huán)狀態(tài)，保證app進(jìn)程的一直運(yùn)行狀態(tài)
    public static void main(String[] args) {
        . ..
        //looper綁定主線程
        Looper.prepareMainLooper();
        創(chuàng)建ActivityThread
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);
        //looper開啟無限循環(huán)讀取消息
        Looper.loop();
            . ..
    }
    private void attach(boolean system, long startSeq) {
        if (!system) {
            . ..
            final IActivityManager mgr = ActivityManager.getService();
            try {
                // 通知 AMS， 并將當(dāng)前進(jìn)程的binder句柄傳給AMS綁定管理起來
                mgr.attachApplication(mAppThread, startSeq);
            } catch (RemoteException ex) {
            }
            . ..
        }
        . ..
    }

    void attachApplication(in IApplicationThread app, long startSeq);

// 這里接受APP傳遞過來的消息
    @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            // 通過 Binder 獲取 PID ，PID和UID都是進(jìn)程創(chuàng)建應(yīng)用的時候系統(tǒng)指定的
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        }
    }
    @GuardedBy("this")
    private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
        // *** 1、通知APP進(jìn)程進(jìn)行初始化操作，初始化application，創(chuàng)建應(yīng)用進(jìn)程的application對象
        if (app.isolatedEntryPoint != null) {
        } else if (app.instr != null) {
            thread.bindApplication(processName, appInfo, providers, ...);
        } else {
            thread.bindApplication(processName, appInfo, providers, ...);
        }
        // *** 2、 通知APP拉起指定的MainActivity，調(diào)用ATMS的啟動頁面的方法，后面繼續(xù)介紹
        // See if the top visible activity is waiting to run in this process...
        if (normalMode) {
            try {
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;
                }
            } catch (Exception e) {
            }
        }
    }

void bindApplication(in String packageName, in ApplicationInfo info, ...);

由AMS調(diào)用過來，具體看上面的代碼
public final void bindApplication(String processName, ApplicationInfo appInfo, ...) {
        sendMessage(H.BIND_APPLICATION, data);
}
public void handleMessage(Message msg) {
    switch (msg.what) {
        case BIND_APPLICATION:
        AppBindData data = (AppBindData)msg.obj;
        handleBindApplication(data);
        break;
        . ..
    }
}
private void handleBindApplication(AppBindData data) {
    Application app;
    try{
        classLoader加載APK中的dex，并且加載APK的資源
        final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                appContext.getClassLoader(), false, true, false);
        final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);
        通過 calssLoader 來創(chuàng)建 application 對象
        app=data.info.makeApplication(data.restrictedBackupMode,null);
        try{
            調(diào)用Application的onCreate
            mInstrumentation.onCreate(data.instrumentationArgs);
        }catch(Exception e){
        }
        try{
            mInstrumentation.callApplicationOnCreate(app);
        }catch(Exception e){
        }
    } ... 
}
public Application newApplication(ClassLoader cl, String className, Context context) 。。{
    Application app = getFactory(context.getPackageName()).instantiateApplication(cl, className);
    app.attach(context);
    return app;
}
(Application) cl.loadClass(className).newInstance();

    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
        final String processName = app.processName;
        boolean didSomething = false;
        Activity啟動的入口
        try {
            if (realStartActivityLocked(activity, app, top == activity, true)) {
            }
        } catch (RemoteException e) {
        }
        return didSomething;
    }
    真的開始啟動 activity
    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);
    }

    ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }

    通過代碼，我們可以看到，獲取的client就是 ActivityThread，IApplicationThread是一個AIDL文件
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
    }

        
    /** Target client. */
    private IApplicationThread mClient;
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

    //ActivityThread中沒有復(fù)寫scheduleTransaction，會執(zhí)行到父類的方法
    //public final class ActivityThread extends ClientTransactionHandler
    //ClientTransactionHandler.java
    public abstract class ClientTransactionHandler {
        void scheduleTransaction(ClientTransaction transaction) {
            transaction.preExecute(this);
            //發(fā)送消息
            sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
        }
    }

    case EXECUTE_TRANSACTION:
        final ClientTransaction transaction = (ClientTransaction) msg.obj;
        mTransactionExecutor.execute(transaction);
        break;

    /**
     * Extended implementation of activity launch. Used when server requests a launch or relaunch.
     */
    @Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
        final Activity a = performLaunchActivity(r, customIntent);
        return a;
    }
    Activity實例化過程
    /**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        Activity activity = null;
        try {
            // 通過反射實例化Activity對象
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        } catch (Exception e) {
        }
        window
        theme
        //當(dāng)實例化Activity對象后，繼續(xù)執(zhí)行callActivityOnCreate
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
    }