Android是基于Linux的，使用Bionic Libc库调用Linux系统调用的衍生发行版操作系统。其给内核添加了一些用来实现安卓所需特性的系统调用，将一些驱动实现为了可插拔的.ko模块，基于此实现了Hardware Abstract Layer/HAL层。 ## 一、Android内核的制作流程

1. 基础来源

2. 定制化步骤

a) 添加Android专属模块

b) 硬件支持层（HAL适配）

c) 安全与权限扩展

d) 性能与功耗优化

3. 集成流程示例

# 1. 从主线获取内核
git clone https://kernel.org/pub/scm/linux/kernel/git/stable/linux.git
cd linux

# 2. 合并Android通用内核补丁
git fetch https://android.googlesource.com/kernel/common android-mainline
git merge FETCH_HEAD

# 3. 添加设备特定代码（如Pixel内核）
git fetch https://android.googlesource.com/device/kernel/google/msm
git merge FETCH_HEAD

二、Android如何利用该内核

1. 系统启动流程

Bootloader → Linux内核 → init进程 → Zygote → SystemServer → 应用

2. 硬件抽象层（HAL）

3. 关键子系统依赖

4. 安全机制

5. 供应商内核模块（GKI）

三、与主线内核的差异与协作

1. 长期分歧与逐步合并

2. 开发模式

四、示例：Pixel设备内核构建

# 下载Pixel 6内核（Tensor芯片）
repo init -u https://android.googlesource.com/kernel/manifest -b android13-gs-pixel-5.10
repo sync
build/build.sh
# 输出：GKI内核 + 模块文件

一、Android系统启动流程

1. Bootloader阶段

# 设备上电后的启动序列
Power On → Boot ROM → Bootloader → Kernel → Android

Bootloader（如U-Boot）主要任务： - 初始化硬件（时钟、内存、外设） - 加载内核镜像和设备树（DTB） - 设置启动参数 - 跳转到内核入口

2. Linux内核启动

// 内核启动流程示例
start_kernel()
    → setup_arch()        // 架构相关初始化
    → setup_dt()          // 解析设备树
    → init_IRQ()          // 中断初始化
    → time_init()         // 时钟初始化
    → rest_init()         // 启动init进程

3. Android特有的启动阶段

init进程（PID 1）

# init.rc配置文件示例
on early-init
    # 挂载文件系统
    mount tmpfs tmpfs /dev
    
on init
    # 创建设备节点
    mkdir /dev/block
    chmod 0755 /dev/block
    
on boot
    # 启动核心服务
    start servicemanager
    start zygote
    start surfaceflinger

Zygote进程

// ZygoteInit.java 核心逻辑
public static void main(String[] argv) {
    // 1. 预加载类和资源
    preload();
    
    // 2. 启动SystemServer
    if (startSystemServer) {
        forkSystemServer();
    }
    
    // 3. 进入循环，等待创建应用进程
    runSelectLoop();
}

System Server启动

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

private void run() {
    // 启动核心服务
    startBootstrapServices();  // ActivityManager, PowerManager
    startCoreServices();       // Battery, UsageStats
    startOtherServices();      // WindowManager, InputManager
}

二、Java抽象层的实现

1. HAL（硬件抽象层）架构

应用层 (Java/Kotlin)
    ↓
Framework层 (Java)
    ↓
JNI层 (C++)
    ↓
HAL层 (C/C++)      ← 厂商实现
    ↓
Linux内核驱动

2. JNI桥接机制

// 示例：Camera的JNI实现
// frameworks/base/core/jni/android_hardware_Camera.cpp

static const JNINativeMethod camMethods[] = {
    {"native_setup", "(Ljava/lang/Object;ILjava/lang/String;)V",
        (void*)android_hardware_Camera_native_setup},
    {"native_release", "()V",
        (void*)android_hardware_Camera_release},
};

// JNI函数实现
static void android_hardware_Camera_native_setup(
    JNIEnv *env, jobject thiz, jobject weak_this, 
    jint cameraId, jstring packageName) {
    
    // 创建Camera对象
    sp<Camera> camera = Camera::connect(cameraId);
    
    // 保存到Java对象
    setCameraNative(env, thiz, camera);
}

3. Binder IPC机制

// AIDL接口定义
interface ICameraService {
    ICamera connect(ICameraClient client, int cameraId);
}

// 服务端实现
public class CameraService extends ICameraService.Stub {
    @Override
    public ICamera connect(ICameraClient client, int cameraId) {
        return new Camera(cameraId);
    }
}

三、设备树（DTB）的Java封装

1. 内核中的设备树处理

// 内核读取设备树节点
struct device_node *node = of_find_node_by_path("/soc/camera");
const char *name = of_get_property(node, "compatible", NULL);
int irq = irq_of_parse_and_map(node, 0);

2. Android中的设备属性系统

属性服务（init进程管理）

# 系统属性定义
ro.hardware=qualcomm
ro.product.model=Pixel
persist.sys.timezone=Asia/Shanghai

Java层访问设备属性

// 通过SystemProperties访问
import android.os.SystemProperties;

public class DeviceInfo {
    public String getHardware() {
        return SystemProperties.get("ro.hardware");
    }
    
    public String getModel() {
        return SystemProperties.get("ro.product.model");
    }
}

3. 硬件服务框架

// Camera HAL接口定义
public abstract class CameraDevice {
    public abstract void configure(StreamConfiguration config);
    public abstract CaptureResult capture(CaptureRequest request);
}

// 厂商实现
public class QualcommCamera extends CameraDevice {
    @Override
    public void configure(StreamConfiguration config) {
        // 调用native层
        nativeConfigure(config);
    }
    
    private native void nativeConfigure(StreamConfiguration config);
}

四、完整的启动时序图

时间轴:
│
├─ Boot ROM (芯片固件)
│   ├─ 加载Bootloader
│   └─ 验证签名
│
├─ Bootloader (U-Boot/ABL)
│   ├─ 初始化DDR、时钟
│   ├─ 加载内核和DTB
│   └─ 传递cmdline
│
├─ Linux Kernel
│   ├─ 解析DTB，创建设备
│   ├─ 初始化驱动
│   └─ 启动init进程
│
├─ Android init
│   ├─ 解析init.rc
│   ├─ 启动ueventd、logd
│   ├─ 挂载文件系统
│   └─ 启动Zygote
│
├─ Zygote
│   ├─ 预加载类
│   ├─ 启动SystemServer
│   └─ 监听socket
│
├─ System Server
│   ├─ 启动AMS、PMS、WMS
│   ├─ 注册服务到ServiceManager
│   └─ 启动Launcher
│
└─ 应用启动
    ├─ Zygote fork进程
    ├─ 加载应用类
    └─ 执行Activity生命周期

五、关键组件详解

1. ServiceManager

// 服务注册
sp<IServiceManager> sm = defaultServiceManager();
sm->addService(String16("activity"), new ActivityManagerService());

// 服务获取
sp<IBinder> binder = sm->getService(String16("activity"));
sp<IActivityManager> am = interface_cast<IActivityManager>(binder);

2. SurfaceFlinger（显示合成）

class SurfaceFlinger : public BnSurfaceComposer {
    void createSurface(String8 name, DisplayId display) {
        // 创建Layer
        sp<Layer> layer = new Layer(this, name);
        mCurrentState.layers.add(layer);
    }
    
    void onMessageReceived(int32_t what) {
        switch (what) {
            case MessageQueue::INVALIDATE:
                handleMessageTransaction();
                handleMessageInvalidate();
                break;
        }
    }
};

3. ART运行时

// Zygote中初始化ART
public class ZygoteInit {
    static void preload() {
        // 预加载类
        preloadClasses();
        
        // 初始化ART
        VMRuntime.getRuntime().startBootImageProfile();
    }
}

六、构建系统集成

# Android.bp示例
cc_binary {
    name: "camera.hal",
    srcs: ["*.cpp"],
    shared_libs: [
        "liblog",
        "libhardware",
        "libutils",
    ],
    cflags: ["-DLOG_TAG=\"CameraHAL\""],
}

这种架构设计使得Android能够： 1. 硬件抽象：通过HAL隔离硬件差异 2. 安全隔离：每个应用在独立进程运行 3. 性能优化：JIT/AOT编译提升执行效率 4. 可扩展性：通过Binder IPC实现模块化