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

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

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

我们现看看HAL stub的代码：

        
                
  1. intled_device_close(structhw_device_t*device)
    2.             
  2. {
    3.             
  3. structled_control_device_t*ctx=(structled_control_device_t*)device;
    4.             
  4. if(ctx){
    5.             
  5. free(ctx);
    6.             
  6. }
    7.             
  7. return0;
    8.             
  8. }
    9.             
    10.             
  10. intled_on(structled_control_device_t*dev,int32_tled)
    11.             
  11. {
    12.             
  12. LOGI("LEDStub:set%don.",led);
    13.             
  13. return0;
    14.             
  14. }
    15.             
    16.             
  16. intled_off(structled_control_device_t*dev,int32_tled)
    17.             
  17. {
    18.             
  18. LOGI("LEDStub:set%doff.",led);
    19.             
  19. return0;
    20.             
  20. }
    21.             
    22.             
  22. staticintled_device_open(conststructhw_module_t*module,constchar*name,
    23.             
  23. structhw_device_t**device)
    24.             
  24. {
    25.             
  25. structled_control_device_t*dev;
    26.             
    27.             
  27. dev=(structled_control_device_t*)malloc(sizeof(*dev));
    28.             
  28. memset(dev,0,sizeof(*dev));
    29.             
    30.             
  30. dev->common.tag=HARDWARE_DEVICE_TAG;
    31.             
  31. dev->common.version=0;
    32.             
  32. dev->common.module=module;
    33.             
  33. dev->common.close=led_device_close;
    34.             
    35.             
  35. dev->set_on=led_on;
    36.             
  36. dev->set_off=led_off;
    37.             
    38.             
  38. *device=&dev->common;
    39.             
    40.             
  40. success:
    41.             
  41. return0;
    42.             
  42. }
    43.             
    44.             
  44. staticstructhw_module_methods_tled_module_methods={
    45.             
  45. open:led_device_open
    46.             
  46. };
    47.             
    48.             
  48. conststructled_module_tHAL_MODULE_INFO_SYM={
    49.             
  49. common:{
    50.             
  50. tag:HARDWARE_MODULE_TAG,
    51.             
  51. version_major:1,
    52.             
  52. version_minor:0,
    53.             
  53. id:LED_HARDWARE_MODULE_ID,
    54.             
  54. name:"SampleLEDStub",
    55.             
  55. author:"TheMokoidOpenSourceProject",
    56.             
  56. methods:&led_module_methods,
    57.             
  57. }
    58.             
  58. /*supportingAPIsgohere*/
    59.             
  59. };
    60.

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

下面看看JNI层代码：

        
                
  1. structled_control_device_t*sLedDevice=NULL;
    2.             
    3.             
  3. staticjbooleanmokoid_setOn(JNIEnv*env,jobjectthiz,jintled)
    4.             
  4. {
    5.             
  5. LOGI("LedServiceJNI:mokoid_setOn()isinvoked.");
    6.             
    7.             
  7. if(sLedDevice==NULL){
    8.             
  8. LOGI("LedServiceJNI:sLedDevicewasnotfetchedcorrectly.");
    9.             
  9. return-1;
    10.             
  10. }else{
    11.             
  11. returnsLedDevice->set_on(sLedDevice,led);
    12.             
  12. }
    13.             
  13. }
    14.             
    15.             
  15. staticjbooleanmokoid_setOff(JNIEnv*env,jobjectthiz,jintled)
    16.             
  16. {
    17.             
  17. LOGI("LedServiceJNI:mokoid_setOff()isinvoked.");
    18.             
    19.             
    20.             
  20. if(sLedDevice==NULL){
    21.             
  21. LOGI("LedServiceJNI:sLedDevicewasnotfetchedcorrectly.");
    22.             
  22. return-1;
    23.             
  23. }else{
    24.             
  24. returnsLedDevice->set_off(sLedDevice,led);
    25.             
  25. }
    26.             
  26. }
    27.             
    28.             
  28. /**helperAPIs*/
    29.             
  29. staticinlineintled_control_open(conststructhw_module_t*module,
    30.             
  30. structled_control_device_t**device){
    31.             
  31. returnmodule->methods->open(module,
    32.             
  32. LED_HARDWARE_MODULE_ID,(structhw_device_t**)device);
    33.             
  33. }
    34.             
    35.             
  35. staticjbooleanmokoid_init(JNIEnv*env,jclassclazz)
    36.             
  36. {
    37.             
  37. led_module_t*module;
    38.             
    39.             
  39. if(hw_get_module(LED_HARDWARE_MODULE_ID,(consthw_module_t**)&module)==0){
    40.             
  40. LOGI("LedServiceJNI:LEDStubfound.");
    41.             
  41. if(led_control_open(&module->common,&sLedDevice)==0){
    42.             
  42. LOGI("LedServiceJNI:GotStuboperations.");
    43.             
  43. return0;
    44.             
  44. }
    45.             
  45. }
    46.             
    47.             
  47. LOGE("LedServiceJNI:GetStuboperationsfailed.");
    48.             
  48. return-1;
    49.             
  49. }
    50.             
    51.             
  51. staticconstJNINativeMethodgMethods[]={
    52.             
  52. {"_init","()Z",(void*)mokoid_init},
    53.             
  53. {"_set_on","(I)Z",(void*)mokoid_setOn},
    54.             
  54. {"_set_off","(I)Z",(void*)mokoid_setOff},
    55.             
  55. };
    56.             
    57.             
  57. intregister_mokoid_server_LedService(JNIEnv*env){
    58.             
  58. staticconstchar*constkClassName=
    59.             
  59. "com/mokoid/LedClient/LedClient";
    60.             
  60. jclassclazz;
    61.             
    62.             
  62. /*lookuptheclass*/
    63.             
  63. clazz=env->FindClass(kClassName);
    64.             
  64. if(clazz==NULL){
    65.             
  65. LOGE("Can'tfindclass%s\n",kClassName);
    66.             
  66. return-1;
    67.             
  67. }
    68.             
    69.             
  69. /*registerallthemethods*/
    70.             
  70. if(env->RegisterNatives(clazz,gMethods,
    71.             
  71. sizeof(gMethods)/sizeof(gMethods[0]))!=JNI_OK)
    72.             
  72. {
    73.             
  73. LOGE("Failedregisteringmethodsfor%s\n",kClassName);
    74.             
  74. return-1;
    75.             
  75. }
    76.             
    77.             
  77. /*fillouttherestoftheIDcache*/
    78.             
  78. return0;
    79.             
  79. }
    80.             
    81.             
  81. extern"C"jintJNI_OnLoad(JavaVM*vm,void*reserved)
    82.             
  82. {
    83.             
  83. JNIEnv*env=NULL;
    84.             
  84. jintresult=-1;
    85.             
    86.             
  86. if(vm->GetEnv((void**)&env,JNI_VERSION_1_4)!=JNI_OK){
    87.             
  87. LOGE("GetEnvfailed!");
    88.             
  88. returnresult;
    89.             
  89. }
    90.             
  90. LOG_ASSERT(env,"Couldnotretrievetheenv!");
    91.             
    92.             
  92. register_mokoid_server_LedService(env);
    93.             
    94.             
  94. returnJNI_VERSION_1_4;
    95.             
  95. }
    96.

上面的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程序使用。

最后是应用程序代码：

        
                
  1. publicclassLedClientextendsActivity{
    2.             
    3.             
  3. static{
    4.             
  4. System.load("/system/lib/libmokoid_runtime.so");
    5.             
  5. }
    6.             
    7.             
  7. @Override
    8.             
  8. publicvoidonCreate(BundlesavedInstanceState){
    9.             
  9. super.onCreate(savedInstanceState);
    10.             
    11.             
  11. //CallanAPIonthelibrary.
    12.             
  12. _init();
    13.             
  13. _set_on(1);
    14.             
  14. _set_off(2);
    15.             
    16.             
  16. TextViewtv=newTextView(this);
    17.             
  17. tv.setText("LED1ison.LED2isoff.");
    18.             
  18. setContentView(tv);
    19.             
  19. }
    20.             
  20. privatestaticnativeboolean_init();
    21.             
  21. privatestaticnativeboolean_set_on(intled);
    22.             
  22. privatestaticnativeboolean_set_off(intled);
    23.             
  23. }
    24.

上面使用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是如何实现的了。下一篇我们会介绍这种方法。

更多相关文章

  1. 使用ant让Android自动打包的build.xml,自动生成签名的apk文件(支
  2. Android中使用语音引擎入门七步曲
  3. Android(安卓)Studio酷炫插件（一）——自动化快速实现Parcelable接
  4. Android(安卓)APP设计加载使用gif动图需要注意的一般性问题
  5. android 安全讲座第四层 手机Root授权原理细节全解析(2)
  6. 【Android】Android(安卓)NDK开发扫盲及最新CMake的编译使用 so
  7. 箭头函数的基础使用
  8. NPM 和webpack 的基础使用
  9. Python list sort方法的具体使用

随机推荐

  1. Android ImageView的scaleType属性与adju
  2. 将Android封装库通过gradle部署到maven私
  3. 使用命令行签名Android应用程序
  4. ContentProvider和Uri详解
  5. Android中Handler小例子
  6. android之从Bmob获取数据显示在ListView
  7. Android 屏幕截图
  8. Awesome Adb——一份超全超详细的 ADB 用
  9. 如何防止android Toast重复显示？
  10. 动态修改Android参数信息的方法绕过改机