Android HAL

Android HAL
HAL介绍

Android 的 HAL（硬件抽像层）是 Google 因应厂商「希望不公开源码」的要求下，所推出的新观念，其架构如下图。虽然 HAL 现在的「抽象程度」还不足，现阶段实作还不是全面符合 HAL 的架构规划，不过也确实给了我们很好的思考空间。
[img]http://blogimg.chinaunix.net/blog/upfile2/100304135603.jpg[/img]

图1：Android HAL 架构规划

这是 Patrick Brady (Google) 在2008 Google I/O 所发表的演讲「Anatomy & Physiology of an Android」中，所提出的 Android HAL 架构图。从这张架构图我们知道，HAL 的目的是为了把 Android framework 与 Linux kernel 完整「隔开」。让 Android 不至过度依赖 Linux kernel，有点像是「kernel independent」的意思，让 Android framework 的开发能在不考虑驱动程序的前提下进行发展。
在 Android 原始码里，HAL 主要的实作储存于以下目录：
1. libhardware_legacy/ - 过去的实作、采取链接库模块的观念进行
2. libhardware/ - 新版的实作、调整为 HAL stub 的观念
3. ril/ - Radio Interface Layer
在 HAL 的架构实作成熟前（即图1的规划），我们先就目前 HAL 现况做一个简单的分析。另外，目前 Android 的 HAL 实作，仍旧散布在不同的地方，例如 Camera、WiFi 等，因此上述的目录并不包含所有的 HAL 程序代码。
HAL 的过去


[img]http://blogimg.chinaunix.net/blog/upfile2/100304135615.jpg[/img]
图2：Android HAL / libhardware_legacy

过去的 libhardware_legacy 作法，比较是传统的「module」方式，也就是将 *.so 档案当做「shared library」来使用，在 runtime（JNI 部份）以 direct function call 使用 HAL module。透过直接函数呼叫的方式，来操作驱动程序。
当然，应用程序也可以不需要透过 JNI 的方式进行，直接以加载 *.so 檔（dlopen）的做法呼叫 *.so 里的符号（symbol）也是一种方式。
HAL 的现实状况


[img]http://blogimg.chinaunix.net/blog/upfile2/100304135636.jpg[/img]
图3：Android HAL / libhardware

现在的 libhardware 作法，就有「stub」的味道了。HAL stub 是一种代理人（proxy）的概念，stub 虽然仍是以 *.so 檔的形式存在，但 HAL 已经将 *.so 档隐藏起来了。Stub 向 HAL「提供」操作函数（operations），而 runtime 则是向 HAL 取得特定模块（stub）的 operations，再 callback 这些操作函数。这种以 indirect function call 的实作架构，让 HAL stub 变成是一种「包含」关系，即 HAL 里包含了许许多多的 stub（代理人）。Runtime 只要说明「类型」，即 module ID，就可以取得操作函数。HAL的实现主要在hardware.c和hardware.h文件中。实质也是通过加载 *.so 档（dlopen）从而呼叫 *.so 里的符号（symbol）实现。这里所谓的代理，我感觉不过是Android统一定义了三个结构体，然后通过几个“必须”从而统一了调用接口

HAL 的未来发展？
新的 HAL 做法，倾向全面采用 JNI 的方式进行。也就是，在 Android 的架构中，修改 Android runtime 实作（即「Core Library」），在取得 HAL 模块的 operations 后再做 callback 操作。将 HAL 模块完全放在 HAL 里面。以上我想应该是针对framework开发来说的。如果仅是使用hal访问硬件，完全可以不修改core library。

一、HAL使用步骤：
(1)Java AP 初始化一个 java service， 然后根据需求组合调用 java service 提供的接口。
(2)Java Service 设置 Native Interface声明， 并在初始化时加载 Native Service 所在的库.Native Service 实际上是一个动态链接库， 通过JNI 和 Java Service 交互。
(3)通过 OnLoad 方法注册与 Java Service 的 Native Function 之间的对应 JNI table 。
(4)通过 HAL Module ID 获得当前实际板上对应的硬件设备的 Module， 并通过此 Module 的 HAL接口 Open 获得硬件设备的 device 实例。 通过device提供的接口组合本地函数的实现。
(5)编写 HAL stub, 对具体的硬件设备初始化对应 Module 和 Device实例， 并实现对硬件驱动的API封装。
(6)HAL模块要以MODULE_ID.platform.so的名字存放在文件系统的/system/lib/hw/下面。

Android HAL层主要在hardware目录下，其中hardware\libhardware\下是同一用模块的概念来加载HAL的.so库。 这里以一个简单的led小例子（假设备，不涉及硬件操作）来说明具体实现步骤。
二、HAL Stub 实现步骤(Implementation)
1. 设计自已的wrapper data structure
* 编写头文件led.h
* 定义 struct led_module_t
* 框架提供的struct hw_module_t 、struct hw_device_t必须放在第一个 field，并取名为 common。
* 可参考 hardware/hardware.h

struct led_module_t {
struct hw_module_t common;
/* support API for LEDServices constructor */
};

2. led_module_t的意义
声明初始化时期(new object)的 supporting API、在 constructor里会使用到。
3. 定义led_control_device_t
声明控制时期的 supporting API、在 Manager API 里会使用到。
struct led_control_device_t {
struct hw_device_t common;
/* supporting control APIs go here */
int (*getcount_led)(struct led_control_device_t *dev);
int (*set_on)(struct led_control_device_t *dev);
int (*set_off)(struct led_control_device_t *dev);
};

4. 每個 HAL stub 都要声明 module ID
#define LED_HARDWARE_MODULE_ID "led"
5. 声明 Stub operations 并实现 callback functions
Stub 的 module 结构体必须取名为 HAL_MODULE_INFO_SYM，此名不可更改。
const struct led_module_t HAL_MODULE_INFO_SYM = {
common: {
tag: HARDWARE_MODULE_TAG,
version_major: 1,
version_minor: 0,
id: LED_HARDWARE_MODULE_ID,
name: "led HAL module",
author: "gggggg",
methods: &led_module_methods,
},
/* supporting APIs go here */
};

以下是具体的文件内容。
led.h文件：
#include <hardware/hardware.h>

#include <fcntl.h>
#include <errno.h>

#include <cutils/log.h>
#include <cutils/atomic.h>

#define LED_HARDWARE_MODULE_ID "led"

struct led_module_t {
struct hw_module_t common;
/* support API for LEDServices constructor */
};

struct led_control_device_t {
struct hw_device_t common;
/* supporting control APIs go here */
int (*getcount_led)(struct led_control_device_t *dev);
int (*set_on)(struct led_control_device_t *dev);
int (*set_off)(struct led_control_device_t *dev);
};

struct led_control_context_t {
struct led_control_device_t device;
};
led.c文件：
#define LOG_TAG "LedStub"

#include <hardware/hardware.h>

#include <fcntl.h>
#include <errno.h>

#include <cutils/log.h>
#include <cutils/atomic.h>

#include "../include/led.h"

static int led_device_close(struct hw_device_t* device)
{
struct led_control_context_t* ctx = (struct led_control_context_t*)device;
if (ctx) {
free(ctx);
}
return 0;
}

static int led_getcount(struct led_control_device_t *dev)
{
LOGI("led_getcount");
return 4;
}

static int led_set_on(struct led_control_device_t *dev)
{
//FIXME: do system call to control gpio led
LOGI("led_set_on");
return 0;
}

static int led_set_off(struct led_control_device_t *dev)
{
//FIXME: do system call to control gpio led
LOGI("led_set_off");
return 0;
}

static int led_device_open(const struct hw_module_t* module, const char* name,
struct hw_device_t** device)
{
struct led_control_context_t *context;

LOGD("led_device_open");

context = (struct led_control_context_t *)malloc(sizeof(*context));
memset(context, 0, sizeof(*context));

//HAL must init property
context->device.common.tag= HARDWARE_DEVICE_TAG;
context->device.common.version = 0;
context->device.common.module= module;
context->device.common.close = led_device_close;

//初始化控制API
context->device.set_on= led_set_on;
context->device.set_off= led_set_off;
context->device.getcount_led = led_getcount;

*device= (struct hw_device_t *)&(context->device);
return 0;
}

static struct hw_module_methods_t led_module_methods = {
open: led_device_open
};

const struct led_module_t HAL_MODULE_INFO_SYM = {
common: {
tag: HARDWARE_MODULE_TAG,
version_major: 1,
version_minor: 0,
id: LED_HARDWARE_MODULE_ID,
name: "led HAL module",
author: "gggggg",
methods: &led_module_methods,
},
/* supporting APIs go here */
};

Android.mk文件：
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_PRELINK_MODULE := false

LOCAL_SHARED_LIBRARIES := liblog

LOCAL_SRC_FILES := led.c

LOCAL_MODULE := led.goldfish

include $(BUILD_SHARED_LIBRARY)

三、在Eclipse中建一个工程使用我们编写的led stub。
1.定义两个类，源码如下：
Myhal.java文件：
package com.hello.MyHal;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.hello.LedService.LedService;;

public class Myhal extends Activity implements View.OnClickListener {

static LedService led_srv;

static Button btn;

static boolean iflag = false;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Log.i("Java App", "OnCreate");
led_srv = new LedService();
Log.i("Java App", "Load Java Serivce");

btn = (Button)this.findViewById(R.id.mybtn);
btn.setOnClickListener(this);
}

public void onClick(View v) {

Log.i("Java App", "btnOnClicked");
String title = new String();
if (iflag) {
title = led_srv.set_off();
btn.setText("Turn On");
setTitle(title);
iflag = false;
} else {
title = led_srv.set_on();
btn.setText("Turn Off");
setTitle(title);
iflag = true;
}
}
}

LedService.java文件：
package com.hello.LedService;

import android.util.Log;

public final class LedService {

/*
* load native service.
*/
static {
Log.i("Java Service", "Load Native Serivce LIB");
System.loadLibrary("led_runtime");
}

public LedService() {
int icount;
Log.i("Java Service", "do init Native Call");
_init();
icount = _get_count();
Log.d("Java Service", "Init OK ");
}

/*
* LED native methods.
*/
public String set_on() {
Log.i("com.hello.LedService", "LED On");
_set_on();
return "led on";
}

public String set_off() {
Log.i("com.hello.LedService", "LED Off");
_set_off();
return "led off";
}

/*
* declare all the native interface.
*/
private static native boolean _init();

private static native int _set_on();

private static native int _set_off();

private static native int _get_count();

}
其中LedService类通过native函数使用led stub提供的功能。

2.接下来我们实现通过jni接口实现native方法。
这里无需使用javah生成相应的头文件。
com_hello_LedService.cpp文件：
#define LOG_TAG "LedService"
#include "utils/Log.h"

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <jni.h>

#include "../../led_stub/include/led.h"

static led_control_device_t *sLedDevice = 0;
static led_module_t* sLedModule=0;

static int get_count(void)
{
return 0;
}

static jint led_setOn(JNIEnv* env, jobject thiz) {
//if (sLedDevice) {
LOGI("led_set_on");
sLedDevice->set_on(sLedDevice);
//}

return 0;
}

static jint led_setOff(JNIEnv* env, jobject thiz) {

//if (sLedDevice) {
LOGI("led_set_off");
sLedDevice->set_off(sLedDevice);
//}

return 0;
}

/** helper APIs */
static inline int led_control_open(const struct hw_module_t* module,
struct led_control_device_t** device) {

LOGI("led_control_ope");
return module->methods->open(module,
LED_HARDWARE_MODULE_ID, (struct hw_device_t**)device);
}

static jint led_init(JNIEnv *env, jclass clazz)
{
led_module_t const * module;
LOGI("led_init");

if (hw_get_module(LED_HARDWARE_MODULE_ID, (const hw_module_t**)&module) == 0) {
LOGI("get Module OK");
sLedModule = (led_module_t *) module;
if (led_control_open(&module->common, &sLedDevice) != 0) {
LOGI("led_init error");
return -1;
}
}

LOGI("led_init success");
return 0;
}

/*
* Array of methods.
*
* Each entry has three fields: the name of the method, the method
* signature, and a pointer to the native implementation.
*/
static const JNINativeMethod gMethods[] = {
{"_init", "()Z",
(void*)led_init},
{ "_set_on", "()I",
(void*)led_setOn },
{ "_set_off", "()I",
(void*)led_setOff },
{ "_get_count", "()I",
(void*)get_count },

};

static int registerMethods(JNIEnv* env) {
static const char* const kClassName =
"com/hello/LedService/LedService";
jclass clazz;

/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s\n", kClassName);
return -1;
}

/* register all the methods */
if (env->RegisterNatives(clazz, gMethods,
sizeof(gMethods) / sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s\n", kClassName);
return -1;
}

/* fill out the rest of the ID cache */
return 0;
}

/*
* This is called by the VM when the shared library is first loaded.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("JNI_OnLoad");

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed\n");
goto fail;
}
assert(env != NULL);

if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed\n");
goto fail;
}

/* success -- return valid version number */
result = JNI_VERSION_1_4;

fail:
return result;
}

Android.mk文件：
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

#LOCAL_MODULE_TAGS := eng

# This is the target being built.
LOCAL_MODULE:= libled_runtime

# All of the source files that we will compile.
LOCAL_SRC_FILES:= \
com_hello_LedService.cpp

# All of the shared libraries we link against.
LOCAL_SHARED_LIBRARIES := \
libandroid_runtime \
libnativehelper \
libcutils \
libutils \
libhardware

# No static libraries.
LOCAL_STATIC_LIBRARIES :=

# Also need the JNI headers.
LOCAL_C_INCLUDES += \
$(JNI_H_INCLUDE)
# No specia compiler flags.
LOCAL_CFLAGS +=

# Don't prelink this library. For more efficient code, you may want
# to add this library to the prelink map and set this to true.
LOCAL_PRELINK_MODULE := false

include $(BUILD_SHARED_LIBRARY)

将Led stub，LedService相关文件放到development/my_module分别make即可生成相应的so文件。使用adb push命令安装到虚拟机上运行即可。
文件组织机构如下：
a@ubuntu:~/work/android/source_android/development/my_module$ pwd
/home/a/work/android/source_android/development/my_module
a@ubuntu:~/work/android/source_android/development/my_module$ tree hal
hal
|-- LedService
| `-- jni
| |-- Android.mk
| `-- com_hello_LedService.cpp
`-- led_stub
|-- include
| `-- led.h
`-- module
|-- Android.mk
`-- led.c

6 directories, 7 files
四、编译运行中遇到的问题及解决方法：
1.usr/bin/ld: cannot find -lz
collect2: ld 返回 1
只是库命名的问题，简单的做了个软链接，一切搞定
ln -svf /lib/libz.so.1 /lib/libz.so
这个库文件与软连接的命名只差了一个.1
2.frameworks/base/tools/aidl/AST.cpp:10: error: 'fprintf' was not declared in this scope的错误
下载gcc-4.3和g++-4.3
apt-get install gcc-4.3 g++-4.3
大约十多兆，然后
进入/usr/bin
cd /usr/bin
建个软连接
ln -s gcc-4.3 gcc
ln -s g++-4.3 g++
33./bin/bash: flex：找不到命令
make: *** [out/host/linux-x86/obj/EXECUTABLES/aidl_intermediates/aidl_language_l.cpp] 错误 127
a@ubuntu:~/work/android/source_android$ sudo apt-get install flex
4.JNI的.so文件放到/system/lib下，而hal moudule需要放到/system/lib/hw下，且命名需符合约定，eg：led.goldfish.so。