Activity启动流程

Activity启动过程中做了哪些事情？下面的时序图展示里启动过程中函数的调用过程, 从图中可以知道大概流程。

在介绍细节的时候是从上往下函数调用过程介绍的，如果不知道某个函数是在哪里被谁调用的，可以回过头来看下时序图。下面是对一些细节进行介绍。

1. 在Android中有两种操作会引发Activity的启动，一种用户点击Launcher的应用程序图标时，Launcher会为启动应用程序的主Activity。另外一种是在已经起来的Activity内部通过调用startActvity接口启动新的Activity。每一个Activity都可以在内部启动新的Activity。图中就是从一个Activity调用startActivity启动另外一个Activity开始。

startActivity()@Activity.java

public void startActivity(Intent intent, 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);
        }
}

startActivity()中调用携带requestCode参数的startActivityForResult()启动新的activity。

startActivityForResult()@Activity.java

public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
    //一般的Activity的mParent为null
    if (mParent == null) {
        //调用Instrumentation.execStartActivity()启动新的Activity。mMainThread类型为ActivityThread, 在attach()函数被回调时被赋值。
        Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
        if (ar != null) {    // 如果activity之前已经启动，而且处于阻塞状态，execStartActivity函数直接返回要启动的activity的result或者null。（注意：这就是Activity.onActivityResult()会在启动另外一个activity启动时被回调的原因。
            // 若result非空，发送结果给本activity，即onActivityResult会被调用。
            mMainThread.sendActivityResult(mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                                            ar.getResultData());
        }
        if (requestCode >= 0) {
            // 如果这次启动需要被启动的activity返回一个结果，则在收到返回结果前，本activity保持不可见。
            mStartedActivity = true;
        }

        final View decor = mWindow != null ? mWindow.peekDecorView() : null;
        if (decor != null) {
            decor.cancelPendingInputEvents();
        }
        // TODO Consider clearing/flushing other event sources and events for child windows.
    } else {
        //在ActivityGroup内部的Activity调用startActivity的时候会走到这里，内部处理逻辑和上面是类似的
        if (options != null) {
            mParent.startActivityFromChild(this, intent, requestCode, options);
        } else {
            mParent.startActivityFromChild(this, intent, requestCode);
        }
    }
}

Instrumentation类的功能是辅助Activity的监控和测试，接着看execStartActivity()函数的实现。

execStartActivity()@Instrumentation.java

 1 public ActivityResult execStartActivity(
 2         Context who, IBinder contextThread, IBinder token, Activity target,
 3         Intent intent, int requestCode, Bundle options) {
 4     //将contextThread转成ApplicationThread.
 5     IApplicationThread whoThread = (IApplicationThread) contextThread;
 6     if (mActivityMonitors != null) {
 7         synchronized (mSync) {
 8              //检查是否存在这个activity
 9             final int N = mActivityMonitors.size();
10             for (int i=0; i<N; i++) {
11                  final ActivityMonitor am = mActivityMonitors.get(i);
12                  if (am.match(who, null, intent)) {
13                      am.mHits++;
14                      if (am.isBlocking()) {                       //若找到，而且处于阻塞状态，直接返回。         
15                          return requestCode >= 0 ? am.getResult() : null;
16                      }
17                      break;
18                 }
19             }
20         }
21     }
22     try {
23         intent.migrateExtraStreamToClipData();     //转移数据
24         intent.prepareToLeaveProcess();            //准备让intent离开一个app进程
25         //通过AcitivityManagerNative与ActivityManagerService关联起来，两个类的关系如下图，由ActivityManagerService去执行实际动作。
26         int result = ActivityManagerNative.getDefault()
27             .startActivity(whoThread, who.getBasePackageName(), intent,
28                     intent.resolveTypeIfNeeded(who.getContentResolver()),
29                     token, target != null ? target.mEmbeddedID : null,
30                     requestCode, 0, null, null, options);
31         //检查启动结果，如果无法打开activity，则抛出诸如ActivityNotFoundException类似的各种异常
32         checkStartActivityResult(result, intent);
33     } catch (RemoteException e) {
34     }
35     return null;
36 }

2. ActivityManager的功能是与系统中所有运行着的Activity交互提供了接口，主要的接口围绕着运行中的进程信息，任务信息，服务信息等，它的大多数功能都是调用了ActivityManagerNative类接口来完成的。
ActivityManager相关静态类图如下图，可以看出这是典型的Proxy模式：

结合面的类结构图，其中ActivityManager是一个客户端，为了减少它与ActivityManagerService的耦合度，在这中间使用了ActivityManagerNative类，该类内部使用ActivityManagerProxy代理类，所有对 ActivityManagerService的访问都转换成对代理类的访问，这样ActivityManager就与ActivityManagerService解耦了。
    为了让代理类与被代理类保持一致的接口，由IActivityManager作为ActivityManagerProxy和ActivityManagerNative的公共接口，ActivityManagerService继承于ActivityManagerNative，也具有相同的接口。

图中绿色的部分是在SDK中开放给应用程序开发人员的接口，蓝色的部分是Proxy模式的实现，红色的部分是底层的服务实现，是真正的动作执行者。

3. startActivity()@ActivityManagerService.java

 @Override
 public final int startActivity(IApplicationThread caller, String callingPackage,
           Intent intent, String resolvedType, IBinder resultTo,
           String resultWho, int requestCode, int startFlags,
           String profileFile, ParcelFileDescriptor profileFd, Bundle options) {
     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                                resultWho, requestCode, startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());
 }

@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
         Intent intent, String resolvedType, IBinder resultTo,
         String resultWho, int requestCode, int startFlags,
         String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {
    enforceNotIsolatedCaller("startActivity");
    userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
             false, true, "startActivity", null);
     // TODO: Switch to user app stacks here.
    return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,
             null, null, options, userId);
}

类ActivityStackSupervisor是用来辅助ActivityManagerService对Activity和Task的管理的。其中用ActivityStackSupervisor类型来进行对Task的操作，用ActivityStack对Acitivity进行操作。

4. 调用mStackSupervisor.startActivityMayWait()函数后，会执行下面几个函数，调用关系参照时序图，函数里涉及很多细节，这里只简单描述下它们的主要功能：

调用9. ActivityStackSupervisor.startActivityLocked():  检查启动权限，创建新的ActivityRecord。

调用10. ActivityStackSupervisor.startActivityUncheckedLocked()：处理intent携带的launch flags, launchMode。(后面再研究launch相关的flag和mode)

调用11. ActivityStack.startActivityLocked()：将activity放到所属task的顶部，重置Task（resetTaskIfNeededLocked），调用WindowManager.setAppStartingWindow()。

调用13. ActivityStackSupervisor.resumeTopActivitiesLocked()：判断ActivityStack数组中是否存在target ActivityStack。

调用14. ActivityStack.resumeTopActivityLocked(): 从当前activity切换到要启动的activity。

调用15. ActivityStackSupervisor.startSpecificActivityLocked():获取ProcessRecord(若要启动的activity的应用已经在运行)，若获取ProcessRecord存在则调用realStartActivityLocked()，否则调用 ActivityManagerServices.startProcessLocked()创建新的ProcessRecord，最后调用Process.start()启动新的进程（最终调用Zygote启动新的进程，为了避免混淆，这部分在时序图中没有体现，后面再研究）。

调用16. ActivityStackSupervisor.realStartActivityLocked(): 调用mWindowManager.setAppVisibility()设置app可见。

调用19. ActivityThread.scheduleLauncherActivity(): 发送Message LAUNCH_ACTIVITY给Handler.

5. Handler接收到message后，执行ActivityThread.handleLaunchActivity()。

handleLaunchActivity()@ActivityThread.java

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ......
    Activity a = performLaunchActivity(r, customIntent);  // 返回一个activity.
    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        Bundle oldState = r.state;
        handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed);

        if (!r.activity.mFinished && r.startsNotResumed) {
            // 当这个activity没有finished而且没有处于resumed状态时，Acivity Manager实际上想要这个activity以paused状态开始，因为它需要可见，但是又不在前台。 
            // 为此，需要经过正常启动（因为activity希望在它们的window被显示前，它们第一次运行时通过onResume），然后暂停它。The activity manager actually wants this one to start out
            //然而，在这种情况下，不需要走完整的暂停周期(比如freezing等)，因为activity假定它可以刚好保留它当前的所有状态。
            try {
               r.activity.mCalled = false;
               mInstrumentation.callActivityOnPause(r.activity);
               ......
             } catch (SuperNotCalledException e) {
                 ......
             } catch (Exception e) {
                 ......
             }
            r.paused = true;
        }
    } else {
        ......
    }
}

6.进一步看performLaunchActivity()，这个函数做了几件重要的事情：创建activity实例，调用Activity.attach()设置参数，触发Activity.onCreate()。

performLaunchActivity()@ActivityThread.java

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {        // 填充package info
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                                       Context.CONTEXT_INCLUDE_CODE);
    }

    ComponentName component = r.intent.getComponent();
    if (component == null) {
        component = r.intent.resolveActivity(mInitialApplication.getPackageManager());
        r.intent.setComponent(component);      //设置Component
    }
    if (r.activityInfo.targetActivity != null) {
        component = new ComponentName(r.activityInfo.packageName,
        r.activityInfo.targetActivity);
    }

    Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);    // 根据Activity的类名，通过Java反射机制创建对应的Activity.
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    } catch (Exception e) {
        ......
    }

    try {
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        if (activity != null) {
            Context appContext = createBaseContextForActivity(r, activity);      // Activity中getContext()函数返回的就是这个对象。
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            ......
            // 将Context，ActivityThread，Instrumentation，Application等设置给新建的Activity，供activity使用。
            activity.attach(appContext, this, getInstrumentation(), r.token,
                            r.ident, app, r.intent, r.activityInfo, title, r.parent,
                            r.embeddedID, r.lastNonConfigurationInstances, config);

            if (customIntent != null) {
                 activity.mIntent = customIntent;
            }
            r.lastNonConfigurationInstances = null;
            activity.mStartedActivity = false;
            int theme = r.activityInfo.getThemeResource();
            if (theme != 0) {
                activity.setTheme(theme);                                             // 设置theme
            }

            activity.mCalled = false;
            mInstrumentation.callActivityOnCreate(activity, r.state);                  // 这个函数会使Activity的onCreate()函数被调用
            if (!activity.mCalled) {
                throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
            }
            r.activity = activity;
            r.stopped = true;
            if (!r.activity.mFinished) {
                activity.performStart();                                            // 这个函数会使Activity的onStart()函数被调用
                r.stopped = false;
            }
            if (!r.activity.mFinished) {
                if (r.state != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                }
            }
            if (!r.activity.mFinished) {
                activity.mCalled = false;
                mInstrumentation.callActivityOnPostCreate(activity, r.state);
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                }
            }
        }
        r.paused = true;
        mActivities.put(r.token, r);
    } catch (SuperNotCalledException e) {
        ......
    } catch (Exception e) {
        ......
    }
    return activity;
}

7.下面分析下Activity.attach()函数，它创建window对象，设置window manager。

attach()@Activity.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,
                  NonConfigurationInstances lastNonConfigurationInstances,
                  Configuration config) {
    attachBaseContext(context);            // 把context赋值给父类的mBase成员

    mFragments.attachActivity(this, mContainer, null);

    mWindow = PolicyManager.makeNewWindow(this);            // 调用PolicyManager的函数创建Window对象。
    mWindow.setCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);
    if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
        mWindow.setSoftInputMode(info.softInputMode);          //设置输入法mode
    }
    if (info.uiOptions != 0) {
        mWindow.setUiOptions(info.uiOptions);
    }
    mUiThread = Thread.currentThread();
    // 赋值给Acitivity的各个成员
    mMainThread = aThread;                            //mMainThread实际上为ActivityThread。
    mInstrumentation = instr;
    mToken = token;
    mIdent = ident;
    mApplication = application;
    mIntent = intent;
    mComponent = intent.getComponent();
    mActivityInfo = info;
    mTitle = title;
    mParent = parent;
    mEmbeddedID = id;
    mLastNonConfigurationInstances = lastNonConfigurationInstances;

    // 创建WindowManager对象并设置给window，供window使用.
    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();   // 保存WindowManager对象.
    mCurrentConfig = config;
}

8. 其中一个关键的函数PolicyManager.makeNewWindow()返回的Window对象，实际上是一个PhoneWindow对象。

具体创建过程参考下面代码：

class PolicyManager@PolicyManager.java

public final class PolicyManager {
    private static final String POLICY_IMPL_CLASS_NAME =
        "com.android.internal.policy.impl.Policy";

    private static final IPolicy sPolicy;      // sPolicy为单例的IPolicy对象。
    static {
        // Pull in the actual implementation of the policy at run-time
        try {
            Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);
            sPolicy = (IPolicy)policyClass.newInstance();   // 创建Policy对象。
        } catch (ClassNotFoundException ex) {
            ......
        }
    }
    // Cannot instantiate this class
    private PolicyManager() {}

    // The static methods to spawn new policy-specific objects
    public static Window makeNewWindow(Context context) {
        return sPolicy.makeNewWindow(context);    //通过Policy对象的makeNewWindow创建一个Window。
    }
    ......
}

class Policy@Policy.java

public class Policy implements IPolicy {
    private static final String TAG = "PhonePolicy";

    private static final String[] preload_classes = {
        "com.android.internal.policy.impl.PhoneLayoutInflater",
        "com.android.internal.policy.impl.PhoneWindow",
        "com.android.internal.policy.impl.PhoneWindow$1",
        "com.android.internal.policy.impl.PhoneWindow$DialogMenuCallback",
        "com.android.internal.policy.impl.PhoneWindow$DecorView",
        "com.android.internal.policy.impl.PhoneWindow$PanelFeatureState",
        "com.android.internal.policy.impl.PhoneWindow$PanelFeatureState$SavedState",
    };

    static {
        // For performance reasons, preload some policy specific classes when
        // the policy gets loaded.
        for (String s : preload_classes) {        // 加载所有的类
            try {
                Class.forName(s);
            } catch (ClassNotFoundException ex) {
                ......
            }
        }
    }
    public Window makeNewWindow(Context context) {
        return new PhoneWindow(context);                // 实际返回的PhoneWindow对象。
    }
    ......
}

9. setWindowManager()@Window.java

public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
            boolean hardwareAccelerated) {
    mAppToken = appToken;
    mAppName = appName;
    mHardwareAccelerated = hardwareAccelerated || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
    if (wm == null) {
        wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
    }
    mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);             // 创建一个WindowManagerImpl对象
}

到这里可以看到，Activity成员变量mWindow实际上是PhoneWindow类型， 变量mWindowManager实际上是WindowManagerImpl。这

10. Acitivity.attach()函数被调用之后，performLaunchActivity还会触发Activity.onCreate()函数被调用，在这个函数中会调用setContentView()函数设置Activity的UI内容。

setContentView()有三种实现，它们的功能基本一致，都是将view添加到mContentParent中：

setContentView()@Activity.java

// 通过一个布局资源设置activity的内容。
public void setContentView(int layoutResID) {
    getWindow().setContentView(layoutResID);
    initActionBar();
}

// 直接将View作为内容直接设置到activity的视图层次中。这种方式设置给view的layoutparams将不起作用，默认为MATCH_PARENT.
public void setContentView(View view) {
    getWindow().setContentView(view);
    initActionBar();
}

// 设置activity的内容为view, 并设置view的LayoutParams.
public void setContentView(View view, ViewGroup.LayoutParams params) {
    getWindow().setContentView(view, params);
    initActionBar();
}

下面给出其中一种实现：

setContentView()@PhoneWindow.java

public void setContentView(View view, ViewGroup.LayoutParams params) {
    if (mContentParent == null) {
        installDecor();                // 初始化DecorView和mContentParent.
    } else {
        mContentParent.removeAllViews();
    }
    mContentParent.addView(view, params);
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        cb.onContentChanged();
    }
}

installDecor()@PhoneWindow.java

private void installDecor() {
    if (mDecor == null) {
        mDecor = generateDecor();
                ......
    }
    if (mContentParent == null) {
        mContentParent = generateLayout(mDecor);
        mTitleView = (TextView)findViewById(com.android.internal.R.id.title);  // 创建标题栏
        ......
    }
}

generateDecor()@PhoneWindow.java

protected DecorView generateDecor() {
    return new DecorView(getContext(), -1);      // DecorView从FrameLayout派生,同时实现RootViewSurfaceTaker接口。
}

generateLayout()@PhoneWindow.java

protected ViewGroup generateLayout(DecorView decor) {
    ......
    // Inflate the window decor.
    int layoutResource;      // 根据情况获取相应的标题栏资源ID。
    int features = getLocalFeatures();
    if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
        if (mIsFloating) {
            ......
            layoutResource = res.resourceId;
        }
        ......
    }

    mDecor.startChanging();

    View in = mLayoutInflater.inflate(layoutResource, null);        //inflate 标题栏
    decor.addView(in, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));      // 加入标题栏

    ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);  // ID_ANDROID_CONTENT:xml布局文件中main layout的ID， 实际上是mDecorView的一部分。
    ......
    mDecor.finishChanging();
    return contentParent;
}

findViewById()@Window.java

public View findViewById(int id) {
    return getDecorView().findViewById(id);
}

通过上面的代码可以看到，在Activity.onCreate()函数里调用setContentView设置的View，实际上会作为DecorView的子view。DecorView还处理了标题栏显示等工作。

addView()@ViewGroup.java

public void addView(View child, int index, LayoutParams params) {
    // addViewInner()函数中设置LayoutParams时会调用child.requestLayout()，在这里调用，为了在这里阻塞child的request.
    requestLayout();
    invalidate(true);     //在下一篇文章中会介绍这个函数
    addViewInner(child, index, params, false);
}

11. 我们接着看handleLaunchActivity()中的handleResumeActivity()函数，

handleResumeActivity()@ActivityThread.java

final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume) {
    ......
    ActivityClientRecord r = performResumeActivity(token, clearHide);          //会调用到Activity.onResume().

    if (r != null) {
        final Activity a = r.activity;
        final int forwardBit = isForward ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

        // If the window hasn't yet been added to the window manager,
        // and this guy didn't finish itself or start another activity,
        // then go ahead and add the window.
        // 若这个activity的window没有加到window manager中，而且它没有自己finish或者启动另外一个acitivity,那就继续，添加这个window.
        boolean willBeVisible = !a.mStartedActivity;
        if (!willBeVisible) {
            try {
                willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(a.getActivityToken());
            } catch (RemoteException e) {
            }
        }
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();                 // 获得在attach()函数中创建出来的window对象。
            View decor = r.window.getDecorView();             // 获得一个View对象
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();            // 获得ViewManager对象
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (a.mVisibleFromClient) {
                a.mWindowAdded = true;
                wm.addView(decor, l);                          // 添加View对象到WindowManager中。
            }
        } else if (!willBeVisible) { // 如果window已经被添加了，但在resume时启动另外的activity,这个window将隐藏。
           r.hideForNow = true;
        }

        // Get rid of anything left hanging around.
        cleanUpPendingRemoveWindows(r);
// 如果window添加了，执行到这的时候就可见了。
        if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
            if (r.newConfig != null) {
                 performConfigurationChanged(r.activity, r.newConfig);
                 freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.newConfig));
                 r.newConfig = null;
             }
             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);      // 根据输入法显示模式调整winddow layout。
                 }
             }
             r.activity.mVisibleFromServer = true;
             mNumVisibleActivities++;
             if (r.activity.mVisibleFromClient) {
                    r.activity.makeVisible();
             }
        }

        if (!r.onlyLocalRequest) {
             r.nextIdle = mNewActivities;
             mNewActivities = r;
             Looper.myQueue().addIdleHandler(new Idler());
        }
        r.onlyLocalRequest = false;

        // Tell the activity manager we have resumed.
        if (reallyResume) {
            try {
                ActivityManagerNative.getDefault().activityResumed(token);
            } catch (RemoteException ex) {
         }
     }
   } else {
         // If an exception was thrown when trying to resume, then just end this activity.
         // 如果resume过程出现异常，就finish这个activity.
         try {
                ActivityManagerNative.getDefault().finishActivity(token, Activity.RESULT_CANCELED, null);
         } catch (RemoteException ex) {
         }
    }
}

addView()@WindowManagerGlobal.java

public void addView(View view, ViewGroup.LayoutParams params,
    Display display, Window parentWindow) {
    ......
    ViewRootImpl root;
    View panelParentView = null;

    synchronized (mLock) {
        ......
        root = new ViewRootImpl(view.getContext(), display);    // 创建ViewRootImpl对象

        view.setLayoutParams(wparams);

        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);
    }
    // do this last because it fires off messages to start doing things
    try {
        root.setView(view, wparams, panelParentView);          // setView()内调用requestLayout(). 在被加到WindowManager之前调度第一次layout,确保收到系统事件之前重新进行了布局。
    } catch (RuntimeException e) {
              ......
    }
}

ViewRootImpl及setView()涉及到了UI绘制。启动相关更多的细节在下一篇中进行分析。