Framework - AMS

参考文章

一、概念

Android10（API29）开始，ActivityTaskManagerService 接管 ActivityManagerService。

二、启动ATMS过程

三、启动APP & 跳转Activity过程

1. 调用 Activity 的 startActivity 方法来启动目标 Activity
2. 接着就会调用到 Instrunmentation 的 execStartActivity 方法，通过获取 ATMS 的 binder 代理对象，然后调用到 ATMS 的 startActivity 中去
3. 调用到 ATMS 中后，会执行到ActivityStarter 的 execute 方法，内部最终执行到了 executeRequest ，接着就会进行一些校验和判断权限，包括进程检查，intent检查，权限检查等，后面就会创建 ActivityRecord ，用来保存 Activity 的相关信息，
4. 然后就会根据启动模式计算 flag ，设置启动 Activity 的 Task 栈。
5. 在 ActivityTaskSupervisor 中检查要启动的 Activity 进程是否存在，存在则向客户端进程 ApplicationThread 回调启动 Activity，否则就创建进程。
6. 会调到 ActivityThread 后在 TransactionExecute 中开始执行system_server回调回来的事务，处理各种回调，切换到对应的生命周期
7. 最后又回调到 ActivityThread 的 handleLaunchActivity 来启动 Activity。在其中调用了 performLaunchActivity 方法。
8. 在 performLaunchActivity 中通过反射创建 Activity 实例，如果没有 Application 则先进行创建，然后再调用Activity 的 attach 方法进行初始化，最后回调 activity 的 onCreate 方法。

3.1 Activity → ATMS

启动一个 APP 或跳转一个 Activity 都是调用的 startActivity()，进而调用 startActivityForResult()。

3.1.1 Activity 

Activity{
    public void startActivity(Intent intent, @Nullable Bundle options) {
        startActivityForResult(intent, -1, options);
    }
    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
        //委托给Instrumentation来启动
        Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
        mMainThread.sendActivityResult(mToken, mEmbeddedID, requestCode, ar.getResultCode(), ar.getResultData());
    }
}

3.1.2 Instrumentation

Instrumentation{
    //形参who：用来启动Activity的对象
    //形参contextThread：Binder对象，具有跨进程通信的能力，传入的是mMainThread.getApplicationThread()
    //形参token：Binder对象，指向了服务端一个 ActivityRecord 对象
    //形参target：当前Activity
    public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, String target, Intent intent, int requestCode, Bundle options) {
        //获取一个Binder对象，转为AIDL所属类型（ATMS的proxy），然后调用ATMS的startActivity()进行跨进程通信
        int result = ActivityTaskManager.getService().startActivity(whoThread,
            who.getOpPackageName(), who.getAttributionTag(), intent,
            intent.resolveTypeIfNeeded(who.getContentResolver()), token, target,
            requestCode, 0, null, options);
        //判断能否启动Activity，不能启动就会抛出异常，例如activity未在manifest中声明等。
        checkStartActivityResult(result, intent);
    }
}

ActivityTaskManager{
    public static IActivityTaskManager getService() {
        return IActivityTaskManagerSingleton.get();
    }
    //一种单例模式
    private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton = new Singleton<IActivityTaskManager>() {
        @Override
        protected IActivityTaskManager create() {
            //获取ATMS的代理对象Binder
            final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
            return IActivityTaskManager.Stub.asInterface(b);
        }
    };
}

3.2 ATMS → PMS

ActivityTaskManagerService{
    public final int startActivity(IApplicationThread caller, String callingPackage, String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId());
    }
    private int startActivityAsUser(IApplicationThread caller, String callingPackage, @Nullable String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
        //获取ActivityStarter实例，去执行execute方法
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            ...
            .execute();
    }
}

ActivityStarter{
    int execute() {
        if (mRequest.activityInfo == null) {
            mRequest.resolveActivity(mSupervisor);
        }
    }
    static class Request {
        void resolveActivity(ActivityTaskSupervisor supervisor) {
            //AndroidManifest中intent标签
            resolveInfo = supervisor.resolveIntent(intent, resolvedType, userId, 0, computeResolveFilterUid(callingUid, realCallingUid, filterCallingUid));
            //转为Activity标签
            activityInfo = supervisor.resolveActivity(intent, resolveInfo, startFlags, profilerInfo);
        }
    }
}

ActivityTaskSupervisor{
    ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags, int filterCallingUid) {
        //通过ATMS获取抽象类PackageManagerInternal
        //PMS内部类PackageManagerInternalImpl实现了它（内部类持有外部类，就可以调用PMS的方法了）
        //resolveIntent()会将从PMS的mPackages中查询到的ActivityInfo赋值给ResultInfo
        mService.getPackageManagerInternalLocked().resolveIntent(intent, resolvedType, modifiedFlags, privateResolveFlags, userId, true, filterCallingUid);
    }
    //将获取的ResultInfo转为ActivityInfo
    ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, ProfilerInfo profilerInfo, int userId, int filterCallingUid) {
        final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId, 0, filterCallingUid);
        return resolveActivity(intent, rInfo, startFlags, profilerInfo);
    }
}

3.3 AMS → ApplicationThread