Android系统灯光子系统 HAL层实现详解
一、Android灯光系统架构概述
Android的灯光系统采用分层架构设计，从上层到下层依次为：
- Java层：负责业务逻辑处理和API接口
- JNI层：Java本地接口，实现跨语言调用
- HAL层：硬件抽象层，直接与底层硬件交互
各层对应的核心文件位置：
- Java服务层：frameworks/base/services/core/java/com/android/server/lights/LightsService.java
- JNI实现：frameworks/base/services/core/jni/com_android_server_lights_LightsService.cpp
- HAL层：hardware/libhardware/modules/lights/lights.c
电池相关：frameworks/base/services/core/java/com/android/server/BatteryService.java
通知服务：frameworks/base/services/core/java/com/android/server/notification/NotificationManagerService.java
灯光HAL实现要点
实现一个标准的灯光HAL模块需要完成以下三个核心步骤：
- 定义一个名为HMI的hw_module_t结构体，作为模块入口
- 实现open回调函数，根据设备名称返回对应的light_device_t结构体
- 为每种灯光设备实现独立的light_device_t结构体，包含set_light方法用于控制灯光
二、HAL层灯光驱动实现
以下是一个完整的灯光HAL实现示例，通过sysfs文件系统控制LED设备：
/*
* Android Lights HAL Implementation
*
* This module provides hardware abstraction for various light devices
* including backlight, battery indicator, and notification LED.
*/
#define LOG_NDEBUG 0
#define LOG_TAG "lights-hwservice"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* LED设备sysfs路径定义 */
static const char* RED_LED_PATH = "/sys/class/leds/red/brightness";
static const char* GREEN_LED_PATH = "/sys/class/leds/green/brightness";
static const char* BLUE_LED_PATH = "/sys/class/leds/blue/brightness";
static const char* RED_LED_TRIGGER = "/sys/class/leds/red/trigger";
static const char* GREEN_LED_TRIGGER = "/sys/class/leds/green/trigger";
static const char* BLUE_LED_TRIGGER = "/sys/class/leds/blue/trigger";
static const char* RED_LED_ON_TIME = "/sys/class/leds/red/delay_on";
static const char* GREEN_LED_ON_TIME = "/sys/class/leds/green/delay_on";
static const char* BLUE_LED_ON_TIME = "/sys/class/leds/blue/delay_on";
static const char* RED_LED_OFF_TIME = "/sys/class/leds/red/delay_off";
static const char* GREEN_LED_OFF_TIME = "/sys/class/leds/green/delay_off";
static const char* BLUE_LED_OFF_TIME = "/sys/class/leds/blue/delay_off";
static const char* LCD_BACKLIGHT_PATH = "/sys/class/backlight/panel/brightness";
/* 线程同步机制 */
static pthread_once_t g_initialization = PTHREAD_ONCE_INIT;
static pthread_mutex_t g_device_lock = PTHREAD_MUTEX_INITIALIZER;
/* 灯光状态存储 */
static struct light_state_t g_notification_state;
static struct light_state_t g_battery_state;
/**
* 向指定路径写入整数值
*/
static int write_integer_value(const char *file_path, int value) {
int file_descriptor;
static int warning_flag = 0;
file_descriptor = open(file_path, O_RDWR);
if (file_descriptor < 0) {
if (warning_flag == 0) {
ALOGE("Failed to open %s for writing", file_path);
warning_flag = 1;
}
return -errno;
}
char data_buffer[24];
int bytes_to_write = snprintf(data_buffer, sizeof(data_buffer), "%d\n", value);
int bytes_written = write(file_descriptor, data_buffer, bytes_to_write);
close(file_descriptor);
return (bytes_written == -1) ? -errno : 0;
}
/**
* 向指定路径写入字符串值
*/
static int write_text_value(const char *file_path, const char *value) {
int file_descriptor;
static int warning_flag = 0;
file_descriptor = open(file_path, O_RDWR);
if (file_descriptor < 0) {
if (warning_flag == 0) {
ALOGE("Failed to open %s for writing", file_path);
warning_flag = 1;
}
return -errno;
}
char data_buffer[32];
int bytes_to_write = snprintf(data_buffer, sizeof(data_buffer), "%s\n", value);
int bytes_written = write(file_descriptor, data_buffer, bytes_to_write);
close(file_descriptor);
return (bytes_written == -1) ? -errno : 0;
}
/**
* 判断灯光状态是否激活
*/
static bool check_light_active(const struct light_state_t *light_state) {
return (light_state->color & 0x00FFFFFF) != 0;
}
/**
* 将RGB颜色转换为亮度值
* 使用加权公式：R*0.299 + G*0.587 + B*0.114
*/
static int convert_rgb_to_brightness(const struct light_state_t *light_state) {
int color_value = light_state->color & 0x00FFFFFF;
int red_component = (color_value >> 16) & 0xFF;
int green_component = (color_value >> 8) & 0xFF;
int blue_component = color_value & 0xFF;
return ((77 * red_component) + (150 * green_component) + (29 * blue_component)) >> 8;
}
/**
* 设置LCD背光亮度
*/
static int update_backlight(struct light_device_t *device,
const struct light_state_t *state) {
int brightness_level = convert_rgb_to_brightness(state);
ALOGV("Backlight brightness: %d, color: 0x%08x", brightness_level, state->color);
pthread_mutex_lock(&g_device_lock);
/* 背光亮度范围调整：输入0-255，输出0-127 */
int adjusted_brightness = brightness_level / 2;
write_integer_value(LCD_BACKLIGHT_PATH, adjusted_brightness);
pthread_mutex_unlock(&g_device_lock);
return 0;
}
/**
* 更新LED灯光状态（内部函数，带锁）
*/
static void update_led_state(struct light_device_t *device,
const struct light_state_t *state) {
int red_intensity, green_intensity, blue_intensity;
int on_duration, off_duration;
/* 提取RGB分量 */
red_intensity = (state->color >> 16) & 0xFF;
green_intensity = (state->color >> 8) & 0xFF;
blue_intensity = state->color & 0xFF;
on_duration = state->flashOnMS;
off_duration = state->flashOffMS;
/* 配置闪烁模式 */
if (state->flashMode != LIGHT_FLASH_NONE) {
write_text_value(RED_LED_TRIGGER, "timer");
write_text_value(GREEN_LED_TRIGGER, "timer");
write_text_value(BLUE_LED_TRIGGER, "timer");
write_integer_value(RED_LED_ON_TIME, on_duration);
write_integer_value(GREEN_LED_ON_TIME, on_duration);
write_integer_value(BLUE_LED_ON_TIME, on_duration);
write_integer_value(RED_LED_OFF_TIME, off_duration);
write_integer_value(GREEN_LED_OFF_TIME, off_duration);
write_integer_value(BLUE_LED_OFF_TIME, off_duration);
} else {
write_text_value(RED_LED_TRIGGER, "none");
write_text_value(GREEN_LED_TRIGGER, "none");
write_text_value(BLUE_LED_TRIGGER, "none");
}
/* 设置LED亮度 */
write_integer_value(RED_LED_PATH, red_intensity);
write_integer_value(GREEN_LED_PATH, green_intensity);
write_integer_value(BLUE_LED_PATH, blue_intensity);
}
/**
* 处理电池和通知灯光的优先级
*/
static void process_light_priority(struct light_device_t *device) {
if (check_light_active(&g_notification_state)) {
update_led_state(device, &g_notification_state);
} else {
update_led_state(device, &g_battery_state);
}
}
/**
* 设置电池指示灯
*/
static int set_battery_indicator(struct light_device_t *device,
const struct light_state_t *state) {
ALOGV("Battery light - Mode: %d, On: %dms, Off: %dms, Color: 0x%08x",
state->flashMode, state->flashOnMS, state->flashOffMS, state->color);
pthread_mutex_lock(&g_device_lock);
g_battery_state = *state;
process_light_priority(device);
pthread_mutex_unlock(&g_device_lock);
return 0;
}
/**
* 设置通知灯光
*/
static int set_notification_indicator(struct light_device_t *device,
const struct light_state_t *state) {
ALOGV("Notification light - Mode: %d, On: %dms, Off: %dms, Color: 0x%08x",
state->flashMode, state->flashOnMS, state->flashOffMS, state->color);
pthread_mutex_lock(&g_device_lock);
g_notification_state = *state;
process_light_priority(device);
pthread_mutex_unlock(&g_device_lock);
return 0;
}
/**
* 初始化全局资源
*/
static void initialize_resources(void) {
pthread_mutex_init(&g_device_lock, NULL);
}
/**
* 关闭灯光设备
*/
static int close_light_device(struct hw_device_t *hw_device) {
if (hw_device) {
free(hw_device);
}
return 0;
}
/**
* 打开灯光设备
*/
static int open_light_device(const struct hw_module_t *module,
const char *name,
struct hw_device_t **device) {
int (*light_control_function)(struct light_device_t *,
const struct light_state_t *);
/* 根据设备名称选择对应的控制函数 */
if (strcmp(LIGHT_ID_BACKLIGHT, name) == 0) {
light_control_function = update_backlight;
} else if (strcmp(LIGHT_ID_BATTERY, name) == 0) {
light_control_function = set_battery_indicator;
} else if (strcmp(LIGHT_ID_NOTIFICATIONS, name) == 0) {
light_control_function = set_notification_indicator;
} else {
return -EINVAL;
}
/* 确保初始化执行一次 */
pthread_once(&g_initialization, initialize_resources);
/* 分配设备结构体内存 */
struct light_device_t *light_dev =
(struct light_device_t *)malloc(sizeof(struct light_device_t));
if (!light_dev) {
return -ENOMEM;
}
memset(light_dev, 0, sizeof(*light_dev));
/* 填充硬件设备结构体 */
light_dev->common.tag = HARDWARE_DEVICE_TAG;
light_dev->common.version = 0;
light_dev->common.module = (struct hw_module_t *)module;
light_dev->common.close = close_light_device;
light_dev->set_light = light_control_function;
*device = (struct hw_device_t *)light_dev;
return 0;
}
/* 模块方法表定义 */
static struct hw_module_methods_t light_module_methods = {
.open = open_light_device
};
/* HAL模块实例定义 */
struct hw_module_t HAL_MODULE_INFO_SYM = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = LIGHTS_HARDWARE_MODULE_ID,
.name = "Android Lights HAL",
.author = "Open Source Community",
.methods = &light_module_methods
};
三、编译配置文件
使用Android.mk文件配置HAL模块的编译选项：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := lights.default
# 生成动态库到hw目录
LOCAL_MODULE_RELATIVE_PATH := hw
LOCAL_C_INCLUDES := hardware/libhardware/include
LOCAL_SRC_FILES := lights.c
# 链接日志库
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_MODULE_TAGS := eng
include $(BUILD_SHARED_LIBRARY)
四、实现要点总结
灯光HAL实现的核心在于：
- 模块入口：通过HAL_MODULE_INFO_SYM结构体导出模块接口
- 设备管理：open函数根据name参数区分不同类型的灯光设备
- 状态管理：保存notification和battery状态，处理优先级逻辑
- 线程安全：使用pthread_mutex保证多线程环境下的数据一致性
- 硬件控制：通过sysfs节点读写实现对LED和背光的控制
该实现遵循Android HAL标准接口规范，可以被上层的LightsService正常调用。
