转载.Android HAL实现的三种方式(1) - 基于JNI的简单HAL设计

现在在Android上的HAL开发总的来说还是随意性比较大，Android也并没有规范好一个具体的框架，下面我将根据Jollen的Mokoid工程，自己做了一些改动，分别给大家介绍一下三种实现方式。

这篇先介绍最简单的一种实现方式 - Java应用程序直接调用JNI库。

由于JNI技术的存在，在Android中，java程序能够很好的调用C/C++库。我们这里设计一个简单的HAL，一共只有三层： HAL stub <-> JNI 库 <-> JAVA应用程序。

我们现看看HAL stub的代码：

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

int led_on(struct led_control_device_t *dev, int32_t led)
{
    LOGI("LED Stub: set %d on.", led);
    return 0;
}

int led_off(struct led_control_device_t *dev, int32_t led)
{
    LOGI("LED Stub: set %d off.", led);
    return 0;
}

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

    dev = (struct led_control_device_t *)malloc(sizeof(*dev));
    memset(dev, 0, sizeof(*dev));

    dev->common.tag =  HARDWARE_DEVICE_TAG;
    dev->common.version = 0;
    dev->common.module = module;
    dev->common.close = led_device_close;

    dev->set_on = led_on;
    dev->set_off = led_off;

    *device = &dev->common;

success:
    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: "Sample LED Stub",
        author: "The Mokoid Open Source Project",
        methods: &led_module_methods,
    }
    /* supporting APIs go here */
};

我在前面关于HAL技术的文章中已经介绍了如何写HAL stub，需要注意的只有hw_module_t和hw_device_t这两个数据结构，这里就不复述了。

下面看看JNI层代码：

struct led_control_device_t *sLedDevice = NULL;

static jboolean mokoid_setOn(JNIEnv* env, jobject thiz, jint led)
{
    LOGI("LedService JNI: mokoid_setOn() is invoked.");

    if (sLedDevice == NULL) {
        LOGI("LedService JNI: sLedDevice was not fetched correctly.");
        return -1;
    } else {
        return sLedDevice->set_on(sLedDevice, led);
    }
}

static jboolean mokoid_setOff(JNIEnv* env, jobject thiz, jint led)
{
    LOGI("LedService JNI: mokoid_setOff() is invoked.");


    if (sLedDevice == NULL) {
        LOGI("LedService JNI: sLedDevice was not fetched correctly.");
        return -1;
    } else {
        return sLedDevice->set_off(sLedDevice, led);
    }
}

/** helper APIs */
static inline int led_control_open(const struct hw_module_t* module,
        struct led_control_device_t** device) {
    return module->methods->open(module,
            LED_HARDWARE_MODULE_ID, (struct hw_device_t**)device);
}

static jboolean mokoid_init(JNIEnv *env, jclass clazz)
{
    led_module_t* module;

    if (hw_get_module(LED_HARDWARE_MODULE_ID, (const hw_module_t**)&module) == 0) {
        LOGI("LedService JNI: LED Stub found.");
        if (led_control_open(&module->common, &sLedDevice) == 0) {
            LOGI("LedService JNI: Got Stub operations.");
            return 0;
        }
    }

    LOGE("LedService JNI: Get Stub operations failed.");
    return -1;
}

static const JNINativeMethod gMethods[] = {
    { "_init",      "()Z",  (void *)mokoid_init },
    { "_set_on",        "(I)Z", (void *)mokoid_setOn },
    { "_set_off",       "(I)Z", (void *)mokoid_setOff },
};

int register_mokoid_server_LedService(JNIEnv* env) {
    static const char* const kClassName =
        "com/mokoid/LedClient/LedClient";
    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;
}

extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;

    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        LOGE("GetEnv failed!");
        return result;
    }
    LOG_ASSERT(env, "Could not retrieve the env!");

    register_mokoid_server_LedService(env);

    return JNI_VERSION_1_4;
}

上面的Jni代码首先通过hw_get_module得到HAL stub，open以后就可以直接使用HAL stub中定义的接口。这里还需要注意JNI_OnLoad这个函数，当Jni库被App load的时候，该函数将会自动被调用，所以我们在这里实现了注册Led Service的操作，也就是说把C/C++的接口映射到Java中去，这样在Java APP中就可以使用该接口了。在register_mokoid_server_LedService中，我们需要注意kclassname指定了需要调用该Jni库的Java APP类 - com.mokoid.LedClient.LedClient，也就是说该Jni库只能提供给该Java程序使用。

最后是应用程序代码：

public class LedClient extends Activity {

    static {
        System.load("/system/lib/libmokoid_runtime.so");
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Call an API on the library.
        _init();
        _set_on(1);
        _set_off(2);

        TextView tv = new TextView(this);
        tv.setText("LED 1 is on. LED 2 is off.");
        setContentView(tv);
    }
    private static native boolean _init();
    private static native boolean _set_on(int led);
    private static native boolean _set_off(int led);
}

 上面使用System.load来装载Jni库，当然我们也可以使用System.loadLibrary来装载，他们的唯一区别就是前者需要指定完整的路径，后者会在系统路径上（比如/system/lib/) 查找库。装载完该Jni库后，就可以使用映射后的接口了（_init, _set_on, _set_off)。 

上面这种HAL的实现方式比较简单，但是也存在一个很大的问题，就是Jni库只能提供给某一个特定的Java使用，如何克服这个问题？我们可以在APP和Jni之间加一层Java service，该Jni提供给Java service使用，而所有的APP利用该service来使用Jni提供的接口。这样的话，在应用程序层，就不需要关心Jni是如何实现的了。下一篇我们会介绍这种方法。

本文出自 “Mobile and Linux Deve..” 博客，请务必保留此出处http://buaadallas.blog.51cto.com/399160/384622