Android HAL 是如何被调用的-CFANZ编程社区

Android 对硬件的调用， google 推荐使用 HAL 的方式进行调用，对于 Andriod HAL 的写法，可以参考 android 源码里的 hardware 目录下几个模块的模版。

在看 HAL 的编写方法的过程中，会发现整个模块貌似没有一个入口。一般说来模块都要有个入口，比如应用程序有 main 函数，可以为加载器进行加载执行， dll 文件有 dllmain ，而对于我们自己写的动态链接库，我们可以对库中导出的任何符号进行调用。

问题来了， Android 中的 HAL 是比较具有通用性的，需要上层的函数对其进行加载调用， Android 的 HAL 加载器是如何实现对不同的 Hardware Module 进行通用性的调用的呢？

带着这个疑问查看 Android 源码，会发现 Android 中实现调用 HAL 是通过 hw_get_module 实现的。

int hw_get_module(const char *id, const struct hw_module_t **module);

这是其函数原型， id 会指定 Hardware 的 id ，这是一个字符串，比如 sensor 的 id 是

#define SENSORS_HARDWARE_MODULE_ID "sensors"

如果找到了对应的 hw_module_t 结构体，会将其指针放入 *module 中。看看它的实现。。。。

1.  
2.  for(i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {  
3.    if(i < HAL_VARIANT_KEYS_COUNT) {  
4.        //获取ro.hardware/ro.product.board/ro.board.platform/ro.arch等key的值。 
5.        if(property_get(variant_keys[i], prop, NULL) == 0) {  
6.            continue;  
7.        }  
8.        snprintf(path, sizeof(path), "%s/%s.%s.so",  
9.                HAL_LIBRARY_PATH, id, prop);  
10.         //如果开发板叫做mmdroid,那么这里的path就是system/lib/hw/sensor.mmdroid.so 
11.    } else{  
12.        snprintf(path, sizeof(path), "%s/%s.default.so",  
13.                HAL_LIBRARY_PATH, id);//默认会加载/system/lib/hw/sensor.default.so 
14.  
15.    }  
16.    if(access(path, R_OK)) {  
17.        continue;  
18.    }  
19.     
20.    break;  
21. }  
22. status = -ENOENT;  
23.  if(i < HAL_VARIANT_KEYS_COUNT+1) {  
24.     
25.    status = load(id, path, module);//调用load函数打开动态链接库 
26. }

获取了动态链接库的路径之后，就会调用 load 函数打开它，下面会打开它。奥秘在 load 中

1.  staticintload(constchar*id,  
2.        constchar*path,  
3.        conststructhw_module_t **pHmi)  
4. {  
5.    intstatus;  
6.    void*handle;  
7.    structhw_module_t *hmi;  
8.   
9.     
10.    handle = dlopen(path, RTLD_NOW);//打开动态库 
11.    if(handle == NULL) {  
12.        charconst*err_str = dlerror();  
13.        LOGE("load: module=%s/n%s", path, err_str?err_str:"unknown");  
14.        status = -EINVAL;  
15.        gotodone;  
16.    }  
17.   
18.     
19.    constchar*sym = HAL_MODULE_INFO_SYM_AS_STR;//被定义为了“HMI” 
20.    hmi = (structhw_module_t *)dlsym(handle, sym);//查找“HMI”这个导出符号，并获取其地址 
21.    if(hmi == NULL) {  
22.        LOGE("load: couldn't find symbol %s", sym);  
23.        status = -EINVAL;  
24.        gotodone;  
25.    }  
26.   
27.     
28.  //找到了hw_module_t结构！！！ 
29.    if(strcmp(id, hmi->id) != 0) {  
30.        LOGE("load: id=%s != hmi->id=%s", id, hmi->id);  
31.        status = -EINVAL;  
32.        gotodone;  
33.    }   
34.    hmi->dso = handle;  
35.       
36.    status = 0;  
37. done:  
38.    if(status != 0) {  
39.        hmi = NULL;  
40.        if(handle != NULL) {  
41.            dlclose(handle);  
42.            handle = NULL;  
43.        }  
44.    } else{  
45.        LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",  
46.                id, path, *pHmi, handle);  
47.    }  
48.  //凯旋而归 
49.    *pHmi = hmi;  
50.     returnstatus;  
51. }

从上面的代码中，会发现一个很奇怪的宏 HAL_MODULE_INFO_SYM_AS_STR ，它直接被定义为了

#define HAL_MODULE_INFO_SYM_AS_STR "HMI"

为何根据它就能从动态链接库中找到这个 hw_module_t 结构体呢？我们查看一下我们用到的 hal 对应的 so 就可以了，在 linux 中可以使用 readelf XX.so –s 查看。

1. Symbol table '.dynsym' contains 28 entries:  
2.   Num:    Value Size Type    Bind   Vis      Ndx Name  
3.     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND  
4.     1: 00000594     0 SECTION LOCAL  DEFAULT    7  
5.     2: 00001104     0 SECTION LOCAL  DEFAULT   13  
6.     3: 00000000     0 FUNC    GLOBAL DEFAULT  UND ioctl  
7.     4: 00000000     0 FUNC    GLOBAL DEFAULT  UND strerror  
8.     5: 00000b84     0 NOTYPE  GLOBAL DEFAULT  ABS __exidx_end  
9.     6: 00000000     0 OBJECT  GLOBAL DEFAULT  UND __stack_chk_guard  
10.     7: 00000000     0 FUNC    GLOBAL DEFAULT  UND __aeabi_unwind_cpp_pr0  
11.     8: 00000000     0 FUNC    GLOBAL DEFAULT  UND __errno  
12.     9: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS _bss_end__  
13.    10: 00000000     0 FUNC    GLOBAL DEFAULT  UND malloc  
14.    11: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start__  
15.    12: 00000000     0 FUNC    GLOBAL DEFAULT  UND __android_log_print  
16.    13: 00000b3a     0 NOTYPE  GLOBAL DEFAULT  ABS __exidx_start  
17.    14: 00000000     0 FUNC    GLOBAL DEFAULT  UND __stack_chk_fail  
18.    15: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_end__  
19.    16: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start  
20.    17: 00000000     0 FUNC    GLOBAL DEFAULT  UND memset  
21.    18: 00000000     0 FUNC    GLOBAL DEFAULT  UND __aeabi_uidiv  
22.    19: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS __end__  
23.    20: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS _edata  
24.    21: 00001188     0 NOTYPE  GLOBAL DEFAULT  ABS _end  
25.    22: 00000000     0 FUNC    GLOBAL DEFAULT  UND open  
26.    23: 00080000     0 NOTYPE  GLOBAL DEFAULT  ABS _stack  
27.    24: 00001104  128 OBJECT  GLOBAL DEFAULT   13 HMI  
28.    25: 00001104     0 NOTYPE  GLOBAL DEFAULT   13 __data_start  
29.    26: 00000000     0 FUNC    GLOBAL DEFAULT  UND close  
30.    27: 00000000     0 FUNC    GLOBAL DEFAULT  UND free

从上面中，第24个符号，名字就是“HMI”，对应于hw_module_t结构体。再去对照一下HAL的代码。

1.  
2.  structcopybit_module_t HAL_MODULE_INFO_SYM = {  
3.    common: {  
4.        tag: HARDWARE_MODULE_TAG,  
5.        version_major: 1,  
6.        version_minor: 0,  
7.        id: COPYBIT_HARDWARE_MODULE_ID,  
8.        name: "QCT MSM7K COPYBIT Module",  
9.        author: "Google, Inc.",  
10.        methods: ©bit_module_methods  
11.    }  
12. };

这里定义了一个名为 HAL_MODULE_INFO_SYM 的 copybit_module_t 的结构体， common 成员为 hw_module_t 类型。注意这里的 HAL_MODULE_INFO_SYM 变量必须为这个名字，这样编译器才会将这个结构体的导出符号变为“ HMI ”，这样这个结构体才能被 dlsym 函数找到！

综上，我们知道了 andriod HAL 模块也有一个通用的入口地址，这个入口地址就是 HAL_MODULE_INFO_SYM 变量，通过它，我们可以访问到 HAL 模块中的所有想要外部访问到的方法。