Activity的启动流程

以前看了很多，时间长了都忘了，所以还是勤快点，把看到的都记下来，算是给自己点积累。

Activity启动分为很多种情况，这里说的是打开新的应用程序第一个Activity的流程。

1. AcitivityManager产生新进程，新进程从android.app.ActivityThread.main开始运行。这里就是一般意义上的程序入口点，类似于C的main函数。

ActivityManagerService.java

private final void startProcessLocked(ProcessRecord app, String hostingType, String hostingNameStr) {

    // Process里面通知Zygote服务，Zygote真正产生新的进程（准确说是复制一个）

    int pid = Process.start("android.app.ActivityThread",
             mSimpleProcessManagement ? app.processName : null, uid, uid,

}

2.ActivityThread的main函数中将Looper准备起来，prepareMainLooper标志着这是应用程序主线程的Looper对象。

ActivityThread.java

public static final void main(String[] args) {

    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
        thread.attach(false);
        // 这里闭合消息循环 
        Looper.loop();

}

3. 接下来调用attach，参数为false，表明这不是系统进程，是给普通应用程序用使用的进程。

ActivityThread.java

private final void attach(boolean system) {

    ViewRoot.addFirstDrawHandler(new Runnable() {
            public void run() {
                ensureJitEnabled();
            }
        });
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        IActivityManager mgr = ActivityManagerNative.getDefault();
        mgr.attachApplication(mAppThread);

}

mAppThread是ApplicationThread对象，是提供给ActivityManagerService控制ActivityThread的回调接口。

private final class ApplicationThread extends ApplicationThreadNative {

    public final void schedulePauseActivity(IBinder token, boolean finished,boolean userLeaving, int configChanges){

        queueOrSendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
            token, (userLeaving ? 1 : 0), configChanges);
        }

    public final void scheduleStopActivity(IBinder token, boolean showWindow, int configChanges) {
            queueOrSendMessage(showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
            token, 0, configChanges);
        }

    .........

}

ActivityManagerService要Pause当前Activity，就会调用schedulePauseActivity想本地的消息循环中加入一个H.PAUSE_ACTIVITY的消息，然后立即返回以避免ActivityManagerService的阻塞。

4.现在又回到了ActivityManagerService中

ActivityManagerService.java

// ActivityManagerService中XXXLocked函数才是真正干活的地方，XXX只是个套

public final void attachApplication(IApplicationThread thread) {
        int callingPid = Binder.getCallingPid();
        attachApplicationLocked(thread, callingPid);
    }

private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {

    // 这里取出对应该Pid的ProcessRecord对象，如果取不出来，你就等着out吧

    app = mPidsSelfLocked.get(pid)

    // 为ProcessRecord对象补充信息

    app.thread = thread;
        app.curAdj = app.setAdj = -100;
        app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
        app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
        app.forcingToForeground = null;
        app.foregroundServices = false;
        app.debugging = false;
        // 清除timeout监测 
        mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

    // 回调之前的ActivityThread，让它记住自己在ActivityManagerService中的相关信息，传这么大坨东西，真给力

    thread.bindApplication(processName, app.instrumentationInfo != null
        app.instrumentationInfo : app.info, providers,
        app.instrumentationClass, app.instrumentationProfileFile,
        app.instrumentationArguments, app.instrumentationWatcher, testMode, 
        isRestrictedBackupMode || !normalMode,
        mConfiguration, getCommonServicesLocked());

    // topRunningActivityLocked的意思没看太明白

    HistoryRecord hr = topRunningActivityLocked(null);

    // 启动Activity

    realStartActivityLocked(hr, app, true, true);

}

private final boolean realStartActivityLocked(HistoryRecord r,
    ProcessRecord app, boolean andResume, boolean checkConfig){

    // 这里又跑到ActivityThread中去了

    app.thread.scheduleLaunchActivity(new Intent(r.intent), r, System.identityHashCode(r),
        r.info, r.icicle, results, newIntents, !andResume, isNextTransitionForward());

}

5.ActivityThread开始调度用户的Activity启动了

ActivityThread.java

private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {
        Activity a = performLaunchActivity(r, customIntent);

    ......

}

private final void performLaunchActivity(ActivityRecord r, Intent customIntent) {

    java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        // 产生Activity 
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);

    // 将新生的Activity与当前应用关联

    activity.attach(appContext, this, getInstrumentation(), r.token,
        r.ident, app, r.intent, r.activityInfo, title, r.parent,
        r.embeddedID, r.lastNonConfigurationInstance,
        r.lastNonConfigurationChildInstances, config);

    .....

}

6.Acivity与当前App关联，直到这里，平时应用所见的Activity才真正被构建

Actiivty.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,
    Object lastNonConfigurationInstance, HashMap lastNonConfigurationChildInstances,
    Configuration config) {

    // 记录传入ContexImpl实例，这就是平时所见的Activity Context 
        attachBaseContext(context);
        // 创建与Activity关联的Window，可以简单理解为显示窗口 
        mWindow = PolicyManager.makeNewWindow(this);

    mUiThread = Thread.currentThread();

    mMainThread = aThread;
        mInstrumentation = instr;
        mToken = token;
        mIdent = ident;
        mApplication = application;
        mIntent = intent;
        mComponent = intent.getComponent();
        mActivityInfo = info;
        mTitle = title;
        mParent = parent;
        mEmbeddedID = id;
        // 构建WindowManager的代理LocalWindowManager 
        mWindow.setWindowManager(null, mToken, mComponent.flattenToString());
        if (mParent != null) {
            // 难道说整个Activity栈中的Activity都有同一个Container 
            mWindow.setContainer(mParent.getWindow());
     }
     mWindowManager = mWindow.getWindowManager();

}

7.ActivityThread

ActivityThread.java

private final void performLaunchActivity(ActivityRecord r, Intent customIntent) {

     ......

     // 回调Activity::onCreate

     mInstrumentation.callActivityOnCreate(activity, r.state);

    // 记录新产生的Activity 
         mActivities.put(r.token, r);

}

private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {

    ......

    handleResumeActivity(r.token, false, r.isForward);

}

final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward) {
    ActivityRecord r = performResumeActivity(token, clearHide);

}

public final ActivityRecord performResumeActivity(IBinder token, boolean clearHide) {

    if (r.pendingIntents != null) {
            deliverNewIntents(r, r.pendingIntents);
             r.pendingIntents = null;
         }
        if (r.pendingResults != null) {
            deliverResults(r, r.pendingResults);
            r.pendingResults = null;
        }
        //回调Activity::onResume 
        r.activity.performResume();

}

到这里，Activity从产生到初始化的过程就全部结束了。之后就是等待用户界面的消息，根据消息进行相应的处理。整个过程中，在ActivityManagerServer、ActivityThread的互相协作下构建出Activity，并在相应的时机回调Activity的相应接口，完成Activity的初始化。