04-05-01 深入Android内核设计思想 第1章：Android系统概述（更新至 Android 16 / API 36）

核心知识点速查

1. Android系统架构（五层，含 GKI 分离）

┌──────────────────────────────────────────────┐
│   应用层 (Applications)                       │
│   - 系统应用 + 第三方应用 (APK/APEX)          │
├──────────────────────────────────────────────┤
│   应用框架层 (Java API Framework)              │
│   - ActivityManager, WindowManager,          │
│     PermissionController, AppOps 等           │
├──────────────────────────────────────────────┤
│   Native层 + AIDL HAL层                       │
│   - Native Libraries (C/C++/Rust)            │
│   - Android Runtime (ART)  [APEX: com.android.art] │
│   - AIDL HAL (进程隔离, binderized)           │
│   - Legacy HIDL HAL (兼容层, 逐步淘汰)         │
├──────────────────────────────────────────────┤
│   GKI 通用内核层 (Generic Kernel Image)        │
│   - common kernel (Google 维护, GKI 认证)      │
│   - KMI 版本化接口 (Kernel Module Interface)    │
│   - 供应商内核模块 (.ko, out-of-tree)         │
├──────────────────────────────────────────────┤
│   Linux内核层 + 硬件驱动                       │
│   - 内核内置驱动 (GKI common 部分)            │
│   - 供应商专属驱动 (out-of-tree modules)       │
│   - 进程/内存/电源管理, EROFS 只读文件系统      │
└──────────────────────────────────────────────┘

2. HAL层的关键作用

• 位置：位于 Framework/Native Service 与 Linux 内核之间
• 目的：
  • 隔离内核驱动与上层框架，保证内核通用性
  • 保护硬件厂商的知识产权（避免 GPL 协议传染）
  • 统一硬件接口，简化跨设备移植
• 实现方式：
  • Android 8-10：传统 HAL (.so 动态库，直接加载)
  • Android 10-15：HIDL HAL (进程隔离，binderized)
  • Android 11-16：AIDL HAL（主流推荐，编译时类型检查）
• 部署方式：独立进程通过 Binder/AIDL 通信，或 passthrough 模式

3. Android与标准Linux的差异

特性	标准Linux	Android
IPC	Socket / D-Bus	Binder (内核级, 零拷贝)
电源管理	标准 PM (suspend/resume)	WakeLock + Doze + App Standby
内存管理	OOM Killer	Low Memory Killer (LMKd)
共享内存	shm / mmap	Ashmem (Android 11 后替换为 memfd)
日志系统	syslog / journald	logcat (环形缓冲区, 多 buffer)
C 库	glibc	Bionic (轻量, 针对移动端优化)
文件系统	ext4 / xfs	EROFS (只读) + F2FS + ext4
安全模型	DAC (用户/组)	DAC + MAC (SELinux) + Seccomp
运行时	无	ART (AOT + JIT 混合编译)
模块化	包管理器 (apt/rpm)	APEX (Android Pony EXpress)

4. 关键目录结构

Android源码/
├── bionic/              # C库（替代glibc，Android专属）
├── bootable/            # Recovery、fastboot 等启动相关
├── build/               # 构建系统（Soong + Kati）
├── cts/                 # 兼容性测试套件
├── dalvik/              # Dalvik 虚拟机（历史）
├── developers/          # 开发者示例
├── development/         # 开发工具与示例
├── device/              # 设备专属配置
│   ├── google/          # Pixel 设备 BSP
│   └── common/          # 通用设备配置
├── external/            # 第三方开源库（protobuf, sqlite等）
├── frameworks/          # Framework层代码
│   ├── base/            # Java Framework 核心
│   ├── native/          # Native Services (SurfaceFlinger等)
│   ├── av/              # 多媒体框架
│   └── opt/             # 可选组件
├── hardware/            # HAL层接口和实现
│   ├── interfaces/      # HIDL接口定义（历史，兼容用）
│   └── libhardware/     # 传统 HAL 头文件
├── kernel/              # Linux内核（GKI common kernel）
├── packages/            # 系统应用和Provider
│   ├── modules/         # Mainline APEX 模块配置
│   └── providers/       # ContentProvider
├── prebuilts/           # 预编译工具链（clang, rustc等）
├── system/              # 核心系统组件
│   ├── core/            # init, logd, adb, healthd等
│   ├── sepolicy/        # SELinux 策略
│   └── vold/            # 卷管理守护进程
└── vendor/              # 供应商专属代码（HAL实现、驱动等）

架构设计理念

HAL层设计模式（传统模式）

Framework层
    ↓ (JNI)
Native Service层
    ↓ (dlopen)
HAL Module (.so)
    ↓ (ioctl/read/write)
Kernel Driver (.ko)
    ↓
Hardware

HAL层设计模式（Android 16 AIDL binderized 模式）

Framework层 (Java/Kotlin)
    ↓ (Java AIDL 接口)
Java Binder 代理
    ↓ (Binder IPC /dev/binder)
AIDL HAL Server 进程 (C++)
    ↓ (AIDL 接口实现)
Vendor HAL 实现 (.so)
    ↓ (ioctl / sysfs)
Kernel Driver (.ko, 内置或 out-of-tree)
    ↓
Hardware

APEX 模块机制详解

Android 16 通过 APEX (Android Pony EXpress) 实现系统组件的独立更新，这是 Project Mainline 的核心载体。

APEX 包结构：
┌─────────────────────────────────┐
│ apex_manifest.pb                │  # 模块元数据
│ apex_pubkey                     │  # 公钥签名
├─────────────────────────────────┤
│ payload/                        │
│   ├── bin/                      │  # 可执行文件
│   ├── lib/ 或 lib64/            │  # 共享库
│   ├── etc/                      │  # 配置文件
│   │   ├── vintf/                │  # VINTF 兼容性描述
│   │   └── init/                 │  # init 脚本
│   └── ...                       │
└─────────────────────────────────┘

Android 16 核心 APEX 模块（30+）：

APEX 模块	内容	更新频率
com.android.art	ART 运行时	季度安全补丁
com.android.media	MediaProvider + MediaCode	季度
com.android.media.swcodec	软件编解码器 (Codec2)	季度
com.android.conscrypt	加密库 (Conscrypt)	月度安全补丁
com.android.extservices	存储/电池管理后台服务	月度
com.android.tethering	网络共享服务	月度
com.android.ipsec	IPsec 安全框架	月度
com.android.dnsresolver	DNS 解析服务	月度
com.android.runtime	ART + bionic 核心组件	季度
com.android.os.statsd	系统统计服务	季度
com.android.health	Health 系统服务	季度
com.android.wifi	Wi-Fi 框架模块	季度
com.android.cellbroadcast	小区广播	季度
com.android.configinfrastructure	配置基础设施	季度
com.android.i18n	国际化库 (ICU)	季度
com.android.timezone	时区数据	按 IANA 更新
com.android.vndk.current	VNDK 运行时	随系统

APEX 配置示例：

// packages/modules/Art/Android.bp
apex {
    name: "com.android.art",
    manifest: "apex_manifest.json",
    key: "com.android.art.key",
    certificate: "com.android.art",
    buildFromSource: true,
    nativeBridgeAbiList: ["arm64-v8a", "x86_64"],
    updatable: true,  // Android 16: 支持 OTA 独立更新
    forceEnumerable: true,
    systemNativeLibs: ["libart", "libart-compiler", "libdexfile"],
}

GKI 2.0 架构

Android 16 强制要求 GKI (Generic Kernel Image) 认证设备，实现了内核与 Android 版本的完全解耦。

GKI 2.0 分层架构：
┌───────────────────────────────────────┐
│  供应商内核模块 (out-of-tree .ko)      │  ← 厂商自行编译
│  - 设备专属驱动                        │
│  - 定制功能模块                        │
├───────────────────────────────────────┤
│  GKI 内核模块 (Google 提供 .ko)        │  ← GKI 认证模块
│  - drivers/gpu/drm/                   │
│  - drivers/net/                       │
│  - fs/ 文件系统等                      │
├───────────────────────────────────────┤
│  GKI Common Kernel (boot.img)          │  ← Google 统一构建
│  - 预编译 vmlinuz                      │
│  - 固定 KMI 版本                       │
│  - 支持 100+ 配置选项                  │
└───────────────────────────────────────┘

KMI (Kernel Module Interface) 版本化机制：

KMI 是 GKI 的核心，它定义了 stable ABI 边界。供应商模块只能依赖 KMI 导出的符号，不能依赖内核内部实现。

# 查看当前 KMI 版本
adb shell uname -r
# 输出示例: 6.6.74-android16-11-01234-gabcd1234
#            │     │          │    │
#            │     │          │    └─ 补丁号
#            │     │          └─ GKI 补丁版本
#            │     └─ Android 内核版本 (android16)
#            └─ 内核主版本号 (6.6 LTS)

# 检查模块是否与 KMI 兼容
modinfo vendor_driver.ko | grep vermagic
# 输出: vermagic=6.6.74-android16-11 SMP preempt mod_unload aarch64

HAL模块加载机制（传统 .so 模式）

// 1. 定义HAL模块结构体
struct xxx_module_t {
    struct hw_module_t common;
    // 自定义成员
};

// 2. 定义HAL设备结构体
struct xxx_device_t {
    struct hw_device_t common;
    // 设备操作函数指针
    int (*open)(...);
    int (*close)(...);
};

// 3. 导出符号（必须）
HAL_MODULE_INFO_SYM

AIDL HAL 接口示例（Android 16 主流）

AIDL HAL 相比 HIDL 的核心优势：编译时类型检查、更好的 IDE 支持、支持 default method、enum/union 类型。

// hardware/interfaces/camera/provider/aidl/ICameraProvider.aidl
package android.hardware.camera.provider;

import android.hardware.camera.common.CameraId;
import android.hardware.camera.common.CameraStatus;
import android.hardware.camera.common.Status;

/**
 * CameraProvider HAL - AIDL 接口定义 (Android 16)
 */
interface ICameraProvider {
    /**
     * 获取可用的摄像头 ID 列表
     */
    getCameraIdList() => (Status status, CameraId[] cameraIds);

    /**
     * 获取指定摄像头的能力
     */
    getCameraCharacteristics(in CameraId cameraId)
        => (Status status, CameraCharacteristics chars);

    /**
     * 打开摄像头设备
     * @param callback 摄像头状态回调
     */
    openCamera(in CameraId cameraId, in ICameraDeviceCallback callback)
        => (Status status, ICameraDevice device);

    /**
     * 设置摄像头状态回调（供应商扩展）
     */
    setTorchMode(in CameraId cameraId, in boolean enabled) => Status status;

    /**
     * [Android 16 新增] 获取摄像头热力图数据
     * 用于 AI 辅助的场景识别
     */
    getCameraHeatmapData(in CameraId cameraId)
        => (Status status, CameraHeatmapData data);
}

AIDL HAL 服务端实现（C++）：

// vendor/camera/provider/CameraProvider.cpp
#include <aidl/android/hardware/camera/provider/BnCameraProvider.h>

class CameraProvider : public BnCameraProvider {
public:
    ndk::ScopedAStatus getCameraIdList(
        std::vector<CameraId>* cameraIds) override {
        // 探测硬件，返回摄像头列表
        *cameraIds = enumerateCameras();
        return ndk::ScopedAStatus::ok();
    }

    ndk::ScopedAStatus openCamera(
        const CameraId& cameraId,
        const std::shared_ptr<ICameraDeviceCallback>& callback,
        std::shared_ptr<ICameraDevice>* device) override {
        // 初始化 V4L2 设备节点
        auto dev = std::make_shared<CameraDevice>(cameraId, callback);
        *device = dev;
        return ndk::ScopedAStatus::ok();
    }
};

// 注册为 binder 服务
static std::shared_ptr<CameraProvider> provider =
    ndk::SharedRefBase::make<CameraProvider>();
status = AServiceManager_addService(
    provider->asBinder().get(),
    "android.hardware.camera.provider.CameraProvider/0");

HAL版本演进（截至 Android 16）

• 传统 HAL（Android 7 及之前）：直接编译到 system.img，通过 dlopen 加载 .so，无进程隔离
• HIDL HAL（Android 8.0 ~ Android 14）：进程隔离，binderized 或 passthrough 模式，使用 .hal 文件定义接口
• AIDL HAL（Android 11 引入，Android 16 默认推荐）：更简洁的接口定义，支持 default method、枚举、union 类型，编译时类型检查，更好的 IDE 支持
• Android 16 策略：所有新 HAL 必须使用 AIDL 定义，HIDL 进入维护模式，不再接受新接口

与Framework层的关联

典型调用链（以 Camera 为例，Android 16 AIDL HAL）

CameraService (Framework, system_server 进程)
    ↓ (Java AIDL 接口)
Binder IPC (/dev/binder)
    ↓
CameraProvider AIDL Server (vendor 进程)
    ↓ (AIDL 实现)
Vendor Camera HAL (C++ .so, v4l2 封装)
    ↓ (ioctl / sysfs / mediactl)
V4L2驱动 (/dev/video0 ~ /dev/videoN)
    ↓
Camera Sensor + ISP 硬件

典型调用链（以 Display 为例）

SurfaceFlinger (Native Service, system 进程)
    ↓ (AIDL IComposer HAL)
Binder IPC
    ↓
Composer AIDL Server (vendor 进程)
    ↓
Display Driver (DRM/KMS 或 fbdev)
    ↓ (ioctl DRM_IOCTL_MODE_*)
GPU / Display Controller 硬件

分区系统与文件系统（Android 16）

分区架构演进

Android 16 采用 virtual A/B 分区 + 动态分区 + EROFS 的组合方案：

┌──────────────────────────────────────────────┐
│  boot        │ boot.img (GKI kernel + ramdisk) │
├──────────────────────────────────────────────┤
│  vendor_boot │ vendor_boot.img (vendor kernel  │
│              │ modules + vendor ramdisk)       │
├──────────────────────────────────────────────┤
│  system      │ system.img (APEX + Framework)   │
│              │ [EROFS 只读, 压缩率 ~30%]       │
├──────────────────────────────────────────────┤
│  product     │ product.img (厂商预装应用)       │
│              │ [EROFS 只读]                   │
├──────────────────────────────────────────────┤
│  vendor      │ vendor.img (HAL + 驱动)         │
│              │ [EROFS 只读]                   │
├──────────────────────────────────────────────┤
│  system_ext  │ system_ext.img (系统扩展)        │
├──────────────────────────────────────────────┤
│  userdata    │ userdata.img (ext4/f2fs 可读写) │
├──────────────────────────────────────────────┤
│  metadata    │ 加密密钥 + 设备元数据            │
├──────────────────────────────────────────────┤
│  super       │ 动态分区容器 (包含以上逻辑分区)   │
│              │ [运行时可调整大小]              │
├──────────────────────────────────────────────┤
│  virtual A/B  │ 快照机制, 无需双倍空间          │
│              │ [OTA 时创建 COW 副本]           │
└──────────────────────────────────────────────┘

Virtual A/B 分区机制

Virtual A/B 是 Android 11 引入、Android 16 完善的无缝 OTA 方案：

特性	传统 A/B	Virtual A/B
空间占用	需要双倍存储空间	仅需 ~20% 额外空间
实现方式	两个完整分区	快照 + COW (Copy-on-Write)
OTA 过程	写入空闲槽位	写入 COW 文件，重启时合并
回滚	切换槽位即可	丢弃 COW 文件即可

设备配置示例（BoardConfig.mk）：

# BoardConfig.mk - 分区定义 (Android 16)
BOARD_USES_DYNAMIC_PARTITIONS := true
BOARD_SUPER_PARTITION_SIZE := 9126805504  # ~8.5GB
BOARD_SUPER_PARTITION_GROUPS := google_dynamic_partitions
BOARD_GOOGLE_DYNAMIC_PARTITIONS_SIZE := 9122611200
BOARD_GOOGLE_DYNAMIC_PARTITIONS_PARTITION_LIST := \
    system system_ext product vendor vendor_dlkm \
    odm odm_dlkm product_services

# Virtual A/B 配置
AB_OTA_UPDATER := true
BOARD_BUILD_SYSTEM_ROOT_IMAGE := true

# EROFS 只读文件系统
TARGET_RO_FILE_SYSTEM_TYPE := erofs
BOARD_USES_VENDOR_DLKMIMAGE := true
BOARD_VENDOR_DLKMIMAGE_FILE_SYSTEM_TYPE := erofs

# GKI 内核配置
BOARD_KERNEL_IMAGE := prebuilt/GKI/kernel
BOARD_VENDOR_RAMDISK_KERNEL_MODULES_BLOCKLIST_FILE := $(KERNEL_DIR)/vendor_ramdisk_module_blocklist.txt

驱动开发要点

1. GKI 2.0 下添加新驱动的步骤

在 GKI 2.0 架构下，驱动开发方式与传统 Android 有显著不同：

# GKI 2.0 驱动开发流程

# 方式一：作为 GKI 认证模块提交到 common kernel（需 Google 审核）
# 1. 修改 Android common kernel 源码
common/drivers/my_driver/my_driver.c

# 2. 修改 Kconfig
config MY_DRIVER
    tristate "My Driver Support"
    depends on ARCH_QCOM || ARCH_MEDIATEK
    default m  # GKI 要求编译为模块 (.ko)，非内置

# 3. 修改 Makefile
obj-$(CONFIG_MY_DRIVER) += my_driver.o

# 4. 确保模块通过 GKI 预提交检查
#    - 只使用 GKI 导出的符号
#    - 不依赖 out-of-tree 代码

# 方式二：作为供应商内核模块 (out-of-tree)
# 1. 在 vendor 目录下维护驱动
vendor/my_company/kernel-modules/my_driver/

# 2. 使用 GKI KMI 接口编译
make -C common_kernel \
    M=$(PWD)/vendor/my_company/kernel-modules/my_driver \
    KCFLAGS="-mrecord-mcount" \
    modules

# 3. 检查 KMI 兼容性
${ANDROID_BUILD_TOP}/kernel/build/gki/generate_abi.sh

2. 字符设备驱动框架

// 驱动注册
static int __init my_driver_init(void) {
    register_chrdev(major, "my_dev", &fops);
    class_create(...);
    device_create(...); // 自动创建/dev/my_dev节点
}

// 驱动操作
static struct file_operations fops = {
    .open = my_open,
    .release = my_release,
    .read = my_read,
    .write = my_write,
    .unlocked_ioctl = my_ioctl,
};

3. 设备树（Device Tree）

• 作用：描述硬件信息，与驱动代码解耦
• 文件：.dts（设备树源码）→ .dtb（二进制）
• 加载：Bootloader 传递给内核

my_device@40000000 {
    compatible = "vendor,my-device";
    reg = <0x40000000 0x1000>;
    interrupts = <0 32 4>;
    clocks = <&clk_device>;
    iommus = <&smmu 0x1234>;  // Android 16: 强制要求 IOMMU
    power-domains = <&pd_my_dev>;  // 电源域管理
};

4. SELinux 策略配置（Android 16 强制要求）

Android 16 对 SELinux 执行更严格的策略，驱动相关节点必须正确标注：

# vendor/sepolicy/my_device.te
type my_device, dev_type;

# vendor/sepolicy/file_contexts
/dev/my_device    u:object_r:my_device:s0

# vendor/sepolicy/hal_camera_server.te (AIDL HAL 进程)
allow hal_camera_server my_device:chr_file { open read write ioctl };

调试命令和工具

1. 内核调试

# 查看内核日志
adb shell dmesg
adb shell cat /proc/kmsg

# 查看设备节点
adb shell ls -l /dev/

# 查看驱动信息
adb shell cat /proc/devices
adb shell cat /proc/interrupts
adb shell cat /proc/iomem

# 查看模块（GKI 2.0）
adb shell lsmod
adb shell modinfo vendor_driver.ko

# 查看 KMI 版本
adb shell uname -r
# 输出: 6.6.74-android16-11-01234-gabcd1234

# 查看 GKI 模块是否加载正常
adb shell lsmod | grep android

2. HAL 调试

# 查看 AIDL HAL 服务注册情况（Android 16 推荐方式）
adb shell service list | grep camera

# 查看 AIDL HAL 服务进程状态
adb shell ps -A | grep hal

# 查看 Binder 通信状态
adb shell cat /sys/kernel/debug/binder/failed_transactions_log
adb shell cat /sys/kernel/debug/binder/transaction_log

# 查看 VINTF 兼容性清单
adb shell vintf

# HAL 日志（需在代码中添加）
ALOGD("HAL: xxx");  # 使用Android日志系统
adb shell logcat | grep -i "camera@2"

# 查看传统 HAL 库（兼容层）
adb shell ls -l /vendor/lib/hw/
adb shell lsof | grep libhardware

3. APEX 模块调试

# 查看已安装的 APEX 模块
adb shell cmd apex list

# 查看 APEX 模块版本
adb shell getprop ro.bootimage.build.date

# 检查 Mainline 模块状态
adb shell pm get-privilege-permissions

# 手动触发 APEX 更新（测试用）
adb shell cmd apex refresh

4. 分区与文件系统调试

# 查看分区布局
adb shell ls -l /dev/block/by-name/
adb shell ls -l /dev/block/mapper/

# 查看 EROFS 文件系统信息
adb shell cat /sys/fs/erofs/features
adb shell df -h

# 查看 dynamic partitions 信息
adb shell lptool --dump

# 查看 virtual A/B 快照状态
adb shell snapshot status

5. 性能分析

# Perfetto（替代 Systrace，Android 16 推荐）
adb shell perfetto -c - -o /data/misc/perfetto-traces/trace.perfetto-trace

# 内核函数追踪
adb shell
echo 1 > /sys/kernel/debug/tracing/tracing_on
echo function > /sys/kernel/debug/tracing/current_tracer

# eBPF 追踪（Android 16 增强支持）
adb shell bpftrace -e 'tracepoint:syscalls:sys_enter_read { printf("read fd: %d\n", args->fd); }'

开发环境搭建

1. 源码下载（repo工具）

# 安装repo
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo

# 初始化 Android 16 (Baklava) 仓库
repo init -u https://android.googlesource.com/platform/manifest -b android16-release

# 同步源码（约 100GB）
repo sync -j8 --no-tags --no-clone-bundle

# 下载 GKI 内核源码（如需修改内核）
repo init -u https://android.googlesource.com/kernel/manifest -b common-android16-6.6
repo sync -j8

2. 编译工具链

# 设置环境变量
source build/envsetup.sh
lunch aosp_arm64-userdebug  # Android 16 推荐 userdebug 构建

# 编译全量（Soong build system）
m -j$(nproc)

# 编译单个模块（Soong）
m com.android.art

# 编译内核（GKI 方式）
m bootimage vendor_bootimage

# 编译 vendor 内核模块
m vendor_dlkmimage

3. GKI 内核单独编译

# 进入 GKI 内核目录
cd common-android16-6.6/

# 使用 build.config.gki.aarch64 配置
BUILD_CONFIG=common/build.config.gki.aarch64 \
    build/build.sh

# 编译后产物：
# - out/android16-6.6/dist/boot.img        (GKI boot 镜像)
# - out/android16-6.6/dist/Image           (内核镜像)
# - out/android16-6.6/dist/*.ko            (GKI 模块)
# - out/android16-6.6/dist/abi.xml         (ABI 定义)

4. 使用 Android Studio 进行内核/HAL 开发

# 生成 AIDL HAL 的 IDE 支持文件（Android 16）
aidl --lang=cpp \
    -I hardware/interfaces/camera/provider/aidl/ \
    -o out/soong/.intermediates/ \
    hardware/interfaces/camera/provider/aidl/android/hardware/camera/provider/ICameraProvider.aidl

# 或者使用 Android.bp 自动生成：
# mmm hardware/interfaces/camera/provider/aidl/

与T87A0项目的关联

1. 安防智慧屏硬件特性

• Camera：多路视频输入，需要 Camera AIDL HAL + V4L2 驱动
• Video Codec：硬件编解码，需要 Codec2 AIDL HAL 对接
• Display：HDMI 输出 + 触摸屏，需要 Display AIDL HAL + DRM/KMS 驱动
• Audio：对讲功能，需要 Audio AIDL HAL + ALSA 驱动
• Network：Wi-Fi + 以太网，需要 Network AIDL HAL
• Sensor：PIR 人体感应、光线传感器，通过 Sensors AIDL HAL 上报

2. 可能涉及的 AIDL HAL 模块

hardware/interfaces/
├── camera/            # 摄像头 AIDL HAL
│   └── provider/      # CameraProvider/ICameraProvider.aidl
├── media/             # 多媒体 AIDL HAL
│   └── codec2/        # Codec2 HAL (编解码)
├── graphics/          # 显示 AIDL HAL
│   └── composer/      # IComposer HAL (HDMI输出)
├── audio/             # 音频 AIDL HAL
│   ├── core/          # ICore/IAudio HAL
│   └── effect/        # 音效处理
├── sensors/           # 传感器 AIDL HAL (PIR等)
├── wifi/              # Wi-Fi AIDL HAL
└── input/             # 输入设备 AIDL HAL (触摸屏)

3. BSP开发重点

device/google/t87a0/
├── BoardConfig.mk          # 编译配置（含 GKI/Erofs 定义）
├── device.mk               # 设备特性 + APEX 配置
├── kernel/                 # 内核 defconfig + 模块列表
├── sepolicy/               # SELinux 策略（Android 16 更严格）
├── recovery/               # Recovery 模式（Virtual A/B 支持）
├── overlay/                # 资源覆盖
├── manifest.xml            # VINTF 兼容性清单（AIDL HAL 声明）
└── firmware/               # 固件文件

4. 驱动开发关注点

• 视频输入驱动：支持多路并行采集 (V4L2 mem2mem)
• ISP驱动：图像处理（降噪、HDR等），通过 mediactl 管线管理
• 编码器驱动：H.264/H.265 硬件加速 (Codec2 HAL 对接)
• 显示驱动：DRM/KMS 驱动，支持 HDMI 输出和双屏显示
• 存储驱动：F2FS 文件系统优化，支持大文件连续写入

快速回忆检查点

问题1：Android与标准Linux的主要区别是什么？

答案

• Binder IPC 机制（内核级，零拷贝）
• WakeLock 电源管理 + Doze + App Standby
• Low Memory Killer (LMKd)
• memfd 匿名共享内存（Android 11+ 替代 Ashmem）
• logcat 日志系统（多 buffer 环形缓冲区）
• HAL 硬件抽象层 + AIDL/HIDL 接口
• SELinux MAC 安全模型 + Seccomp 过滤
• ART 运行时（AOT + JIT 混合编译）
• APEX 模块化系统（独立更新）

问题2：HAL层的作用是什么？为什么需要HAL？

答案

• 隔离内核驱动与 Framework，保护厂商知识产权
• 避免 GPL 协议传染（内核 GPL，HAL 可以 Apache）
• 统一硬件接口，简化设备移植
• Android 8+ 进程隔离（binderized HAL），提高系统稳定性
• Android 11+ AIDL HAL 提供编译时类型检查和更好的 IDE 支持
• Android 16 要求所有新 HAL 使用 AIDL 定义

问题3：如何查看Android设备的内核日志和GKI状态？

答案

adb shell dmesg           # 查看内核环形缓冲区
adb shell cat /proc/kmsg  # 实时查看内核日志
adb shell uname -r        # 查看 GKI KMI 版本
adb shell lsmod           # 查看已加载的内核模块
adb shell modinfo xxx.ko  # 查看模块信息

问题4：Android 16 系统架构从上到下是什么？

答案

1. 应用层（Applications，APK/APEX）
2. 应用框架层（Java API Framework）
3. Native层 + AIDL HAL层（C/C++/Rust 库 + 硬件抽象）
4. GKI 通用内核层（common kernel + KMI + vendor modules）
5. Linux内核层 + 硬件驱动（内置驱动 + out-of-tree 模块）

问题5：GKI 2.0 下如何添加一个新的内核驱动？

答案

1. 编写驱动代码（.c 文件），确保只使用 GKI 导出的符号
2. 修改 Kconfig（配置选项，要求 tristate = m）
3. 修改 Makefile（编译规则，输出 .ko 模块）
4. 使用 build.config.gki.aarch64 配置编译
5. 通过 generate_abi.sh 检查 KMI 兼容性
6. 烧录到 vendor_boot.img 或 vendor_dlkm.img

问题6：什么是 APEX？Android 16 有哪些核心 APEX 模块？

答案

APEX (Android Pony EXpress) 是 Android 的系统模块化格式，支持独立 OTA 更新。

Android 16 核心 APEX 模块（30+）包括：

• com.android.art - ART 运行时
• com.android.media / .media.swcodec - 多媒体
• com.android.conscrypt - 加密库
• com.android.tethering / .ipsec - 网络与安全
• com.android.runtime - ART + bionic
• com.android.os.statsd - 系统统计
• 等 30+ 个模块，支持月度/季度安全补丁独立更新

问题7：AIDL HAL 相比 HIDL HAL 有什么优势？

答案

• 编译时类型检查：AIDL 在编译时就能发现接口不匹配问题
• 更好的 IDE 支持：Android Studio 原生支持 AIDL 语法高亮和跳转
• 支持 default method：接口可以提供默认实现，向后兼容更灵活
• 支持 enum/union 类型：类型表达能力更强
• 更简洁的语法：无需 .hal 专用语法，使用标准 AIDL
• Android 16 策略：所有新 HAL 必须使用 AIDL，HIDL 进入维护模式

关键概念图谱

Android 16 系统架构
├── 五层架构（含 GKI 分离）
│   ├── 应用层 (APK + APEX)
│   ├── Java Framework
│   ├── Native + AIDL HAL (进程隔离, binderized)
│   ├── GKI 通用内核层 (common kernel + KMI)
│   └── Linux 内核层 (内置驱动 + out-of-tree 模块)
│
├── 为什么需要 HAL？
│   ├── 保护知识产权（避免 GPL 传染）
│   ├── 统一接口（简化移植）
│   ├── 进程隔离（提高系统稳定性）
│   └── 动态加载（灵活适配不同硬件）
│
├── HAL 如何工作？
│   ├── Framework 通过 Java AIDL 接口调用
│   ├── Binder IPC (/dev/binder) 跨进程通信
│   ├── AIDL HAL Server 进程实现硬件接口
│   ├── HAL 通过 ioctl 操作内核驱动
│   └── 驱动控制硬件
│
├── APEX 模块化系统
│   ├── 30+ 独立更新模块
│   ├── 月度/季度安全补丁独立推送
│   ├── 无需完整 OTA 即可更新系统组件
│   └── Project Mainline 核心载体
│
├── GKI 2.0 内核架构
│   ├── common kernel（Google 统一构建）
│   ├── KMI 版本化接口（稳定 ABI）
│   ├── 供应商模块（out-of-tree .ko）
│   └── 内核与 Android 版本解耦
│
├── 分区系统
│   ├── Virtual A/B（无缝 OTA，仅需 ~20% 额外空间）
│   ├── 动态分区（运行时可调整大小）
│   └── EROFS 只读文件系统（压缩率 ~30%）
│
├── 与标准 Linux 的差异
│   ├── IPC：Binder vs Socket/D-Bus
│   ├── 电源：WakeLock/Doze vs 标准 PM
│   ├── 内存：LMKd vs OOM Killer
│   ├── 日志：logcat vs syslog/journald
│   ├── 安全：SELinux + Seccomp vs DAC
│   └── 模块化：APEX vs apt/rpm
│
├── HAL 版本演进
│   ├── 传统 HAL（Android 7-，dlopen .so）
│   ├── HIDL HAL（Android 8-14，.hal 定义，进入维护）
│   └── AIDL HAL（Android 11+，Android 16 默认推荐）
│
└── 驱动开发流程（GKI 2.0）
    ├── 编写驱动代码（只使用 GKI 导出符号）
    ├── 配置编译系统（Kconfig/Makefile）
    ├── GKI 编译（build.config.gki.aarch64）
    ├── KMI 兼容性检查（generate_abi.sh）
    └── 烧录验证（boot.img / vendor_boot.img / vendor_dlkm.img）