OpenHarmonyL0 AMS&BMS 应用框架技术分析

qq_52229576

8人浏览 · 2026-08-24 16:56:10

qq_52229576 · 2026-08-24 16:56:10 发布

轻智能解决方案-BMS&AMS

1. 概述

1.1 什么是 OpenHarmony 轻量系统

OpenHarmony 轻量系统（Lite System）是面向资源受限设备（如穿戴设备、摄像头等）的操作系统版本。相比标准系统，轻量系统具有以下特点：

资源占用小（内存、存储）
组件精简
支持的设备类型：Hi3516DV300、Hi3518EV300、穿戴手表等

1.2 核心概念

概念	说明
Ability	应用的最小调度单元，能完成独立功能的组件
HAP	Harmony Ability Package，应用安装包格式
Bundle	应用包，包含应用的所有资源和配置
Want	Ability 间交互的信息载体，描述启动意图
Foundation 进程	系统基础服务运行进程，AMS/BMS 都在此进程中

1.3 系统架构概览

graph TB
    subgraph APP[应用层]
        A1[JS Ability]
        A2[Native Ability]
        A3[Service Ability]
    end
    
    subgraph KIT[AbilityKit 开发框架]
        AK[AbilityKit]
    end
    
    subgraph FOUND[Foundation 进程]
        AMS[AMS 元能力管理服务]
        BMS[BMS 包管理服务]
    end
    
    A1 --> AK
    A2 --> AK
    A3 --> AK
    AK --> AMS
    AMS -->|IPC 通信| BMS
    
    AMS -.- AMS_Detail
    BMS -.- BMS_Detail
    
    AMS_Detail[生命周期管理 / 进程管理 / Ability栈管理]
    BMS_Detail[安装卸载升级 / 包信息查询 / 安全管理]

2. AMS - 元能力管理服务

2.1 AMS 是什么

AMS (Ability Management Service) 是 OpenHarmony 轻量系统的核心服务，负责：

管理应用 Ability 的生命周期
管理应用进程的创建和销毁
维护 Ability 调用栈
协调多个 Ability 之间的跳转关系

AMS 运行在 foundation 进程中，通过 sa_manager 注册为系统服务。

2.2 AMS 架构详解

flowchart TB
    subgraph KIT["AbilityKit (客户端)"]
        direction TB
        AB["Ability 基类<br/>生命周期回调"]
        AS["AbilitySlice<br/>页面切片"]
        AC["AbilityContext<br/>上下文管理"]
        AL["AbilityLoader<br/>模块注册加载"]
        AM["AbilityManager<br/>IPC 通信"]
        EH["EventHandler<br/>线程间通信"]
        
        AB --- AS
        AB --- AC
        AB --- AL
        AB --- AM
        AB --- EH
    end
    
    subgraph SVC["Ability Manager Service (服务端)"]
        direction TB
        S1["服务启动模块<br/>AMS 启动注册"]
        S2["接口管理模块<br/>对外能力管理"]
        S3["进程管理模块<br/>进程启动销毁"]
        S4["Ability 栈管理<br/>跳转关系维护"]
        S5["生命周期调度<br/>状态切换控制"]
        S6["连接管理模块<br/>Service 连接"]
        
        S1 --- S2
        S3 --- S4
        S5 --- S6
    end
    
    subgraph SPAWN["AppSpawn (进程创建)"]
        direction TB
        AP["应用进程创建服务<br/>高权限<br/>预加载通用模块<br/>加速应用启动"]
    end
    
    KIT -->|IPC 通信| SVC
    SVC -->|创建进程| SPAWN
    SPAWN -->|进程就绪| SVC

2.3 Ability 类型

类型	说明	用途
Page Ability	带界面的 Ability	提供人机交互界面
Service Ability	不带界面的 Ability	提供后台任务服务

2.4 Ability 生命周期

flowchart LR
    CREATED([创建]) --> UNINIT[UNINITIALIZED<br/>未初始化 临时状态]
    UNINIT --> INIT[INITIAL<br/>初始/停止状态]
    INIT -->|启动| INACT[INACTIVE<br/>可见无焦点]
    INACT -->|获取焦点| ACT[ACTIVE<br/>前台有焦点]
    ACT -->|失去焦点| INACT
    ACT -->|退到后台| BG[BACKGROUND<br/>后台状态]
    BG -->|重新激活| ACT
    BG -->|销毁| INIT

各状态说明：

状态	说明	典型场景
`UNINITIALIZED`	未初始化	临时状态，Ability 对象刚创建
`INITIAL`	初始/停止	Ability 未运行
`INACTIVE`	未激活	窗口已显示但未获得焦点
`ACTIVE`	前台激活	窗口显示且获得焦点，用户可交互
`BACKGROUND`	后台	Ability 退到后台，不可见

2.5 生命周期回调函数

开发者在 Ability 中重写以下回调函数：

class MyAbility : public Ability {
    // Ability 启动时调用（仅一次）
    virtual void OnStart(const Want &want);
    
    // 进入 INACTIVE 状态时调用
    virtual void OnInactive();
    
    // 进入 ACTIVE 状态时调用
    virtual void OnActive(const Want &want);
    
    // 进入 BACKGROUND 状态时调用
    virtual void OnBackground();
    
    // Ability 被销毁时调用
    virtual void OnStop();
    
    // Service Ability 被连接时调用
    virtual const SvcIdentity* OnConnect(const Want &want);
    
    // Service Ability 断开连接时调用
    virtual void OnDisconnect(const Want &want);
};

2.6 AMS 核心类

类名	职责	代码位置
`AbilityMgrService`	AMS 服务入口，单例模式	`services/abilitymgr_lite/`
`AbilityStackManager`	Ability 栈管理，单例模式	`services/abilitymgr_lite/`
`AbilityRecordManager`	Ability 记录管理	`services/abilitymgr_lite/`
`AppManager`	应用进程记录管理	`services/abilitymgr_lite/`
`PageAbilityRecord`	Page Ability 记录	`services/abilitymgr_lite/`
`AbilityManager`	IPC 通信客户端	`frameworks/abilitymgr_lite/`

2.7 Task 任务体系

AMS 使用任务模式处理各种操作：

task/
├── ability_start_task.cpp        # 启动 Ability
├── ability_stop_task.cpp         # 停止 Ability
├── ability_activate_task.cpp     # 激活 Ability
├── ability_inactivate_task.cpp   # 去激活 Ability
├── ability_background_task.cpp   # Ability 退到后台
├── ability_terminate_task.cpp    # 终止 Ability
├── ability_connect_task.cpp      # 连接 Service Ability
├── ability_disconnect_task.cpp   # 断开连接
├── ability_dump_task.cpp         # Dump 信息
├── app_restart_task.cpp          # 重启应用
└── app_terminate_task.cpp        # 终止应用

2.8 AMS 代码结构

foundation/ability/ability_lite/
├── frameworks/
│   ├── ability_lite/          # AbilityKit 核心实现
│   ├── abilitymgr_lite/       # AMS 通信客户端
│   └── want_lite/             # Want 实现
├── interfaces/
│   ├── kits/
│   │   ├── ability_lite/      # 开发者接口 (Ability.h 等)
│   │   └── want_lite/         # Want 对外接口
│   └── inner_api/
│       └── abilitymgr_lite/   # 内部接口 (供其他子系统调用)
└── services/
    └── abilitymgr_lite/       # AMS 服务实现
        ├── include/
        │   ├── ability_mgr_service.h
        │   ├── ability_stack_manager.h
        │   └── task/          # 各种任务定义
        └── src/
            ├── ability_mgr_service.cpp
            ├── ability_stack_manager.cpp
            └── task/          # 任务实现

3. BMS - 包管理服务

3.1 BMS 是什么

BMS (Bundle Management Service) 负责应用安装包的管理，提供以下功能：

应用的安装、卸载、升级
应用包信息的查询
应用状态变化的监听
包安全管理（签名验证、权限管理）

BMS 同样运行在 foundation 进程中，通过 sa_manager 注册。

3.2 BMS 架构详解

flowchart TB
    subgraph BK["BundleKit (对外接口)"]
        direction TB
        I1["Install<br/>安装应用"]
        I2["Uninstall<br/>卸载应用"]
        I3["GetBundleInfo<br/>获取包信息"]
        I4["QueryAbilityInfo<br/>查询 Ability 信息"]
        I5["RegisterCallback<br/>状态变化监听"]
        
        I1 --- I2
        I3 --- I4
        I5 --- I1
    end
    
    subgraph SVC["Bundle Manager Service (服务端)"]
        direction TB
        
        subgraph SCAN["包扫描子模块"]
            SC1["解析本地预制包"]
            SC2["提取包信息"]
            SC1 --- SC2
        end
        
        subgraph INST["包安装子模块"]
            IN1["安装 HAP"]
            IN2["卸载 HAP"]
            IN3["升级 HAP"]
            IN1 --- IN2 --- IN3
        end
        
        subgraph MGR["包管理子模块"]
            MG1["管理包信息"]
            MG2["持久化存储"]
            MG3["UID 分配回收"]
            MG1 --- MG2 --- MG3
        end
        
        SCAN --- INST
        INST --- MGR
    end
    
    subgraph DAEMON["包安装服务 (独立进程)"]
        direction TB
        D1["创建安装目录"]
        D2["删除安装目录"]
        D3["高权限操作"]
        D1 --- D2 --- D3
    end
    
    subgraph SEC["包安全管理子模块"]
        direction TB
        SE1["签名验证"]
        SE2["权限授予"]
        SE3["权限管理"]
        SE1 --- SE2 --- SE3
    end
    
    BK --> SVC
    INST --> DAEMON
    INST --> SEC

3.3 BMS 核心 API

3.3.1 安装/卸载

// 安装应用
bool Install(
    const char *hapPath,           // HAP 包路径
    const InstallParam *installParam,  // 安装参数
    InstallerCallback callback     // 安装结果回调
);

// 卸载应用
bool Uninstall(
    const char *bundleName,        // 包名
    const InstallParam *installParam,  // 卸载参数
    InstallerCallback callback     // 卸载结果回调
);

3.3.2 信息查询

// 查询 Ability 信息
uint8_t QueryAbilityInfo(const Want *want, AbilityInfo *abilityInfo);

// 批量查询 Ability 信息
uint8_t QueryAbilityInfos(const Want *want, AbilityInfo **abilityInfo, int32_t *len);

// 获取 Bundle 信息
uint8_t GetBundleInfo(
    const char *bundleName,   // 包名
    int32_t flags,            // 是否包含 AbilityInfo (1=包含, 0=不包含)
    BundleInfo *bundleInfo    // 输出参数
);

// 获取所有 Bundle 信息
uint8_t GetBundleInfos(int32_t flags, BundleInfo **bundleInfos, int32_t *len);

// 根据 UID 获取包名
uint8_t GetBundleNameForUid(int32_t uid, char **bundleName);

// 获取包大小
uint32_t GetBundleSize(const char *bundleName);

3.3.3 状态监听

// 注册回调，监听安装/卸载/升级事件
int32_t RegisterCallback(BundleStatusCallback *callback);

// 取消注册
int32_t UnregisterCallback(void);

3.4 BMS 核心类

类名	职责	代码位置
`ManagerService`	BMS 核心服务，单例	`services/bundlemgr_lite/`
`BundleInstaller`	安装/卸载实现	`services/bundlemgr_lite/`
`BundleMap`	BundleInfo 映射管理	`services/bundlemgr_lite/`
`BundleParser`	解析 bundle 配置	`services/bundlemgr_lite/`
`BundleExtractor`	提取包信息	`services/bundlemgr_lite/`
`HapSignVerify`	HAP 签名验证	`services/bundlemgr_lite/`
`ZipFile`	HAP 包解压	`services/bundlemgr_lite/`

3.5 BMS 代码结构

foundation/bundlemanager/bundle_framework_lite/
├── frameworks/
│   └── bundle_lite/           # BundleKit 客户端实现
├── interfaces/
│   ├── kits/
│   │   └── bundle_lite/       # 开发者接口
│   │       ├── bundle_manager.h    # 主要 API
│   │       ├── ability_info.h      # AbilityInfo 定义
│   │       ├── bundle_info.h       # BundleInfo 定义
│   │       ├── element_name.h      # ElementName 定义
│   │       └── module_info.h       # ModuleInfo 定义
│   └── inner_api/
│       └── bundlemgr_lite/    # 内部接口
├── services/
│   └── bundlemgr_lite/        # BMS 服务实现
│       ├── include/
│       │   ├── bundle_manager_service.h
│       │   ├── bundle_installer.h
│       │   ├── bundle_map.h
│       │   ├── bundle_parser.h
│       │   └── ...
│       └── src/
│           ├── bundle_manager_service.cpp
│           ├── bundle_installer.cpp
│           └── ...
└── utils/
    └── bundle_lite/           # 工具代码

3.6 BundleInfo 和 AbilityInfo

BundleInfo 结构

struct BundleInfo {
    char bundleName[MAX_BUNDLE_NAME_LEN];  // 包名
    char versionName[MAX_VERSION_NAME_LEN]; // 版本名
    int32_t versionCode;                    // 版本号
    int32_t uid;                            // 用户 ID
    char smallIconPath[MAX_PATH_LEN];       // 小图标路径
    char bigIconPath[MAX_PATH_LEN];         // 大图标路径
    char iconPath[MAX_PATH_LEN];            // 图标路径
    // ... 更多字段
    AbilityInfo *abilityInfos;              // Ability 信息数组
    int32_t abilityInfoSize;                // Ability 数量
};

AbilityInfo 结构

struct AbilityInfo {
    char bundleName[MAX_BUNDLE_NAME_LEN];   // 所属包名
    char name[MAX_ABILITY_NAME_LEN];        // Ability 名称
    char srcPath[MAX_PATH_LEN];             // 源码路径
    char iconPath[MAX_PATH_LEN];            // 图标路径
    bool isVisible;                         // 是否可见
    int32_t type;                           // Ability 类型 (Page/Service)
    // ... 更多字段
};

4. AMS 与 BMS 的协作关系

4.1 协作架构图

graph TB
    subgraph FOUND[Foundation 进程]
        subgraph AMS_SUB[AMS]
            AMS_Client[bundlems_client]
            AMS_Stack[Ability Stack Manager]
        end
        
        subgraph BMS_SUB[BMS]
            BMS_Kit[BundleKit 接口层]
            BMS_Inner[AmsInner Interface 事件通知]
        end
    end
    
    AMS_Client -->|IPC 通信 查询包信息| BMS_Kit
    BMS_Inner -->|事件通知| AMS_Stack
    
    subgraph FLOW[交互流程]
        F1[1. AMS 收到启动请求]
        F2[2. AMS 调用 BMS 查询 AbilityInfo]
        F3[3. BMS 返回 Ability 信息]
        F4[4. AMS 根据信息创建进程 启动 Ability]
        F5[5. BMS 安装/卸载时通知 AMS 更新状态]
    end

4.2 典型交互场景

场景 1：启动一个 Ability

sequenceDiagram
    participant User as 用户
    participant AMS as AMS
    participant BMS as BMS
    
    User->>AMS: 点击应用图标
    AMS->>BMS: 1. 查询 AbilityInfo
    BMS-->>AMS: 返回 AbilityInfo (srcPath, type, etc.)
    AMS->>AMS: 2. 创建进程
    AMS->>AMS: 3. 加载 Ability
    AMS->>AMS: 4. 调度生命周期

场景 2：安装一个新应用

sequenceDiagram
    participant User as 用户
    participant BMS as BMS
    participant AMS as AMS
    
    User->>BMS: bm install -p app.hap
    BMS->>BMS: 1. 解析 HAP
    BMS->>BMS: 2. 验证签名
    BMS->>BMS: 3. 创建目录
    BMS->>BMS: 4. 保存信息
    BMS->>BMS: 5. 分配 UID
    BMS->>AMS: 通知 AMS
    AMS->>AMS: 更新应用列表

4.3 UID 分配机制

BMS 负责为每个应用分配唯一的 UID：

UID 范围	用途
0-1999	系统应用
2000-9999	第三方应用
10000+	保留

UID 在应用安装时分配，卸载时回收。

5. 开发工具使用

5.1 aa 工具 (Ability Assistant)

用于管理 Ability 的命令行工具。

# 启动 Ability
aa start -p <bundleName> -n <abilityName>

# 示例
aa start -p com.example.myapp -n MainAbility

# 停止 Ability
aa stop -p <bundleName> -n <abilityName>

工具位置： out/<product>/dev_tools/bin/aa

5.2 bm 工具 (Bundle Manager)

用于管理应用包的命令行工具。

# 安装应用
bm install -p <hap_path>

# 卸载应用
bm uninstall -n <bundleName>

# 查询指定应用的包信息
bm dump -n <bundleName>

# 查询所有应用的包信息
bm dump -l

工具位置： out/<product>/dev_tools/bin/bm

5.3 编译命令

# 进入代码根目录
cd ~/workspace/luban/openharmony

# 选择目标设备
hb set

# 全量编译
hb build -f

# 编译单个模块
hb build -T bundlems    # 编译 BMS
hb build -T abilityms   # 编译 AMS

6. 常见问题与调试技巧

6.1 常见问题

Q1: Ability 启动失败

排查步骤：

检查 bundleName 和 abilityName 是否正确
使用 bm dump -n <bundleName> 确认应用已安装
检查 Ability 的 srcPath 是否正确
查看 foundation 进程日志

Q2: 应用安装失败

排查步骤：

检查 HAP 包是否完整
检查签名是否正确（调试模式可跳过）
检查设备存储空间
查看 BMS 日志

Q3: Ability 生命周期异常

排查步骤：

确认是否正确重写了生命周期回调
检查是否有阻塞操作导致状态切换失败
使用 aa dump 查看当前 Ability 状态

6.2 调试技巧

查看日志

# 查看 foundation 进程日志（AMS/BMS 都在此进程）
hilog | grep -E "AbilityMs|BundleMs"

Dump 信息

# Dump 所有 Ability 状态
aa dump

# Dump 指定应用信息
bm dump -n com.example.myapp

6.3 关键日志标签

模块	日志标签	说明
AMS	`AbilityMs`	AMS 相关日志
BMS	`BundleMs`	BMS 相关日志
AppSpawn	`AppSpawn`	进程创建日志
IPC	`Samgr`	服务管理日志

7. AMS 关键模块代码走读

说明: 同一个仓库 abilitymgr_lite/src/ 下共存两套实现：

根目录代码 = L1 版本（Linux 内核），使用 AbilityMgrHandler + AbilityWorker + Task 模式

slite 目录代码 = L0 版本（LiteOS-M 内核），使用 AbilityRecordManager + AbilityThread 模式

本章走读的是 L0 版本，命名空间为 OHOS::AbilitySlite。

7.1 AMS 服务注册与启动

文件: services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp

AMS 通过 SYSEX_SERVICE_INIT 和 SYSEX_FEATURE_INIT 两个宏分别注册 Service 和 Feature：

static void InitService()
{
    SamgrLite *sm = SAMGR_GetInstance();
    sm->RegisterService(AbilityMgrServiceSlite::GetInstance());
}
SYSEX_SERVICE_INIT(InitService);

static void InitFeature()
{
    SamgrLite *samgrLite = SAMGR_GetInstance();
    samgrLite->RegisterFeature(AMS_SERVICE, AbilityMgrServiceSlite::GetInstance());
    g_amsSliteImpl.ams = AbilityMgrServiceSlite::GetInstance();
    auto publicApi = GET_IUNKNOWN(g_amsSliteImpl);
    samgrLite->RegisterFeatureApi(AMS_SERVICE, AMS_SLITE_FEATURE, publicApi);
}
SYSEX_FEATURE_INIT(InitFeature);

构造函数 - 同时绑定 Service 和 Feature 回调：

AbilityMgrServiceSlite::AbilityMgrServiceSlite() : Service(), Feature()
{
    this->Feature::GetName = AbilityMgrServiceSlite::GetFeatureName;
    this->Feature::OnInitialize = AbilityMgrServiceSlite::OnFeatureInitialize;
    this->Feature::OnStop = AbilityMgrServiceSlite::OnFeatureStop;
    this->Feature::OnMessage = AbilityMgrServiceSlite::OnFeatureMessage;
    this->Service::GetName = AbilityMgrServiceSlite::GetServiceName;
    this->Service::Initialize = AbilityMgrServiceSlite::ServiceInitialize;
    this->Service::MessageHandle = AbilityMgrServiceSlite::ServiceMessageHandle;
    this->Service::GetTaskConfig = AbilityMgrServiceSlite::GetServiceTaskConfig;
}

Feature 初始化时自动启动 Launcher：

void AbilityMgrServiceSlite::OnFeatureInitialize(Feature *feature, Service *parent, Identity identity)
{
    auto *abilityMgrService = static_cast<AbilityMgrServiceSlite *>(feature);
    abilityMgrService->featureIdentity_ = identity;
    AbilityRecordManager::GetInstance().StartLauncher();  // 自动启动 Launcher
}

7.2 AMS 消息分发机制

文件: services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp

AMS 通过 ServiceMessageHandle 处理消息：

BOOL AbilityMgrServiceSlite::ServiceMessageHandle(Service *service, Request *request)
{
    if (request->msgId == START_ABILITY) {
        auto *data = static_cast<StartAbilityData *>(request->data);
        AbilityRecordManager::GetInstance().curTask_ = data->curTask;
        ret = AbilityRecordManager::GetInstance().StartAbility(data->want);
    } else if (request->msgId == TERMINATE_ABILITY) {
        ret = AbilityRecordManager::GetInstance().TerminateAbility(request->msgValue);
    } else if (request->msgId == TERMINATE_APP) {
        ret = AbilityRecordManager::GetInstance().ForceStopBundle(request->msgValue);
    } else if (request->msgId == TERMINATE_ALL) {
        char *excludedBundleName = reinterpret_cast<char *>(request->data);
        ret = AbilityRecordManager::GetInstance().TerminateAll(excludedBundleName);
    } else if (request->msgId == ABILITY_TRANSACTION_DONE) {
        uint32_t token = request->msgValue & TRANSACTION_MSG_TOKEN_MASK;
        uint32_t state = (request->msgValue >> TRANSACTION_MSG_STATE_OFFSET) & TRANSACTION_MSG_STATE_MASK;
        return AbilityRecordManager::GetInstance().SchedulerLifecycleDone(token, state) == ERR_OK;
    }
    // ...
}

消息 ID	说明
`START_ABILITY`	启动 Ability
`TERMINATE_ABILITY`	终止 Ability
`TERMINATE_APP`	强制停止应用
`TERMINATE_ALL`	终止所有应用（可排除指定应用）
`ABILITY_TRANSACTION_DONE`	生命周期回调完成

7.3 AbilityRecordManager 核心管理器

文件: services/abilitymgr_lite/src/slite/ability_record_manager.cpp

AbilityRecordManager 是 L0 AMS 的核心，负责 Ability 的全生命周期管理：

// 启动 Ability 的核心流程
int32_t AbilityRecordManager::StartAbility(const Want *want)
{
    if (isAppScheduling_) {
        return AddAbilityOperation(START_ABILITY, want, 0);  // 排队等待
    }
    isAppScheduling_ = true;

    // Step 1: 通过 BMSHelper 查询 Ability 信息
    auto *info = static_cast<AbilitySvcInfo *>(AdapterMalloc(sizeof(AbilitySvcInfo)));
    uint8_t queryRet = BMSHelper::GetInstance().QueryAbilitySvcInfo(want, info);

    // Step 2: 启动 Ability
    auto ret = StartAbility(info);
    BMSHelper::GetInstance().ClearAbilitySvcInfo(info);
    return ret;
}

启动 Ability 详细流程：

int32_t AbilityRecordManager::StartAbility(AbilitySvcInfo *info)
{
    auto topRecord = abilityList_.GetTopAbility();

    // 情况1: 启动的是 Launcher
    if (IsLauncher(info->bundleName)) {
        if (topToken != LAUNCHER_TOKEN && topRecord->state != SCHEDULE_BACKGROUND) {
            ScheduleLifecycleInner(topRecord, SLITE_STATE_BACKGROUND);  // 当前应用退到后台
        } else {
            SchedulerLifecycle(LAUNCHER_TOKEN, SLITE_STATE_FOREGROUND);  // Launcher 回前台
        }
        return ERR_OK;
    }

    // 情况2: 当前栈顶有 JS 应用，先终止它
    if (topRecord->state != SCHEDULE_STOP && topRecord->token != LAUNCHER_TOKEN) {
        if (strcmp(info->bundleName, topRecord->appName) == 0) {
            // 启动的是同一个应用，恢复前台
            SchedulerLifecycle(LAUNCHER_TOKEN, SLITE_STATE_BACKGROUND);
            return ERR_OK;
        } else {
            TerminateAbility(topRecord->token);  // 终止当前应用
            pendingToken_ = GenerateToken();
        }
    }

    // 情况3: 创建新应用任务
    return PreCheckStartAbility(*info);
}

7.4 创建应用任务

int32_t AbilityRecordManager::CreateAppTask(AbilityRecord *record)
{
    // 根据应用类型创建不同的 AbilityThread
    if (record->isNativeApp) {
        record->abilityThread =
            AbilityThreadLoader::GetInstance().CreateAbilityThread(NATIVE_CREATOR);
    } else {
        record->abilityThread =
            AbilityThreadLoader::GetInstance().CreateAbilityThread(JS_CREATOR);
    }

    // 初始化 Ability 线程
    record->abilityThread->InitAbilityThread(record);
    record->taskId = record->abilityThread->GetAppTaskId();

    // 调度生命周期：INITIAL -> FOREGROUND
    SchedulerLifecycle(record->token, SLITE_STATE_INITIAL);
    return ERR_OK;
}

7.5 AbilityThread 线程模型

文件: services/abilitymgr_lite/src/slite/js_ability_thread.cpp 和 native_ability_thread.cpp

L0 为每个应用创建独立的 LiteOS-M 任务（线程），通过消息队列通信：

int32_t JsAbilityThread::InitAbilityThread(const AbilityRecord *abilityRecord)
{
    // 创建消息队列
    messageQueueId_ = osMessageQueueNew(QUEUE_LENGTH, sizeof(SliteAbilityInnerMsg), nullptr);

    // 创建 LiteOS-M 任务
    TSK_INIT_PARAM_S stTskInitParam = { nullptr };
    stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)(JsAbilityThread::AppTaskHandler);
    stTskInitParam.uwStackSize = TASK_STACK_SIZE;
    stTskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST - APP_TASK_PRI;
    stTskInitParam.uwArg = reinterpret_cast<uintptr_t>(messageQueueId_);
    LOS_TaskCreate(&appTaskId_, &stTskInitParam);

    // 创建 JS Ability 实例
    ability_ = SliteAbilityLoader::GetInstance().CreateAbility(JS_ABILITY, abilityRecord->appName);
    return ERR_OK;
}

// 任务主循环：从消息队列取消息并处理
void JsAbilityThread::AppTaskHandler(UINT32 uwArg)
{
    auto messageQueueId = reinterpret_cast<osMessageQueueId_t>(uwArg);
    for (;;) {
        SliteAbilityInnerMsg innerMsg;
        osMessageQueueGet(messageQueueId, &innerMsg, &prio, osWaitForever);

        switch (innerMsg.msgId) {
            case CREATE:     abilityThread->HandleCreate(innerMsg.want); break;
            case FOREGROUND: abilityThread->HandleForeground(innerMsg.want); break;
            case BACKGROUND: abilityThread->HandleBackground(); break;
            case DESTROY:    abilityThread->HandleDestroy(); return;
        }
    }
}

7.6 生命周期调度

int32_t AbilityRecordManager::SchedulerLifecycleDone(uint64_t token, int32_t state)
{
    switch (state) {
        case SLITE_STATE_INITIAL:       // onCreate 完成
            OnCreateDone(token);         // -> 调度 FOREGROUND
            break;
        case SLITE_STATE_FOREGROUND:    // onForeground 完成
            OnForegroundDone(token);
            isAppScheduling_ = false;
            RunOperation();              // 处理排队的操作
            break;
        case SLITE_STATE_BACKGROUND:    // onBackground 完成
            OnBackgroundDone(token);
            break;
        case SLITE_STATE_UNINITIALIZED: // onDestroy 完成
            OnDestroyDone(token);
            break;
    }
    return ERR_OK;
}

L0 生命周期状态：

状态	对应回调	说明
`SCHEDULE_STOP`	-	未启动
`SCHEDULE_INITED`	`OnCreate` 完成	初始化完成
`SCHEDULE_FOREGROUND`	`OnForeground`	前台运行
`SCHEDULE_BACKGROUND`	`OnBackground`	后台运行

7.7 BMSHelper - AMS 与 BMS 的桥梁

文件: services/abilitymgr_lite/src/slite/bms_helper.cpp

AMS 通过 BMSHelper 查询 BMS 获取应用信息：

uint8_t BMSHelper::QueryAbilitySvcInfo(const Want *want, AbilitySvcInfo *svcInfo)
{
    // 先检查是否是 Native 应用
    if (IsNativeApp(want->element->bundleName)) {
        svcInfo->bundleName = Utils::Strdup(want->element->bundleName);
        svcInfo->isNativeApp = true;
        return ERR_OK;
    }

    // 通过 BMS IPC 接口查询 AbilityInfo
    AbilityInfo abilityInfo = { nullptr, nullptr };
    QueryAbilityInfo(want, &abilityInfo);

    svcInfo->bundleName = Utils::Strdup(abilityInfo.bundleName);
    svcInfo->path = Utils::Strdup(abilityInfo.srcPath);
    svcInfo->isNativeApp = false;
    return ERR_OK;
}

8. BMS 关键模块代码走读

说明: 同一个仓库 bundlemgr_lite/src/ 下共存两套实现：

根目录代码 = L1 版本（Linux 内核），使用 BundleMsHost + BundleMsFeature + ManagerService

gt_ 前缀代码 = L0 版本（LiteOS-M 内核），使用 BundleMgrService + BundleMgrSliteFeature + GtManagerService

本章走读的是 L0 版本。

8.1 BMS 服务注册与启动

文件: services/bundlemgr_lite/src/bundle_mgr_service.cpp

static void Init()
{
    SamgrLite *sm = SAMGR_GetInstance();
#ifdef __LITEOS_M__
    sm->RegisterService(BundleMgrService::GetInstance());
    BundleMgrSliteFeature::Init();  // L0 注册 Feature
#else
    sm->RegisterService(BundleMgrService::GetInstance());
#endif
}
SYSEX_SERVICE_INIT(Init);

ServiceInitialize 时发送扫描消息：

BOOL BundleMgrService::ServiceInitialize(Service *service, Identity identity)
{
    auto *bundleManagerService = static_cast<BundleMgrService *>(service);
    bundleManagerService->identity_ = identity;
    Request request = {
#ifdef __LITEOS_M__
        .msgId = BMS_REGISTER_CALLBACK_MSG,  // L0: 注册回调
#else
        .msgId = BMS_SCAN_PACKAGE_MSG,       // 非 L0: 直接扫描
#endif
    };
    SAMGR_SendRequest(bundleManagerService->GetIdentity(), &request, nullptr);
    return TRUE;
}

8.2 BMS 消息处理

BOOL BundleMgrService::ServiceMessageHandle(Service *service, Request *request)
{
    if (request->msgId == BMS_INSTALL_MSG) {
        Bmsbuff *data = static_cast<Bmsbuff *>(request->data);
        GtManagerService::GetInstance().Install(data->bundleParameter, nullptr,
            data->bundleInstallerCallback);
    } else if (request->msgId == BMS_UNINSTALL_MSG) {
        Bmsbuff *data = static_cast<Bmsbuff *>(request->data);
        GtManagerService::GetInstance().Uninstall(data->bundleParameter, nullptr,
            data->bundleInstallerCallback);
    } else if (request->msgId == BMS_SCAN_PACKAGE_MSG) {
        GtManagerService::GetInstance().ScanPackages();
    }
    return TRUE;
}

8.3 BundleMgrSliteFeature - IPC 接口层

文件: services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp

所有 IPC 请求都委托给 GtManagerService 处理：

BundleMgrSliteFeatureImpl g_bmsSliteImpl = {
    DEFAULT_IUNKNOWN_ENTRY_BEGIN,
    .Install = BundleMgrSliteFeature::Install,
    .Uninstall = BundleMgrSliteFeature::Uninstall,
    .QueryAbilityInfo = BundleMgrSliteFeature::QueryAbilityInfo,
    .GetBundleInfo = BundleMgrSliteFeature::GetBundleInfo,
    .GetBundleInfos = BundleMgrSliteFeature::GetBundleInfos,
    .GetBundleSize = BundleMgrSliteFeature::GetBundleSize,
    // ...
    DEFAULT_IUNKNOWN_ENTRY_END
};

bool BundleMgrSliteFeature::Install(const char *hapPath, const InstallParam *installParam,
    InstallerCallback installerCallback)
{
    return GtManagerService::GetInstance().Install(hapPath, installParam, installerCallback);
}

uint8_t BundleMgrSliteFeature::QueryAbilityInfo(const Want *want, AbilityInfo *abilityInfo)
{
    return GtManagerService::GetInstance().QueryAbilityInfo(want, abilityInfo);
}

8.4 GtManagerService - 核心实现

文件: services/bundlemgr_lite/src/gt_bundle_manager_service.cpp

GtManagerService 是 L0 BMS 的核心实现类：

GtManagerService::GtManagerService()
{
    installer_ = new GtBundleInstaller();      // 安装器
    bundleResList_ = new List<BundleRes *>();  // 资源列表
    bundleMap_ = BundleMap::GetInstance();     // BundleInfo 映射表
    listenList_ = new List<InstallerCallback>(); // 回调监听列表
}

bool GtManagerService::Install(const char *hapPath, const InstallParam *installParam,
    InstallerCallback installerCallback)
{
    // 1. 提取安装信息（bundleName, label, icon 等）
    uint8_t ret = GtBundleExtractor::ExtractInstallMsg(path,
        &(bundleInstallMsg_->bundleName),
        &(bundleInstallMsg_->label),
        &(bundleInstallMsg_->smallIconPath),
        &(bundleInstallMsg_->bigIconPath), ...);

    // 2. 检查是否已安装（升级场景）
    BundleInfo *installedInfo = bundleMap_->Get(bundleInstallMsg_->bundleName);
    if (installedInfo != nullptr) {
        updateFlag_ = true;
        oldVersionCode_ = installedInfo->versionCode;
    }

    // 3. 通知安装开始
    ReportInstallCallback(OPERATION_DOING, 0, BMS_INSTALLATION_START, installerCallback);

    // 4. 执行安装
    ret = installer_->Install(path, installerCallback);

    // 5. 更新 BundleInfo 列表
    UpdateBundleInfoList();

    // 6. 通知安装完成
    ReportInstallCallback(ret, ..., BMS_INSTALLATION_COMPLETED, installerCallback);
    return ret == ERR_OK;
}

8.5 L0 BMS 架构总结

BundleMgrService (Service 层)
    │
    ├── ServiceMessageHandle: 处理安装/卸载/扫描消息
    │
    └── BundleMgrSliteFeature (Feature/IPC 层)
            │
            ├── Install / Uninstall
            ├── QueryAbilityInfo / GetBundleInfo
            │
            └── GtManagerService (核心实现层)
                    │
                    ├── GtBundleInstaller (安装/卸载)
                    ├── GtBundleParser (配置解析)
                    ├── GtBundleExtractor (HAP 提取)
                    ├── BundleMap (信息存储)
                    └── ListenList (回调通知)

9. AMS 与 BMS 协作代码走读

9.1 AMS 启动 Ability 时查询 BMS

sequenceDiagram
    participant AMS as AMS AbilityRecordManager
    participant Helper as BMSHelper
    participant BMS as BMS GtManagerService

    AMS->>Helper: QueryAbilitySvcInfo(want)
    Helper->>Helper: IsNativeApp(bundleName)?
    alt Native 应用
        Helper-->>AMS: isNativeApp=true
    else JS 应用
        Helper->>BMS: QueryAbilityInfo(want)
        BMS-->>Helper: AbilityInfo(srcPath, bundleName)
        Helper-->>AMS: isNativeApp=false, path=srcPath
    end
    AMS->>AMS: CreateAppTask(record)
    AMS->>AMS: AbilityThread->InitAbilityThread

9.2 L0 与 L1 的关键区别

说明: 同一个仓库 abilitymgr_lite/src/ 下共存两套实现，通过编译配置选择：

根目录代码 = L1 版本（Linux 内核）

slite 目录代码 = L0 版本（LiteOS-M 内核）

对比项	L1 版本（根目录）	L0 版本（slite 目录）
AMS 核心类	`AbilityMgrHandler` + `AbilityWorker`	`AbilityRecordManager`
进程模型	AppSpawn 创建独立进程	LiteOS-M 任务（线程）
Ability 线程	统一处理	`JsAbilityThread` / `NativeAbilityThread` 分离
通信方式	IPC (samgr)	消息队列 (osMessageQueue)
BMS 交互	`bundleMsClient_`	`BMSHelper`
BMS 核心实现	`ManagerService`	`GtManagerService`
命名空间	`OHOS`	`OHOS::AbilitySlite`
生命周期状态	5 状态 (UNINITIALIZED/INITIAL/INACTIVE/ACTIVE/BACKGROUND)	4 状态 (STOP/INITED/FOREGROUND/BACKGROUND)

附录

A. 关键代码路径速查 (L0 slite)

模块	路径
AMS Service	`services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp`
AMS 核心管理器	`services/abilitymgr_lite/src/slite/ability_record_manager.cpp`
AMS JS 线程	`services/abilitymgr_lite/src/slite/js_ability_thread.cpp`
AMS Native 线程	`services/abilitymgr_lite/src/slite/native_ability_thread.cpp`
AMS BMS 桥接	`services/abilitymgr_lite/src/slite/bms_helper.cpp`
AMS Ability 记录	`services/abilitymgr_lite/src/slite/ability_record.cpp`
BMS Service	`services/bundlemgr_lite/src/bundle_mgr_service.cpp`
BMS Feature	`services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp`
BMS 核心实现	`services/bundlemgr_lite/src/gt_bundle_manager_service.cpp`
BMS 安装器	`services/bundlemgr_lite/src/gt_bundle_installer.cpp`
BMS 解析器	`services/bundlemgr_lite/src/gt_bundle_parser.cpp`

B. 核心头文件

文件	说明
`ability_mgr_service_slite.h`	AMS 服务定义
`ability_record_manager.h`	AMS 核心管理器
`ability_record.h`	Ability 记录
`ability_thread.h`	Ability 线程基类
`bms_helper.h`	AMS 查询 BMS 的桥接
`bundle_mgr_service.h`	BMS 服务定义
`bundle_mgr_slite_feature.h`	BMS Feature 接口
`gt_bundle_manager_service.h`	BMS 核心实现
`want.h`	Want 结构定义

欢迎加入Laval社区

社区规范：仅讨论OpenHarmony相关问题。

更多推荐

OpenHarmony 地图服务（Map Kit）架构与渲染流程学习记录

地图服务是位置类应用的核心基础设施。本文详解从地图瓦片加载、坐标系转换、渲染管线到定位与路径规划的完整链路，并梳理核心数据结构与源码模块位置。 flowchart LR A[地图初始化 MapComponent] --> B[瓦片加载多级缩放金字塔] B --> C[坐标转换经纬度 ↔ 屏幕像素]

Laval社区

OpenHarmony Launcher 启动流程

Launcher 是 OpenHarmony 系统启动后用户看到的第一个应用，也是整个系统的桌面入口。本文详解从 SystemServer 触发、Launcher Ability 加载、UI 渲染到桌面就绪的完整链路，并梳理核心数据结构与源码模块位置。 flowchart LR A[SystemServer 启动] --> B[L

Laval社区

OpenHarmony Launcher 桌面动画体系详解

OpenHarmony Launcher 桌面动画体系详解桌面动画是 Launcher 用户体验的灵魂。本文详解从动画框架选型、页面切换动画、图标交互动画到性能优化的完整链路，并梳理核心数据结构与源码模块位置。 flowchart LR A[动画框架选型 ArkUI动画引擎] --> B[页面切换动画 PageView滑动] &nbs

Laval社区

所有评论(0)

查看更多评论

qq_52229576

@qq_52229576

已为社区贡献1条内容

OpenHarmonyL0 AMS&BMS 应用框架技术分析

qq_52229576

轻智能解决方案-BMS&AMS

1. 概述

1.1 什么是 OpenHarmony 轻量系统

1.2 核心概念

1.3 系统架构概览

2. AMS - 元能力管理服务

2.1 AMS 是什么

2.2 AMS 架构详解

2.3 Ability 类型

2.4 Ability 生命周期

2.5 生命周期回调函数

2.6 AMS 核心类

2.7 Task 任务体系

2.8 AMS 代码结构

3. BMS - 包管理服务

3.1 BMS 是什么

3.2 BMS 架构详解

3.3 BMS 核心 API

3.3.1 安装/卸载

3.3.2 信息查询

3.3.3 状态监听

3.4 BMS 核心类

3.5 BMS 代码结构

3.6 BundleInfo 和 AbilityInfo

BundleInfo 结构

AbilityInfo 结构

4. AMS 与 BMS 的协作关系

4.1 协作架构图

4.2 典型交互场景

场景 1：启动一个 Ability

场景 2：安装一个新应用

4.3 UID 分配机制

5. 开发工具使用

5.1 aa 工具 (Ability Assistant)

5.2 bm 工具 (Bundle Manager)

5.3 编译命令

6. 常见问题与调试技巧

6.1 常见问题

Q1: Ability 启动失败

Q2: 应用安装失败

Q3: Ability 生命周期异常

6.2 调试技巧

查看日志

Dump 信息

6.3 关键日志标签

7. AMS 关键模块代码走读

7.1 AMS 服务注册与启动

7.2 AMS 消息分发机制

7.3 AbilityRecordManager 核心管理器

7.4 创建应用任务

7.5 AbilityThread 线程模型

7.6 生命周期调度

7.7 BMSHelper - AMS 与 BMS 的桥梁

8. BMS 关键模块代码走读

8.1 BMS 服务注册与启动

8.2 BMS 消息处理

8.3 BundleMgrSliteFeature - IPC 接口层

8.4 GtManagerService - 核心实现

8.5 L0 BMS 架构总结

9. AMS 与 BMS 协作代码走读

9.1 AMS 启动 Ability 时查询 BMS

9.2 L0 与 L1 的关键区别

附录

A. 关键代码路径速查 (L0 slite)

B. 核心头文件

所有评论(0)

温馨提示：您尚未绑定手机号

qq_52229576