AMS—Activity工作过程

我们从Activity的startActivity（）开始，这个方法有很多重载方式，最终都回调了startActivityForResult（）；

startActivityForResult（）

            Instrumentation.ActivityResult ar =mInstrumentation.execStartActivity(this,
            mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);

在startActivityForResult（）中，调用了Instrumentation的execStartActivity（）；

execStartActivity（）

            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target, requestCode, 0, null, options);

            checkStartActivityResult(result, intent);

Instrumentation的execStartActivity（）做了两件事情，第一调用IActivityManager的startActivity（）,IActivityManager是一个Binder对象，为AMS在用户进程的代理，getService（）是通过封装好的Singleton单例实现的，具体代码：

    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;
                }
            };

第二调用checkStartActivityResult（），这是检查启动的Activity的结果，比如activity是否在manifest注册；

AMS.startActivity():

    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
            boolean validateIncomingUser) {
            return mStackSupervisor.startActivityMayWait(caller,-1,callingPackage,intent);
    }

在AMS中，activity的启动又转移到了StackSupervisor中，然后在StackSupervisor和ActivityStack中传递，他们的传递关系如下图：

Activity的启动在ActivityStackSupervisor和ActivityStack的传递顺序

最终传递到realStartActivityLocked();在这个方法中，通过Binder，操作ApplicationThread在AMS的代理IApplicationThread,这个Binder接口完成了大量的Activity和Service启动和停止的相关操作，在这里，我们实际调用了ApplicationThread的scheduleLaunchActivity();

在scheduleLaunchActivity()中，发出了一个Message将任务交给Handler去处理，在handleLaunchActivity中处理

handleLaunchActivity

   public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {

        //   创建Activity
        final Activity a = performLaunchActivity(r, customIntent);

        if(a!=null){
            //   执行Activity的onResume（）
            handleResumeActivity();
         }
     
    }

performLaunchActivity 开启Activity的核心方法

    /**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

        //    通过mInstrumentation创建activity实例
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            }
            
           //   尝试创建Application实例
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

                //    创建ContextImpl对象，调用activity的attach（）初始化重要数据
                ContextImpl appContext = createBaseContextForActivity(r);
                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);

          //   调用activity的onCreate（）
         mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);

    }

核心方法performLaunchActivity做了四件事情：

• 通过ClassLoader创建activity的实例
• 尝试创建Application实例，创建成功后会调用Application的onCreate（），如果已经存在则不需要创建
• 创建ContextImpl对象，是Context的具体实现，他通过Activity的attach（）和Activity建立关联，初始化一些重要的数据
• 通过mInstrumentation调用Activity的onCreate（）；