ActivityManager 分析

一、ActivityManagerService启动阶段
AMS是在系统启动的init2阶段，由SystemServer启动的Java服务之一。

 // Activity manager runs the show.
 //第一阶段：启动ActivityManagerService
 mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer)

...
// Set up the Application instance for the system process and get started.
//第二阶段：调用setSystemProcess方法
mActivityManagerService.setSystemProcess();

//第三阶段：嗲用installSystemProciders方法
mActivityManagerService.installSystemProviders();

...
//第四阶段：调用systemReady方法
 mActivityManagerService.systemReady(new Runnable() {
            @Override
            public void run() {
                Slog.i(TAG, "Making services ready");

                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
                Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "PhaseActivityManagerReady");
...

二、第二阶段：调用setSystemProcess方法
Activity启动第二阶段：调用setSystemProcess方法，setSystemProcess()方法的功能大体可以分成三部分
1、注册服务。首先将ActivityManagerService注册到ServiceManager，然后将几个与系统系统调试有关的服务注册到ServiceManager。这些与系统性能调试相关的服务最终会调用ActivityManagerService，将它们与ActivityManagerService一起注册到SM中，这样系统的调度和调试功能就完善了。
2、查询并处理ApplicationInfo。 首先调用ApplicationManagerService的接口，查询包名为android的应用程序的ApplicationInfo信息，
该信息来自于Android启动时APK安装扫描过程，对应framework-res.apk，然后以该信息为参数调用ActivityThread的installSystemApplicationInfo方法
3、创建并处理ProcessRecord。 调用ActivityManagerService方法上的newProcessRecordLocked，创建一个ProcessRecord类型的对象， 并保存该对象。

    public void setSystemProcess() {
        try {
            /×将AcitvityManagerService注册到ServiceManager中，this指的是ActivityManagerService的一个实例×/
            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
            ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
            //注册meminfo服务用于调试，其作用可以参考adb shell dumpsys meminfo
            ServiceManager.addService("meminfo", new MemBinder(this));
            //注册gfxinfo服务用于调试，其作用可以参考adb shell dumpsys gfxinfo
            ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
            //Android 4.1中新加入的服务，用于存储（dump）应用数据库信息
            ServiceManager.addService("dbinfo", new DbBinder(this));
            //注册cpuinfo服务用于调试，其作用可以参考adb shell dumpsys cpuinfo
            if (MONITOR_CPU_USAGE) {
                ServiceManager.addService("cpuinfo", new CpuBinder(this));
            }
            //注册permission服务，用于检查进程的权限信息
            ServiceManager.addService("permission", new PermissionController(this));
            ServiceManager.addService("processinfo", new ProcessInfoService(this));

            /// M: ANRManager mechanism @{
            ServiceManager.addService("anrmanager", mANRManager, true);
            /// @}

            //通过PackageManagerService查询报名为android的应用程序的ApplicationInfo信息
            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
            //调用ActivityThread上的方法
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

            //生成一个新的ProcessRecord类型的对象，并将该对象存入
            synchronized (this) {
                ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
                app.persistent = true;//不能被回收
                app.pid = MY_PID;//system_server的进程ID
                app.maxAdj = ProcessList.SYSTEM_ADJ;//设置最大的ADJ值
                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                synchronized (mPidsSelfLocked) {
                    mPidsSelfLocked.put(app.pid, app);
                }
                //新加入一个APP，需要更新LRU，后续分析
                updateLruProcessLocked(app, false, null);
                updateOomAdjLocked();
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException(
                    "Unable to find android system package", e);
        }
    }

2.1 查询并处理ApplicationInfo
由PackageManagerService相关知识可以知道，查询ApplicationInfo的工作最终由ackagerManagerService的getApplicationInfo方法完成。

    //传入的参数分别为：android、STOCK_PM_FLAGS和当前User ID
    public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) {
        if (!sUserManager.exists(userId)) return null;
        flags = updateFlagsForApplication(flags, userId, packageName);
        enforceCrossUserPermission(Binder.getCallingUid(), userId,
                false /* requireFullPermission */, false /* checkShell */, "get application info");
        // writer
        synchronized (mPackages) {
            //首先，从PackageManagerService.mPackages中查找包信息
            PackageParser.Package p = mPackages.get(packageName);
            if (DEBUG_PACKAGE_INFO) Log.v(
                    TAG, "getApplicationInfo " + packageName
                    + ": " + p);
            if (p != null) {
                //然后，从mSetting.mPackages查找包设置信息
                PackageSetting ps = mSettings.mPackages.get(packageName);
                if (ps == null) return null;
                // Note: isEnabledLP() does not apply here - always return info
                //由包设置信息和包信息创建应用程序信息
                return PackageParser.generateApplicationInfo(
                        p, flags, ps.readUserState(userId), userId);
            }
            if ("android".equals(packageName)||"system".equals(packageName)) {
                //由scanPackageLI开机扫描包时设置
                return mAndroidApplication;
            }
            if ((flags & MATCH_UNINSTALLED_PACKAGES) != 0) {
                return generateApplicationInfoFromSettingsLPw(packageName, flags, userId);
            }
        }
        return null;
    }

2.2 创建并初始化ProcessRecord
接下来分析ActivityManagerService.setSystemProcess的最后一步工作：创建并初始化ProcessRecord。创建ProcessRecord的工作，由ActivityManagerService的newProcessRecordLocked方法完成。

final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
            boolean isolated, int isolatedUid) {
        //参数customProcess为system
        String proc = customProcess != null ? customProcess : info.processName;
        //影响电池状态的信息
        BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
        final int userId = UserHandle.getUserId(info.uid);
        int uid = info.uid;
        if (isolated) {//参数为false
            if (isolatedUid == 0) {
                int stepsLeft = Process.LAST_ISOLATED_UID - Process.FIRST_ISOLATED_UID + 1;
                while (true) {
                    if (mNextIsolatedProcessUid < Process.FIRST_ISOLATED_UID
                            || mNextIsolatedProcessUid > Process.LAST_ISOLATED_UID) {
                        mNextIsolatedProcessUid = Process.FIRST_ISOLATED_UID;
                    }
                    uid = UserHandle.getUid(userId, mNextIsolatedProcessUid);
                    mNextIsolatedProcessUid++;
                    if (mIsolatedProcesses.indexOfKey(uid) < 0) {
                        // No process for this uid, use it.
                        break;
                    }
                    stepsLeft--;
                    if (stepsLeft <= 0) {
                        return null;
                    }
                }
            } else {
                // Special case for startIsolatedProcess (internal only), where
                // the uid of the isolated process is specified by the caller.
                uid = isolatedUid;
            }
        }
        final ProcessRecord r = new ProcessRecord(stats, info, proc, uid);
        if (!mBooted && !mBooting
                && userId == UserHandle.USER_SYSTEM
                && (info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {
            r.persistent = true;
        }
        addProcessNameLocked(r);
        return r;
    }

newProcessRecordLocked需要接收一个IApplicationThread类型的参数，该参数进而传入ProcessRecord的构造函数，用于创建ProcessRecord。