Activity的启动流程分析

1  private final void startProcessLocked(ProcessRecord app, String hostingType, String hostingNameStr) {
2        // Process里面通知Zygote服务，Zygote真正产生新的进程（准确说是复制一个）
4        int pid = Process.start("android.app.ActivityThread",
6                     mSimpleProcessManagement ? app.processName : null, uid, uid,
7   }

1 public static final void main(String[] args) {
2     Looper.prepareMainLooper();
3     ActivityThread thread = new ActivityThread();
4     thread.attach(false);
5     // 这里闭合消息循环 
6     Looper.loop();
7 }

 1 private final void attach(boolean system) {
 2              ViewRoot.addFirstDrawHandler(new Runnable() {
 4                 public void run() {
 5                     ensureJitEnabled();
 6                 }
 7             });
 8             RuntimeInit.setApplicationObject(mAppThread.asBinder());
 9             IActivityManager mgr = ActivityManagerNative.getDefault();
10             mgr.attachApplication(mAppThread);
11     }

 1 private final class ApplicationThread extends ApplicationThreadNative {
 2 
 3   public final void schedulePauseActivity(IBinder token, boolean finished,boolean userLeaving, int  configChanges){
 4 
 5             queueOrSendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
 6                     token, (userLeaving ? 1 : 0),  configChanges);
 7         }
 8 
 9   public final void scheduleStopActivity(IBinder token, boolean showWindow, int configChanges) {
10            queueOrSendMessage(showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
11                 token, 0, configChanges);
12         }
13 
14   .........
15 
16 }

 1  // ActivityManagerService中XXXLocked函数才是真正干活的地方，XXX只是个套
 2 
 3     public final void attachApplication(IApplicationThread thread) {
 4         int callingPid = Binder.getCallingPid();
 5         attachApplicationLocked(thread, callingPid);
 6     }
 7 
 8  
 9 
10     private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
11 
12         // 这里取出对应该Pid的ProcessRecord对象，如果取不出来，你就等着out吧
13 
14         app = mPidsSelfLocked.get(pid)
15 
16         // 为ProcessRecord对象补充信息
17 
18         app.thread = thread;
19         app.curAdj = app.setAdj = -100;
20         app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
21         app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
22         app.forcingToForeground = null;
23         app.foregroundServices = false;
24         app.debugging = false;
25         // 清除timeout监测 
26         mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
27 
28  
29 
30         // 回调之前的ActivityThread，让它记住自己在ActivityManagerService中的相关信息，传这么大坨东西，真给力
31 
32         thread.bindApplication(processName, app.instrumentationInfo != null
33                     ? app.instrumentationInfo : app.info, providers,
34                     app.instrumentationClass, app.instrumentationProfileFile,
35                     app.instrumentationArguments, app.instrumentationWatcher, testMode, 
36                     isRestrictedBackupMode || !normalMode,
37                     mConfiguration, getCommonServicesLocked());
38 
39        // topRunningActivityLocked的意思没看太明白
40 
41        HistoryRecord hr = topRunningActivityLocked(null);
42 
43        // 启动Activity
44 
45        realStartActivityLocked(hr, app, true, true);
46 
47     }
48 
49  
50 
51     private final boolean realStartActivityLocked(HistoryRecord r,
52             ProcessRecord app, boolean andResume, boolean checkConfig){
53 
54         // 这里又跑到ActivityThread中去了
55 
56        app.thread.scheduleLaunchActivity(new Intent(r.intent), r, System.identityHashCode(r),
57                     r.info, r.icicle, results, newIntents, !andResume, isNextTransitionForward());
58 
59     }
60 
61  

 1 private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {
 2        Activity a = performLaunchActivity(r, customIntent);
 3 
 4        ......
 5 
 6 }
 7 
 8 private final void performLaunchActivity(ActivityRecord r, Intent customIntent) {
 9 
10        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
11        // 产生Activity 
12        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
13 
14        // 将新生的Activity与当前应用关联
15 
16        activity.attach(appContext, this, getInstrumentation(), r.token,
17                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
18                         r.embeddedID, r.lastNonConfigurationInstance,
19                         r.lastNonConfigurationChildInstances, config);
20 
21       .....
22 
23 }

 1 final void attach(Context context, ActivityThread aThread, Instrumentation instr, IBinder token, int ident,
 2     Application application, Intent intent, ActivityInfo info,  CharSequence title, Activity parent, String id,
 3     Object lastNonConfigurationInstance, HashMap<String,Object> lastNonConfigurationChildInstances,
 4             Configuration config) {
 5 
 6        // 记录传入ContexImpl实例，这就是平时所见的Activity Context 
 7        attachBaseContext(context);
 8        // 创建与Activity关联的Window，可以简单理解为显示窗口 
 9        mWindow = PolicyManager.makeNewWindow(this);
10 
11        mUiThread = Thread.currentThread();
12 
13        mMainThread = aThread;
14        mInstrumentation = instr;
15        mToken = token;
16        mIdent = ident;
17        mApplication = application;
18        mIntent = intent;
19        mComponent = intent.getComponent();
20        mActivityInfo = info;
21        mTitle = title;
22        mParent = parent;
23        mEmbeddedID = id;
24       // 构建WindowManager的代理LocalWindowManager 
25        mWindow.setWindowManager(null, mToken, mComponent.flattenToString());
26        if (mParent != null) {
27             // 难道说整个Activity栈中的Activity都有同一个Container 
28             mWindow.setContainer(mParent.getWindow());
29        }
30        mWindowManager = mWindow.getWindowManager();
31 
32     }

 1 private final void performLaunchActivity(ActivityRecord r, Intent customIntent) {
 2 
 3        ......
 4 
 5        // 回调Activity::onCreate
 6 
 7        mInstrumentation.callActivityOnCreate(activity, r.state);
 8 
 9         // 记录新产生的Activity 
10        mActivities.put(r.token, r);
11 
12 }
13 
14 private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {
15 
16        ......
17 
18        handleResumeActivity(r.token, false, r.isForward);
19 
20 }
21 
22  final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward) {
23 
24        ActivityRecord r = performResumeActivity(token, clearHide);
25 
26  
27 
28 }
29 
30 public final ActivityRecord performResumeActivity(IBinder token, boolean clearHide) {
31 
32         if (r.pendingIntents != null) {
33               deliverNewIntents(r, r.pendingIntents);
34               r.pendingIntents = null;
35        }
36        if (r.pendingResults != null) {
37               deliverResults(r, r.pendingResults);
38               r.pendingResults = null;
39        }
40        //回调Activity::onResume 
41        r.activity.performResume();
42 
43 }