AMS源码解析——AMS的启动流程

YuLong
929 阅读7分钟

Android的知识体系搭建

一 概述

对于 Android 开发者来说，ActivityManagerService（简称 AMS）可以说的最重要的服务之一（甚至没有之一了），AMS 在我们的应用和系统中，做了大量的工作，例如应用程序的生命周期，任务栈的管理等等。

作为解析 AMS 的第一篇博客，我们将从 AMS 的启动出发，来详细探究一下它的启动过程和原理。

二 从 SystemServer 开始

之前已经说过，在 Android 中，系统服务的启动方式有两种，

  1. 通过 rc 文件配置并加载，单独运行在一个进程中（类似 SurfaceFling 服务）
  2. 在 SystemServer 服务进程中启动。

AMS 也是在 SystemServer 进程中启动的，在 SystemServer 三批启动的进程中，它是最早的那一批。

2.1 startBootstrapServices

[/frameworks/base/services/java/com/android/server/SystemServer.java]
private void startBootstrapServices() {
  // 提前准备了一个 Apk 安装器，初始化的时候会用到
  Installer installer = mSystemServiceManager.startService(Installer.class);

  // 启动 ActivityTaskManagerService 服务。[见三]
  ActivityTaskManagerService atm = mSystemServiceManager.startService(
    ActivityTaskManagerService.Lifecycle.class).getService();

  // 启动 ActivityManagerService 服务
  mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);

  // 设置 ActivityManagerService 的服务管理者
  mActivityManagerService.setSystemServiceManager(mSystemServiceManager);

  // 设置 ActivityManagerService 的 Apk 安装器
  mActivityManagerService.setInstaller(installer);

  // ActivityTaskManagerService 的全局锁
  mWindowManagerGlobalLock = atm.getGlobalLock();

  mActivityManagerService.initPowerManagement();

  // 设置系统进程，这行代码很重要，在之后的 AMS 进程管理中，我们回详细讲 
  mActivityManagerService.setSystemProcess();
}

2.2 startService

startService 是一个泛型函数，也就是所有 SystemService 的子类都可以通过它进行启动。

具体的启动步骤如下。也就是 Android 中启动服务的经典三步构造、注册、onStart。

  1. 获取服务的 ClassName
  2. 调用服务的 Context 构造函数
  3. 将服务注册到 SystemServer
  4. 调用服务的 onStart
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {

        // 获取服务的名称
        final String name = serviceClass.getName();
        ...

        final T service;
        try {
            // 第一步，构造
            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
        ...

        // 启动服务
        startService(service);
        return service;
    } finally {
        ...
    }
}

2.3 startService

public void startService(@NonNull final SystemService service) {

        // 先判断服务是否已经启动，避免重复启动
        String className = service.getClass().getName();
        if (mServiceClassnames.contains(className)) {
            Slog.i(TAG, "Not starting an already started service " + className);
            return;
        }

        mServiceClassnames.add(className);

        // 第二部，注册服务
        mServices.add(service);

        long time = SystemClock.elapsedRealtime();
        try {
            // 第三部，调用服务 onStart
            service.onStart();
        } catch (RuntimeException ex) {
            throw new RuntimeException("Failed to start service " + service.getClass().getName()
                    + ": onStart threw an exception", ex);
        }

        // 计算服务是否启动超时，这里是 50ms
        warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
    }

所以，我们接下来就从构造，注册，onStart这三块内容，来看 AMS 是如何启动的。

三 ActivityTaskManagerService

首先是 ActivityTaskManagerService（后续简称 ATMS）。

  [frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java]

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

在 startService 函数中，会调用 ATMS.Lifecycle 的 Context 的构造函数[2.2]。然后调用 ATMS.Lifecycle 的 onStart 函数[2.3]。

注意：这里传入的是ATMS的内部类Lifecycle，所以它调用的是Lifecycle的构造函数和Lifecycle的onStart函数。

3,1 ATMS.Lifecycle 的构造函数

[frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java]

public static final class Lifecycle extends SystemService {

	private final ActivityTaskManagerService mService;

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

在 Lifecycle 中，有一个 ATMS 的成员对象，并且调用了 ATMS 的构造函数。

3.2 ATMS 的构造函数

[frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java]

public ActivityTaskManagerService(Context context) {
    mContext = context;
    mFactoryTest = FactoryTest.getMode();
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();
    mLifecycleManager = new ClientLifecycleManager();
    mInternal = new LocalService();
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
}

首先是 ATMS 的构造函数。这个函数只是对一些参数做了初始化。

3.3 ATMS.Lifecycle 的 start

[frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java]

public static final class Lifecycle extends SystemService {

	private final ActivityManagerService mService;
	private static ActivityTaskManagerService sAtm;

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

在 ATMS.Lifecycle 的 onStart 中，将 ATM 这个服务发布到了 ServiceManager 中。并调用了 ATM 的 start 函数。

3.4 浅谈 ATMS.Lifecycle

我们再来看看 ATMS.Lifecycle 这个内部类，它继承了 SystemService，SystemService 是系统服务的基类，它是一个抽象类。虽然 ATMS 的名字中有一个 Service，但是它实际上并不是 Service 的子类，所以系统通过 ATMS.Lifecycle 这个内部类，来接收系统服务的生命周期的回调。

这样，通过 Lifecycle 的 onStart，就可以回调到 ATMS 的 start。

[frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java]

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

	@Override
	public void onUserUnlocked(@NonNull TargetUser user) {
		synchronized (mService.getGlobalLock()) {
			mService.mTaskSupervisor.onUserUnlocked(user.getUserIdentifier());
		}
	}

	@Override
	public void onUserStopped(@NonNull TargetUser user) {
		synchronized (mService.getGlobalLock()) {
			mService.mTaskSupervisor.mLaunchParamsPersister
					.onCleanupUser(user.getUserIdentifier());
		}
	}

	public ActivityTaskManagerService getService() {
		return mService;
	}
}

我们再回到[2.1]，来看看 ATM 这个系统服务。

四 ATM

根据上述逻辑，AMS 的启动，会调用以下几个函数

  1. AMS 的 Context 构造函数
  2. AMS 的 Lifecycle.onStart 函数

启动是由ActivityManagerService.Lifecycle.startService完成的。

4.1 AMS.Lifecycle

public static final class Lifecycle extends SystemService {

	public Lifecycle(Context context) {
            super(context);
            mService = new ActivityManagerService(context, sAtm);
	}

    public static ActivityManagerService startService(
            SystemServiceManager ssm, ActivityTaskManagerService atm) {
        sAtm = atm;
        return	ssm.startService(ActivityManagerService.Lifecycle.class).getService();
    }

	@Override
	public void onStart() {
            mService.start();
	}
}

4.2 AMS 的构造函数

// 构造函数在主线程上调用，如果需要在其他线程。 则需要对 Looper 进行明确说明。
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    mInjector = new Injector(systemContext);
    mContext = systemContext;

    mFactoryTest = FactoryTest.getMode();

    // 主线程，ActivityThread
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();

    // 前台服务的 Handle
    mHandlerThread = new ServiceThread(TAG,
            THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();

    // MainHandler
    mHandler = new MainHandler(mHandlerThread.getLooper());
    mUiHandler = mInjector.getUiHandler(this);

    // 前台服务的Thread，HandlerThread的子类
    mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
            THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
    mProcStartHandlerThread.start();
    mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());

    // ActivityManager 的常量类
    mConstants = new ActivityManagerConstants(mContext, this, mHandler);
    final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
    mPlatformCompat = (PlatformCompat) ServiceManager.getService(
            Context.PLATFORM_COMPAT_SERVICE);
    mProcessList = mInjector.getProcessList(this);
    mProcessList.init(this, activeUids, mPlatformCompat);
    mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
            new LowMemDetector(this));
    mPhantomProcessList = new PhantomProcessList(this);
    mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);

    // 广播策略的参数（前台、后台、分流）
    final BroadcastConstants foreConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_FG_CONSTANTS);
    foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;

    final BroadcastConstants backConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_BG_CONSTANTS);
    backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;

    // Android 10 新增的广播类型 offload，超时时间采用的后台广播的时间（60秒）
    final BroadcastConstants offloadConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
    offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
    // by default, no "slow" policy in this queue
    offloadConstants.SLOW_TIME = Integer.MAX_VALUE;

    mEnableOffloadQueue = SystemProperties.getBoolean(
            "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);

    // 前台广播队列
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "foreground", foreConstants, false);
    // 后台广播队列
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "background", backConstants, true);
    // 分流广播队列
    mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
            "offload", offloadConstants, true);
    // 三个广播队列数组
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;
    mBroadcastQueues[2] = mOffloadBroadcastQueue;

    mServices = new ActiveServices(this);
    mCpHelper = new ContentProviderHelper(this, true);
    mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
    mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
    mUidObserverController = new UidObserverController(mUiHandler);

    final File systemDir = SystemServiceManager.ensureSystemDir();

    // 未来电池服务将会从 AMS 移除（谷歌的饼，好多年了还在）
    mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
            BackgroundThread.get().getHandler());
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    mBatteryStatsService.getActiveStatistics().setCallback(this);
    mOomAdjProfiler.batteryPowerChanged(mOnBattery);

    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);

    mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);

    // 创建用户
    mUserController = new UserController(this);

    mPendingIntentController = new PendingIntentController(
            mHandlerThread.getLooper(), mUserController, mConstants);

    mUseFifoUiScheduling = SystemProperties.getInt("sys.use_fifo_ui", 0) != 0;

    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);

    // 将 AMS 和 ATMS 相关联，并获取 ActivityTaskManagerInternal
    mActivityTaskManager = atm;
    mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
            DisplayThread.get().getLooper());
    mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);

    mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);

    // 性能监控
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);


    updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
    try {
        Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
                Process.THREAD_GROUP_SYSTEM);
        Process.setThreadGroupAndCpuset(
                mOomAdjuster.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
                Process.THREAD_GROUP_SYSTEM);
    } catch (Exception e) {
        Slog.w(TAG, "Setting background thread cpuset failed");
    }

    mInternal = new LocalService();
    mPendingStartActivityUids = new PendingStartActivityUids(mContext);
    mTraceErrorLogger = new TraceErrorLogger();
}

AMS 的构造函数中，依旧是一些初始化相关的内容。接下来再来看看 onStart 中的 mService.start() 。

4.3 AMS.start

private void start() {
    // 移除所有进程组
    removeAllProcessGroups();

    // 电源管理的服务
    mBatteryStatsService.publish();

    // 运行时权限的服务
    mAppOpsService.publish();

    // 发布 AMS 服务到本地，用于和本进程内通信
    LocalServices.addService(ActivityManagerInternal.class, mInternal);
    LocalManagerRegistry.addManager(ActivityManagerLocal.class,
            (ActivityManagerLocal) mInternal);


    // 通知其他服务，AMS 已经发布到本地了，你们可以用了
    mActivityTaskManager.onActivityManagerInternalAdded();
    mPendingIntentController.onActivityManagerInternalAdded();
    mAppProfiler.onActivityManagerInternalAdded();
}

接下来回到[2.1]，继续看 SystemServer 中 AMS 的启动流程。

4.4 setSystemServiceManager

首先是 setSystemServiceManager，简单的设置了一个 mSystemServiceManager。

public void setSystemServiceManager(SystemServiceManager mgr) {
    mSystemServiceManager = mgr;
}

4.5 setInstaller

然后是设置 apk 按照器。

public void setInstaller(Installer installer) {
    mInstaller = installer;
}

4.6 initPowerManagement

初始化电源管理相关的服务

public void initPowerManagement() {
    mActivityTaskManager.onInitPowerManagement();
    mBatteryStatsService.initPowerManagement();
    mLocalPowerManager = LocalServices.getService(PowerManagerInternal.class);
}

到此，AMS 已经持有了 Installer 安装器，SystemServiceManager 系统服务等对象，后续可以直接调用。

4.7 setSystemProcess

public void setSystemProcess() {
    try {
        // 使用 ServiceManager 注册一些系统服务
        // activity
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
        // procstats
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        // meminfo
        ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
                DUMP_FLAG_PRIORITY_HIGH);
        // gfxinfo
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        // dbinfo
        ServiceManager.addService("dbinfo", new DbBinder(this));
        mAppProfiler.setCpuInfoService();
        // permission
        ServiceManager.addService("permission", new PermissionController(this));
        // processinfo
        ServiceManager.addService("processinfo", new ProcessInfoService(this));
        // cacheinfo
        ServiceManager.addService("cacheinfo", new CacheBinder(this));

        // 获取名为 android 的应用
        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.setPid(MY_PID);
            app.mState.setMaxAdj(ProcessList.SYSTEM_ADJ);
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            addPidLocked(app);
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }

    // 在AMS和包管理器启动并运行后，开始观察应用程序的操作（）。
    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, String attributionTag,
                boolean active, @AttributionFlags int attributionFlags,
                int attributionChainId) {
            cameraActiveChanged(uid, active);
        }
    });
}

AMS 这个服务是一个很重要的服务，它在 setSystemProcess 这个函数中，为 ServiceManager 添加了很多子服务。例如

  • meminfo：内存管理的服务，如果系统内存不够，就好调用应用的低内存回调，让我们释放内存
  • gfxinfo：图像信息的服务
  • dbinfo：数据库
  • permission：权限管理的服务
  • processinfo：进程管理的服务
  • cacheinfo：缓存管理

五 总结

在这篇文章中，我们介绍了AMS的启动流程，和AMS中包含的一些东西。

在 AMS 中会注册一系列的服务，它除了 Activity 的管理，还有进程的管理，任务栈的管理，内存的管理，权限的管理等等。

后续我们也会分别介绍这些服务和它们具体的工作原理，作为 AMS 的开篇，我们就这篇内容就简单一点，只介绍一下 AMS 的启动流程就行了，最后再用一幅图总结一下。

AMS的启动~1.png

avatar
文章
阅读
粉丝
相关推荐
安卓应用开发中的MVC、MVP、MVVM、MVI（1）
457阅读
 · 
2点赞
Android 怎么通过Intent打开第三方App
7.0k阅读
 · 
6点赞
做了五年Android,我顿悟了...
18k阅读
 · 
118点赞
Kotlin 异步 | Flow 限流的应用场景及原理
12k阅读
 · 
130点赞
LiveData 的使用误区(Tips)
4.4k阅读
 · 
8点赞