Android 11 （R）AMS Activity内部机制

最新推荐文章于 2024-11-18 21:04:02 发布

原创

最新推荐文章于 2024-11-18 21:04:02 发布 · 1.2k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#android

一、AMS是如何被管理的

如我们在Android 11(R)启动流程中介绍的一样，AMS和ATMS是在SystemServer中被启动的

ActivityTaskManagerService atm = mSystemServiceManager.startService(
                ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                mSystemServiceManager, atm);

由SystemServiceManager启动具体的服务，从代码可以看出这里启动的是ActivityTaskManagerService.Lifecycle，并没有直接启动ActivityTaskManagerService。这是因为ActivityTaskManagerService只能有一个父类，要继承IActivityTaskManager.Stub，如果想要使用SystemService统一管理atms服务，但atms又无法在继承SystemService。因此需要实现了一个内部静态内部类Lifecycle来继承SystemService并且实例化ActivityTaskManagerService。

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {.....}

public static final class Lifecycle extends SystemService {
    private final ActivityTaskManagerService mService;

    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityTaskManagerService(context);
    }

    @Override
    public void onStart() {
        publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
        mService.start();
    }

    public ActivityTaskManagerService getService() {
        return mService;
    }
}

然后通过publishBinderService将服务公布到了ServiceManager中，application就可以通过ServiceManager拿到AMS进行通信

publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);

二、AMS 的启动

在ams的start函数中，初始化了很多服务，还添加了很多服务到servicemanager中

private void start() {
    removeAllProcessGroups();
    mProcessCpuThread.start();//启动cpu监控线程

    mBatteryStatsService.publish();//注册电池状态和权限管理服务
    mAppOpsService.publish();
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, mInternal);
    mActivityTaskManager.onActivityManagerInternalAdded();
    mPendingIntentController.onActivityManagerInternalAdded();
    // Wait for the synchronized block started in mProcessCpuThread,
    // so that any other access to mProcessCpuTracker from main thread
    // will be blocked during mProcessCpuTracker initialization.
    try {
        mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Slog.wtf(TAG, "Interrupted wait during start", e);
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

//初始化电源管理服务
SystemServer.java   mActivityManagerService.initPowerManagement
//核心内容，为APP进程安排系统进程以便后期监控
SystemServer.java    mActivityManagerService.setSystemProcess();

public void setSystemProcess() {
    try {
        //添加ams服务到ServiceManager
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
        //添加ProcessStats服务到ServiceManager
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        //添加meminfo服务到ServiceManager
        ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                DUMP_FLAG_PRIORITY_HIGH);
        //添加gfxinfo服务到ServiceManager  图像信息
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        //添加dbinfo服务到ServiceManager  数据库信息
        ServiceManager.addService("dbinfo", new DbBinder(this));
        if (MONITOR_CPU_USAGE) {
            //添加cpuinfo服务到ServiceManager  cpu信息
            ServiceManager.addService("cpuinfo", new CpuBinder(this),
                    /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
        }
        //添加permission服务到ServiceManager  权限和进程信息
        ServiceManager.addService("permission", new PermissionController(this));
        //添加processinfo服务到ServiceManager  进程信息
        ServiceManager.addService("processinfo", new ProcessInfoService(this));
        //添加cacheinfo服务到ServiceManager  缓存信息
        ServiceManager.addService("cacheinfo", new CacheBinder(this));

        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

        synchronized (this) {
            //创建ProcessRecord维护进程的相关信息
            ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                    false,
                    0,
                    new HostingRecord("system"));
            app.setPersistent(true);
            app.pid = app.mPidForCompact = MY_PID;
            app.getWindowProcessController().setPid(MY_PID);
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            addPidLocked(app);
            mProcessList.updateLruProcessLocked(app, false, null);
            updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }

    // Start watching app ops after we and the package manager are up and running.
    mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
            new IAppOpsCallback.Stub() {
                @Override public void opChanged(int op, int uid, String packageName) {
                    if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
                        if (getAppOpsManager().checkOpNoThrow(op, uid, packageName)
                                != AppOpsManager.MODE_ALLOWED) {
                            runInBackgroundDisabled(uid);
                        }
                    }
                }
            });

    final int[] cameraOp = {AppOpsManager.OP_CAMERA};
    mAppOpsService.startWatchingActive(cameraOp, new IAppOpsActiveCallback.Stub() {
        @Override
        public void opActiveChanged(int op, int uid, String packageName, boolean active) {
            cameraActiveChanged(uid, active);
        }
    });
}