核心服务一：ActivityManagerService

望佑
300 阅读8分钟

一、AMS（Activity Manager Service）概述

AMS是Android框架的三大核心功能之一，主要负责系统中四大组件的启动、切换、调度及应用程序进程的管理和调度等工作。

二、AMS的主要功能

  1. 应用生命周期管理： 当打开应用或切换页面时，AMS会进行相应的处理，并通知应用的相应组件（如Activity）。 例如，当用户启动一个Activity时，AMS会创建该Activity的实例，并调用其onCreate()、onStart()和onResume()等生命周期回调方法。 应用程序重写这些方法，来响应生命周期事件。

  2. 任务栈的管理： AMS负责管理应用程序任务栈，将不同应用的Activity按照启动模式添加到任务栈中，以实现应用程序之间的切换和交互。 标准模式Standard、单顶模式SingleTop、单任务模式SingleTask、单实例模式SingleInstance

  3. 应用程序之间的交互： AMS负责应用程序之间的交互，包括使用Intent去启动Activity、发送广播和启动服务等操作。 Intent可用于APP之间、APP内部组件之间通信，可以定义操作、携带数据或指定接受者。

  4. 系统服务的调度： AMS通过监控系统资源、调整服务优先级和协调服务之间的交互，来确保系统服务的整体稳定运行

三、AMS的工作原理

  1. 进程间通信（IPC）： AMS作为系统服务，运行在系统进程中。 其他进程需要通过Binder机制来和AMS跨进程通信。 Binder是Android系统中一种高效的IPC机制，允许不同进程之间共享内存、发送和接收数据。

  2. ActivityThread和ApplicationThread： ActivityThread：应用程序的主线程，负责UI 更新、事件处理、启动 Activity 等。 ApplicationThread：用于系统服务和应用程序进程之间的通信，是在 Android 框架内部使用的 Binder 接口实现。

  3. 内存管理： 当系统内存不足时，AMS会根据优先级来终止一些进程以释放内存。

  • （1）优先保留前台进程和可见进程，可能终止服务进程、后台进程和空进程等；
  • （2）决定终止哪些进程后，判断Activity当前状态、与用户交互情况或有没有更重要Activity在运行等
  • （3）决定终止某个Activity实例，AMS通知其所在进程进行清理，包括保存Activity状态、释放资源等

四、AMS的实现细节

1. 核心数据结构

ActivityStack

  • 定义：管理Activity任务栈的类。
  • 作用：负责存储和管理一组相关的Activity实例，控制Activity的进出顺序。

ActivityRecord

  • 定义：记录和管理Activity生命周期的类。
  • 作用：保存Activity的详细信息，跟踪Activity的状态变化。

ProcessRecord

  • 定义：表示和管理应用程序进程的类。
  • 作用：记录进程的详细信息，如进程ID、内存状态等，用于进程管理和调度。

TaskRecord

  • 定义：表示和管理任务的类，任务是一组相关的Activity集合。
  • 作用：维护任务中的Activity序列，支持任务之间的切换和导航。

它们之间的关系

  • ActivityStack与TaskRecord：ActivityStack包含了一个或多个TaskRecord，每个TaskRecord代表一个任务栈中的任务。ActivityStack通过管理TaskRecord来管理整个任务栈。
  • TaskRecord与ActivityRecord：TaskRecord包含了一个或多个ActivityRecord，每个ActivityRecord代表任务中的一个Activity实例。TaskRecord通过管理ActivityRecord来维护任务中的Activity序列。
  • ActivityRecord与ProcessRecord：虽然它们不直接关联，一个ActivityRecord属于某个特定的ProcessRecord，表示该Activity运行在该进程中。AMS通过ProcessRecord来管理包含该ActivityRecord的进程。

2. 初始化与启动

  • 在Android系统启动时，SystemServer作为系统服务的入口点负责加载和启动AMS。 SystemServer首先会创建一个AMS实例并将其注册为系统服务，然后启动AMS的主线程Looper来处理AMS的各种操作。 虽然 SystemServer 的实际实现相当复杂，但我们可以简化这一过程，并给出一个伪代码示例来演示 SystemServer 如何创建并启动 AMS。
// 伪代码示例：SystemServer 启动 AMS

// 假设这是 SystemServer 类的一部分
class SystemServer {

    // 模拟的启动方法，实际中可能由 Zygote 进程分叉而来
    public static void main(String[] args) {
        // 初始化必要的系统资源和服务...

        // 创建 AMS 实例
        ActivityManagerService ams = new ActivityManagerService();

        // 将 AMS 注册为系统服务，这通常涉及到一个全局的服务注册表
        // 在实际 Android 系统中，这通常通过 ServiceManager 类完成
        ServiceManager.addService("activity", ams);

        // 启动 AMS 的主线程 Looper
        // 注意：在 Android 中，AMS 通常已经在其构造函数或初始化过程中启动了自己的 Looper
        // 这里我们假设它需要一个显式的启动方法
        ams.startLooper();

        // 更多的系统服务初始化...

        // 进入 Looper 循环，等待并处理消息
        // 注意：在 SystemServer 中，这通常是通过一个主 Looper 循环来完成的，
        // 但它不仅仅是为了 AMS，而是为了处理整个系统服务的消息
        Looper.loop();
    }

    // 假设的 ActivityManagerService 类
    static class ActivityManagerService {

        // AMS 的构造函数可能包含初始化代码
        public ActivityManagerService() {
            // 初始化代码...

            // 启动 Looper（在实际实现中，这可能在构造函数之外完成）
            // 但为了示例，我们在这里调用它
            startLooper();
        }

        // 启动 Looper 的方法
        // 注意：在实际代码中，AMS 可能会使用 HandlerThread 或直接在主线程上启动 Looper
        private void startLooper() {
            Looper.prepare(); // 准备 Looper

            // 假设有一个 Handler 用于处理消息
            Handler handler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    // 处理消息...
                }
            };

            // 在这个伪代码中，我们不会实际进入 Looper 循环，
            // 因为 SystemServer 通常会处理多个服务并维护一个全局的 Looper
            // 但为了完整性，我们知道 Looper.loop() 会被调用在某个地方
            // Looper.loop(); // 在实际中，这可能不是在这里调用的
        }

        // AMS 的其他方法和功能...
    }

    // 模拟的 ServiceManager 类，用于注册和获取系统服务
    static class ServiceManager {

        // 模拟的服务注册表
        private static final Map<String, IBinder> services = new HashMap<>();

        // 添加服务到注册表
        public static void addService(String name, IBinder service) {
            services.put(name, service);
        }

        // 获取服务（这里只是简单返回，实际中会有 IPC 调用）
        public static IBinder getService(String name) {
            return services.get(name);
        }
    }
}

// 注意：IBinder 是一个接口，用于 IPC 通信，AMS 会实现这个接口来提供远程服务
// 在这个伪代码中，我们没有详细展示 IBinder 的实现，因为它会涉及到 Binder 框架的复杂性

请记住，这个示例是为了教学目的而简化的。在 Android 的实际实现中，SystemServer、ActivityManagerService 和 ServiceManager 都远比这里展示的复杂。特别是，ActivityManagerService 的初始化会涉及到许多系统资源和服务的交互，而 SystemServer 会负责启动和管理多个关键系统服务，而不仅仅是 AMS。此外，IPC 机制（如 Binder）在 Android 中用于不同进程之间的通信，这在上述伪代码中并未详细展开。

五、伪代码

为了更全面地展示ActivityStack、TaskRecord、ActivityRecord以及它们与ProcessRecord（尽管ProcessRecord不直接在此示例中管理，但我会提及其概念）之间的关系，我们可以编写一个简化的Java伪代码示例。请注意，由于ProcessRecord的详细管理通常不在ActivityStack或TaskRecord的直接职责范围内，我们将主要关注前三个类的关系。

// ActivityRecord 类，代表任务中的一个Activity实例
class ActivityRecord {
    private String activityName; // Activity的名称
    // 这里可以添加更多属性，如intent、state等

    public ActivityRecord(String activityName) {
        this.activityName = activityName;
    }

    // 获取Activity名称
    public String getActivityName() {
        return activityName;
    }

    // 其他ActivityRecord相关的方法...
}

// TaskRecord 类，代表一个任务栈中的任务
class TaskRecord {
    private String taskId; // 任务的唯一标识符
    private List<ActivityRecord> activities; // 任务中的Activity列表

    public TaskRecord(String taskId) {
        this.taskId = taskId;
        this.activities = new ArrayList<>();
    }

    // 添加Activity到任务
    public void addActivity(ActivityRecord activityRecord) {
        activities.add(activityRecord);
    }

    // 获取任务中的所有Activity
    public List<ActivityRecord> getActivities() {
        return activities;
    }

    // 其他TaskRecord相关的方法...
}

// ActivityStack 类，管理一个或多个TaskRecord
class ActivityStack {
    private List<TaskRecord> tasks;

    public ActivityStack() {
        this.tasks = new ArrayList<>();
    }

    // 创建一个新任务并添加到栈中
    public TaskRecord createTask(String taskId) {
        TaskRecord task = new TaskRecord(taskId);
        tasks.add(task);
        return task;
    }

    // 获取所有任务
    public List<TaskRecord> getTasks() {
        return tasks;
    }

    // 根据任务ID获取任务
    public TaskRecord getTaskById(String taskId) {
        for (TaskRecord task : tasks) {
            if (task.taskId.equals(taskId)) {
                return task;
            }
        }
        return null;
    }

    // 其他管理任务栈的方法...
}

// 注意：ProcessRecord 通常不在这个上下文中直接管理，但我们可以假设它的存在
// class ProcessRecord {
//     // ... 表示一个进程，包含多个ActivityRecord（但通常不是直接管理）
// }

// 示例用法
public class Main {
    public static void main(String[] args) {
        ActivityStack stack = new ActivityStack();

        // 创建一个新任务
        TaskRecord task1 = stack.createTask("task1");
        task1.addActivity(new ActivityRecord("MainActivity"));
        task1.addActivity(new ActivityRecord("DetailActivity"));

        // 创建另一个新任务
        TaskRecord task2 = stack.createTask("task2");
        task2.addActivity(new ActivityRecord("LoginActivity"));

        // 假设ProcessRecord的管理是AMS的职责，这里不直接展示

        // 打印所有任务及其Activity
        for (TaskRecord task : stack.getTasks()) {
            System.out.println("Task ID: " + task.taskId);
            for (ActivityRecord activity : task.getActivities()) {
                System.out.println("  Activity: " + activity.getActivityName());
            }
        }
    }
}

在这个示例中，ActivityRecord 类代表了一个Activity实例，TaskRecord 类管理了一个或多个ActivityRecord，而ActivityStack 类则管理了一个或多个TaskRecord。我们假设了ProcessRecord的存在，但在这个上下文中没有直接展示其管理逻辑，因为ProcessRecord通常是由更高级别的系统服务（如Activity Manager Service, AMS）来管理的，它负责进程的创建、销毁以及Activity在进程中的调度等。

请注意，这个示例是高度简化的，并且没有包含Android系统中实际存在的许多复杂性和细节。

avatar
文章
阅读
粉丝