Android ActivityManagerService总结(一)AMS启动

矫情吗；* 2024-03-24 13:07 60阅读 0赞

## 一. 概述 ##

ActivityManagerService是Android系统中一个特别重要的系统服务，也是我们上层APP打交道最多的系统服务之一。ActivityManagerService（以下简称AMS） 主要负责四大组件的启动、切换、调度以及应用进程的管理和调度工作。所有的APP应用都需要与AMS打交道. 符合C/S通信模式.

Client：由ActivityManager封装一部分服务接口供Client调用  
Server:由ActivityManagerService实现，提供Server端的系统服务

## 二. AMS启动过程 ##

AMS是在SystemServer进程中fork出来的， 所以先到SystemServer中查看初始化

public static void main(String[] args) {
            new SystemServer().run();
        }

继续看run方法

private void run() {
            // Start services.
            try {
                traceBeginAndSlog("StartServices");
                //在startBootstrapServices()中去启动了AMS
                startBootstrapServices();
                startCoreServices();
                startOtherServices();
                SystemServerInitThreadPool.shutdown();
            } catch (Throwable ex) {
                Slog.e("System", "******************************************");
                Slog.e("System", "************ Failure starting system services", ex);
                throw ex;
            } finally {
                traceEnd();
            }
    }

调用startBootStrapServices()方法

private void startBootstrapServices() {
    .....   
            //启动AMS
            mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                    mSystemServiceManager, atm);
    
    
                // Set up the Application instance for the system process and get started.
            //为系统进程设置应用程序实例并开始操作
            traceBeginAndSlog("SetSystemProcess");
            mActivityManagerService.setSystemProcess();
            traceEnd();
    ....
    }
    
    
     public static ActivityManagerService startService(
                    SystemServiceManager ssm, ActivityTaskManagerService atm) {
                sAtm = atm;
                return 
    //传入的是ActivityManagerService.Lifecycle.class对象
    ssm.startService(ActivityManagerService.Lifecycle.class).getService();
    }

AMS是通过SystemServiceManager.startService去启动的，参数是  
ActivityManagerService.Lifecycle.class， 首先看看startService方法

public <T extends SystemService> T startService(Class<T> serviceClass) {
        ....    
        final T service;
                try {
                    //获取AMS.Lifecycle类中 带context参数的构造方法
                    Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                    //通过构造器的newInstance方法
                   //实际上就是 new一个 AMSEx对象 而 AMSEx 是继承 AMS
                    service = constructor.newInstance(mContext);
        ....
        startService(service);
        return service;
    }

用传入进来的ActivityManagerService.Lifecycle.class作为参数, 通过反射方式创建对应的service服务. 所以创建的是Lifecycle的实例, 然后通过startService来启动服务.

那AMS的 Lifecycle的实例是什么呢? 继续看源码,发现它是AMS中的一个静态内部类,并且继承于SystemService

public static final class Lifecycle extends SystemService {
            private final ActivityManagerService mService;
            private static ActivityTaskManagerService sAtm;
    
            public Lifecycle(Context context) {
                super(context);
                mService = new ActivityManagerServiceEx(context, sAtm);
            }
    ....
    
    }

在Lifecycle的构造方法中, 通过new 一个 AMSEx对象(AMSEx是继承AMS)赋值给mService

实质上还是创建了AMS服务对象,然后通过 startService(service)方法启动AMS服务.

接着继续调用frameworks/base/services/core/java/com/android/server/SystemServiceManager.java中的

public void startService(@NonNull final SystemService service) {
            // Register it.
            mServices.add(service);
            // Start it.
            long time = SystemClock.elapsedRealtime();
            try {
                //走到这里,就执行到AMS中的onStart()方法了, 服务真正的启动起来
                service.onStart();
            } catch (RuntimeException ex) {
                throw new RuntimeException("Failed to start service " + service.getClass().getName()
                        + ": onStart threw an exception", ex);
            }
            warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
        }

在上面 new ActivityManagerServiceEx(context, sAtm)这句代码时, 先会执行AMS的构造方法

看看初始化的时候,做了什么事情

// Set up the Application instance for the system process and get started.  
traceBeginAndSlog("SetSystemProcess");  
mActivityManagerService.setSystemProcess();  
traceEnd();

再看service.onStart()方法//走到这里,就执行到AMS中的onStart()方法了, 服务真正的启动起来

private void start() {
            removeAllProcessGroups();
            mProcessCpuThread.start();
    
            mBatteryStatsService.publish();
            mAppOpsService.publish(mContext);
            Slog.d("AppOps", "AppOpsService published");
            LocalServices.addService(ActivityManagerInternal.class, new LocalService());
            mActivityTaskManager.onActivityManagerInternalAdded();
            mUgmInternal.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 {
    //等待mProcessCpuThread完成初始化后， 释放锁，初始化期间禁止访问
                mProcessCpuInitLatch.await();
            } catch (InterruptedException e) {
                Slog.wtf(TAG, "Interrupted wait during start", e);
                Thread.currentThread().interrupt();
                throw new IllegalStateException("Interrupted wait during start");
            }
        }

再回过头来看看在startBootstrapServices()方法中的

mActivityManagerService.setSystemProcess()

public void setSystemProcess() {
            try {
                ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                        DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
                ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
                ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                        DUMP_FLAG_PRIORITY_HIGH);
                ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
                ServiceManager.addService("dbinfo", new DbBinder(this));
                if (MONITOR_CPU_USAGE) {
                    ServiceManager.addService("cpuinfo", new CpuBinder(this),
                            /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
                }
                ServiceManager.addService("permission", new PermissionController(this));
                ServiceManager.addService("processinfo", new ProcessInfoService(this));
    
                ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                        "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
                mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
    
                synchronized (this) {
                    ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                            false,
                            0,
                            new HostingRecord("system"));
                    app.setPersistent(true);
                    app.pid = MY_PID;
                    app.getWindowProcessController().setPid(MY_PID);
                    app.maxAdj = ProcessList.SYSTEM_ADJ;
                    app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                    mPidsSelfLocked.put(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);
            }

看看这里面做的工作:

1. 注册服务。首先将ActivityManagerService注册到ServiceManager中，其次将几个与系统性能调试相关的服务(meminfo内存信息, cpuinfo CPU信息, permission 权限信息, processinfo进程信息等)注册到ServiceManager。

2. 查询并处理ApplicationInfo。首先调用PackageManagerService的接口，查询包名为android的应用程序的ApplicationInfo信息，对应于framework-res.apk。然后以该信息为参数调用ActivityThread上的installSystemApplicationInfo方法。

3. 创建并处理ProcessRecord。调用ActivityManagerService上的newProcessRecordLocked，创建一个ProcessRecord类型的对象，并保存该对象的信息。

## 三. 时序图 ##

总结一下AMS启动时序图

![9bafcdc39ee94af6a64022f3f60311f0.jpeg][]

[9bafcdc39ee94af6a64022f3f60311f0.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ebe973b2d953497e9cecd31ae4f123a0.png