Android中Activity的启动流程

发表于 更新于 阅读次数：

前言

在这篇文章中，将会基于android 26源码上分析Activity从启动到显示到屏幕和Decorview添加到Window中的过程。另外在本文中，省略了很多内容，目的只是从源码中找到一条启动的线索。迟点再补充上流程图。

从startActivity开始说起

在应用层开发时，Acitvity跳转会写出下面的代码：

1
2
3
4
5
6
public static void startAtcivity(BaseActivity activity) {
        if(activity != null) {
            Intent intent = new Intent(activity, HomeAcivity.class);
            activity.startActivity(intent);
        }
    }

首先看下activity的继承关系：

context继承关系

activity继承关系

第一张图，知道activity是context的子类，第二张图，我们可以知道各种activity的关系。
另外会写一片文章，介绍context。

现在我们进入activity#startActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Override
public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        // Note we want to go through this call for compatibility with
        // applications that may have overridden the method.
        startActivityForResult(intent, -1);
    }
}

接着调用activity#startActivityForResult

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        //1、Instrumentation
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        if (ar != null) {
            mMainThread.sendActivityResult(
                mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                ar.getResultData());
        }
     ...
    } else {
        ...
    }
}

在1、中，出现了Instrumentation，并调用了execStartActivity方法
进入Instrumentation#execStartActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
   ...
    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
            for (int i=0; i<N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                ActivityResult result = null;
                if (am.ignoreMatchingSpecificIntents()) {
                    result = am.onStartActivity(intent);
                }
                ...
            }
        }
    }
    try {
        ...
        //1、进入ActivityManagerService中
        int result = ActivityManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        //2、检查创建actiity过程是否产生了异常            
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

在1、中，出现了ActivityManager。取到IActivityManager，这里有涉及binder机制，ActivityManager.getService()得到的就是ActivityManagerService，ActivityManagerService实现了IActivityManager.Stub，而ActivityManager中有IActivityManager.Stub.asInterface的远程调用。
ActivityManager#getService

1
2
3
4
5
6
7
8
9
10
11
12
13
 public static IActivityManager getService() {
     return IActivityManagerSingleton.get();
 }

private static final Singleton<IActivityManager> IActivityManagerSingleton =
         new Singleton<IActivityManager>() {
             @Override
             protected IActivityManager create() {
                 final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                 final IActivityManager am = IActivityManager.Stub.asInterface(b);
                 return am;
             }
         };

在2、中，Instrumentation#checkStartActivityResult方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/** @hide */
public static void checkStartActivityResult(int res, Object intent) {
    if (!ActivityManager.isStartResultFatalError(res)) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
            //1、出现没有注册异常
                throw new ActivityNotFoundException(
                        "Unable to find explicit activity class "
                        + ((Intent)intent).getComponent().toShortString()
                        + "; have you declared this activity in your AndroidManifest.xml?");
            throw new ActivityNotFoundException(
                    "No Activity found to handle " + intent);
        case ActivityManager.START_PERMISSION_DENIED:
            throw new SecurityException("Not allowed to start activity "
                    + intent);
        case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
            throw new AndroidRuntimeException(
                    "FORWARD_RESULT_FLAG used while also requesting a result");
        case ActivityManager.START_NOT_ACTIVITY:
            throw new IllegalArgumentException(
                    "PendingIntent is not an activity");
        case ActivityManager.START_NOT_VOICE_COMPATIBLE:
            throw new SecurityException(
                    "Starting under voice control not allowed for: " + intent);
        case ActivityManager.START_VOICE_NOT_ACTIVE_SESSION:
            throw new IllegalStateException(
                    "Session calling startVoiceActivity does not match active session");
        case ActivityManager.START_VOICE_HIDDEN_SESSION:
            throw new IllegalStateException(
                    "Cannot start voice activity on a hidden session");
        case ActivityManager.START_ASSISTANT_NOT_ACTIVE_SESSION:
            throw new IllegalStateException(
                    "Session calling startAssistantActivity does not match active session");
        case ActivityManager.START_ASSISTANT_HIDDEN_SESSION:
            throw new IllegalStateException(
                    "Cannot start assistant activity on a hidden session");
        case ActivityManager.START_CANCELED:
            throw new AndroidRuntimeException("Activity could not be started for "
                    + intent);
        default:
            throw new AndroidRuntimeException("Unknown error code "
                    + res + " when starting " + intent);
    }
}

这是检查在启动activity过程中，可能出现的异常。比如，启动的Acitivity没有在AndroidManifest.xml中注册，会出现代码中1、的异常。

继续，回到在execStartActivity的1、进入ActivityManagerService#startActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Override
public int startActivity(IBinder whoThread, String callingPackage,
        Intent intent, String resolvedType, Bundle bOptions) {
    checkCaller();

    int callingUser = UserHandle.getCallingUserId();
    TaskRecord tr;
    IApplicationThread appThread;
    synchronized (ActivityManagerService.this) {
        tr = mStackSupervisor.anyTaskForIdLocked(mTaskId);
        if (tr == null) {
            throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
        }
        //1、IApplicationThread
        appThread = IApplicationThread.Stub.asInterface(whoThread);
        if (appThread == null) {
            throw new IllegalArgumentException("Bad app thread " + appThread);
        }
    }
    //2、ActivityStarter
    return mActivityStarter.startActivityMayWait(appThread, -1, callingPackage, intent,
            resolvedType, null, null, null, null, 0, 0, null, null,
            null, bOptions, false, callingUser, null, tr, "AppTaskImpl");
}

在1、处，出现了IApplicationThread，这里涉及到了binder机制，IApplicationThread的实现是在ActivityThread中的内部类ApplicationThread

ActivityThread#ApplicationThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 private class ApplicationThread extends IApplicationThread.Stub {
   
...

     private void updatePendingConfiguration(Configuration config) {
        ...
     }

     public final void schedulePauseActivity(IBinder token, boolean finished,
          ...
     }

     public final void scheduleStopActivity(IBinder token, boolean showWindow,
             int configChanges) {
         ...
     }

     public final void scheduleWindowVisibility(IBinder token, boolean showWindow) {
         ...
     }

    ...
 
     public final void scheduleResumeActivity(IBinder token, int processState,
             boolean isForward, Bundle resumeArgs) {
         ...
     }

     public final void scheduleSendResult(IBinder token, List<ResultInfo> results) {
         ...
     }

     @Override
     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
             ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
             CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
             int procState, Bundle state, PersistableBundle persistentState,
             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
             boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

        ...
     }

     @Override
     public final void scheduleRelaunchActivity(IBinder token,
             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
             int configChanges, boolean notResumed, Configuration config,
             Configuration overrideConfig, boolean preserveWindow) {
        ...
     }

     public final void scheduleNewIntent(
             List<ReferrerIntent> intents, IBinder token, boolean andPause) {
         ...
     }

     public final void scheduleDestroyActivity(IBinder token, boolean finishing,
             int configChanges) {
         ...
     }

     public final void scheduleReceiver(Intent intent, ActivityInfo info,
             CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras,
             boolean sync, int sendingUser, int processState) {
         ...
     }

    ...

     public final void scheduleCreateService(IBinder token,
             ServiceInfo info, CompatibilityInfo compatInfo, int processState) {
        ...
     }

     public final void scheduleBindService(IBinder token, Intent intent,
             boolean rebind, int processState) {
         ...
     }

     public final void scheduleUnbindService(IBinder token, Intent intent) {
        ...
     }

     public final void scheduleServiceArgs(IBinder token, ParceledListSlice args) {
         List<ServiceStartArgs> list = args.getList();
 ...
     }

     public final void scheduleStopService(IBinder token) {
         ...
     }

     public final void bindApplication(String processName, ApplicationInfo appInfo,
             List<ProviderInfo> providers, ComponentName instrumentationName,
             ProfilerInfo profilerInfo, Bundle instrumentationArgs,
             IInstrumentationWatcher instrumentationWatcher,
             IUiAutomationConnection instrumentationUiConnection, int debugMode,
             boolean enableBinderTracking, boolean trackAllocation,
             boolean isRestrictedBackupMode, boolean persistent, Configuration config,
             CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
             String buildSerial) {
...
     }

    ...

     public void scheduleConfigurationChanged(Configuration config) {
         updatePendingConfiguration(config);
         ...
     }

   ...

     public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
             int resultCode, String dataStr, Bundle extras, boolean ordered,
             boolean sticky, int sendingUser, int processState) throws RemoteException {
         ...
     }

    ...

     @Override
     public void scheduleActivityConfigurationChanged(
             IBinder token, Configuration overrideConfig) {
        ...
     }

   ...
 }

在ApplicationThread中，有很多与Activity，service，Application生命周期有关的方法。
其中scheduleLaunchActivity()应该就是负责Activity创建的。

ActivityManagerService#startActivity的2、处，调用了ActivityStarter的startActivityMayWait方法，它又调用了startActivityLocked方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
   1、
   int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
          ...

       mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
               aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
               callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
               options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
               container, inTask);

      ...
       return mLastStartActivityResult;
   }
   
   2、
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
           String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
           IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
           IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
           String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
           ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
           ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
           TaskRecord inTask) {
     ...

       return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
               options, inTask, outActivity);
   }
   
   3、
   private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
      ...
       try {
           mService.mWindowManager.deferSurfaceLayout();
           result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                   startFlags, doResume, options, inTask, outActivity);
       } finally {
           ...
       }

      ...
       return result;
   }

在3、中，调用了startActivityUnchecked方法，startActivityUnchecked又调用了ActivityStackSupervisor#resumeFocusedStackTopActivityLocked方法，

ActivityStackSupervisor#resumeFocusedStackTopActivityLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

上面方法中，接着调用ActivityStack的resumeTopActivityUncheckedLocked方法，
ActivityStack#resumeTopActivityUncheckedLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    if (mStackSupervisor.inResumeTopActivity) {
        // Don't even start recursing.
        return false;
    }

    boolean result = false;
    try {
        // Protect against recursion.
        mStackSupervisor.inResumeTopActivity = true;
        result = resumeTopActivityInnerLocked(prev, options);
    } finally {
        mStackSupervisor.inResumeTopActivity = false;
    }
...

    return result;
}

接着调用resumeTopActivityInnerLocked方法，在resumeTopActivityInnerLocked中调用ActivityStackSupervisor的startSpecificActivityLocked方法

ActivityStackSupervisor#startSpecificActivityLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void startSpecificActivityLocked(ActivityRecord r,
        boolean andResume, boolean checkConfig) {
    ...
    if (app != null && app.thread != null) {
        try {
            if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                    || !"android".equals(r.info.packageName)) {
               ...
            }
            realStartActivityLocked(r, app, andResume, checkConfig);
            return;
        } catch (RemoteException e) {
           ...
        }

    }

    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

方法中调用了realStartActivityLocked方法，它里面有下面的代码：

ActivityStackSupervisor#realStartActivityLocked

1
2
3
4
5
6
7
8
9
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
		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, !andResume,
         mService.isNextTransitionForward(), profilerInfo);

上面的app.thread就是ApplicationThread,并调用scheduleLaunchActivity。

上面曾经说过ApplicationThread是AcitivityThread的内部类。

进入ApplicationThread的scheduleLaunchActivity方法，它最后会发送一个消息给名为H的handler

1
sendMessage(H.LAUNCH_ACTIVITY, r);

H.LAUNCH_ACTIVITY的消息处理逻辑是：

1
2
3
4
5
6
7
8
9
case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

调用handleLaunchActivity方法。在handleLaunchActivity主要是分别调用performLaunchActivity和handleResumeActivity方法

进入ActivityThread#performLaunchActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
        //1、收集创建Acitivity的信息
        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ...

        //2、创建Context的实现者ContextImpl
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        try {
			//3、通Instrumentation创建activity
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            ...
        } catch (Exception e) {
            ...
        }

        try {
            //4、创建Application
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

           ...
            if (activity != null) {
                ...
                appContext.setOuterContext(activity);
                //5、调用activity的attach方法
                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);
                ...
                
               if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                if (r.isPersistable()) {
                    //6、调用Activity的OnCreate方法
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }            

                ...
                //7、调用Activity的OnStart方法
                 if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                
                ...
            }
            r.paused = true;

            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            ...
        }

        return activity;
    }

在3、中，会调用Instrumentation#newActivity

1
2
3
4
5
6
public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        return (Activity)cl.loadClass(className).newInstance();
    }

可以看出是通过类加载器通过反射创建Activity实例的。

在4、中，调用了LoadedApk#makeApplication方法，

1
2
app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);

makeApplication方法中，和newActivity差不多，也是由Instrumentation的newApplication方法，通过反射创建Application的

5、中调用Acitivty的attach方法，

Acitivty#attach

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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) {
    attachBaseContext(context);

    mFragments.attachHost(null /*parent*/);

    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);
    ...
    mUiThread = Thread.currentThread();
    ...
    mWindow.setWindowManager(
            (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
            mToken, mComponent.flattenToString(),
            (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    if (mParent != null) {
        mWindow.setContainer(mParent.getWindow());
    }
    mWindowManager = mWindow.getWindowManager();
    mCurrentConfig = config;

    mWindow.setColorMode(info.colorMode);
}

在该方法中，主要是会创建PhoneWindow。

在6和7中，分别调用了acitivity的生命周期方法，onCreate和onStart。

已经分析了在handleLaunchActivity的performLaunchActivity方法。
现在分析handleLaunchActivity的handleResumeActivity，在handleResumeActivity中会调用acitivity的生命周期方法onResume和将Decorview添加到Window中，并在makeVisible中显示出来。

Activity#handleResumeActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        ActivityClientRecord r = mActivities.get(token);
        if (!checkAndUpdateLifecycleSeq(seq, r, "resumeActivity")) {
            return;
        }

        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        //1、会调用Acitvity的onResume生命周期方法
        // TODO Push resumeArgs into the activity for consideration
        r = performResumeActivity(token, clearHide, reason);

        if (r != null) {
            final Activity a = r.activity;

            ...
            if (!willBeVisible) {
                try {
                    willBeVisible = ActivityManager.getService().willActivityBeVisible(
                            a.getActivityToken());
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();
                //2、设置decor不可见
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (r.mPreserveWindow) {
                    a.mWindowAdded = true;
                    r.mPreserveWindow = false;
                    // Normally the ViewRoot sets up callbacks with the Activity
                    // in addView->ViewRootImpl#setView. If we are instead reusing
                    // the decor view we have to notify the view root that the
                    // callbacks may have changed.
                    ViewRootImpl impl = decor.getViewRootImpl();
                    if (impl != null) {
                        impl.notifyChildRebuilt();
                    }
                }
                if (a.mVisibleFromClient) {
                    if (!a.mWindowAdded) {
                        a.mWindowAdded = true;
                        //3、将Decorviewt添加到Window
                        wm.addView(decor, l);
                    } else {
                        // The activity will get a callback for this {@link LayoutParams} change
                        // earlier. However, at that time the decor will not be set (this is set
                        // in this method), so no action will be taken. This call ensures the
                        // callback occurs with the decor set.
                        a.onWindowAttributesChanged(l);
                    }
                }

            // If the window has already been added, but during resume
            // we started another activity, then don't yet make the
            // window visible.
            } else if (!willBeVisible) {
                if (localLOGV) Slog.v(
                    TAG, "Launch " + r + " mStartedActivity set");
                r.hideForNow = true;
            }

            // Get rid of anything left hanging around.
            cleanUpPendingRemoveWindows(r, false /* force */);

            // The window is now visible if it has been added, we are not
            // simply finishing, and we are not starting another activity.
            if (!r.activity.mFinished && willBeVisible
                    && r.activity.mDecor != null && !r.hideForNow) {
                if (r.newConfig != null) {
                    performConfigurationChangedForActivity(r, r.newConfig);
                    if (DEBUG_CONFIGURATION) Slog.v(TAG, "Resuming activity "
                            + r.activityInfo.name + " with newConfig " + r.activity.mCurrentConfig);
                    r.newConfig = null;
                }
                if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward="
                        + isForward);
                WindowManager.LayoutParams l = r.window.getAttributes();
                if ((l.softInputMode
                        & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
                        != forwardBit) {
                    l.softInputMode = (l.softInputMode
                            & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
                            | forwardBit;
                    if (r.activity.mVisibleFromClient) {
                        ViewManager wm = a.getWindowManager();
                        View decor = r.window.getDecorView();
                        wm.updateViewLayout(decor, l);
                    }
                }

                r.activity.mVisibleFromServer = true;
                mNumVisibleActivities++;
                if (r.activity.mVisibleFromClient) {
                    //4、调用makeVisible
                    r.activity.makeVisible();
                }
            }

            ...

        } else {
           ...
        }
    }

在1、处的performResumeActivity方法中，会调用以下代码：

1
r.activity.performResume();

即调用activity的onResume生命周期方法。

在2、中，设置了Decorview为不可见
在3、中，将Decorview添加到window中，由于2中设置了Decorview为不可见，这时view还看不到。
在4、中，调用Activity的makeVisible方法。
Activity#makeVisible

1
2
3
4
5
6
7
8
void makeVisible() {
    if (!mWindowAdded) {
        ViewManager wm = getWindowManager();
        wm.addView(mDecor, getWindow().getAttributes());
        mWindowAdded = true;
    }
    mDecor.setVisibility(View.VISIBLE);
}

上面代码中，将Decorview设置为可见的。

剩下问题

在上面过程中的哪里开始涉及视图绘制。迟点再看。
分析追溯到Zygote中。
本篇文章的排版还有点乱。

优秀文章：http://blog.csdn.net/dd864140130/article/details/60466394