现在在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. android之如何使用Android的搜索框架
  2. Android(安卓)事件全局监听（二）需要root权限 ，使用getevent监听Andr
  3. Android(安卓)APK 签名比对，防止软件被破解使用
  4. Android(安卓)Studio怎样提示函数使用方法
  5. 史上最全的Android开发学习教程集锦【初学者】
  6. Android中微信主界面菜单栏的布局实现代码
  7. 箭头函数的基础使用
  8. NPM 和webpack 的基础使用
  9. Python list sort方法的具体使用

随机推荐

  1. Android热修复技术原理
  2. android framework层 学习笔记（二）
  3. Android——在SurfaceView上绘图
  4. Android第二周（第二部分）－listview
  5. 【开源框架】一个基于回调机制的多线程异
  6. html5游戏移植到android并打包成apk，加广
  7. 弹幕刷屏之术——Android无时间线弹幕实
  8. Android 软键盘监听事件
  9. Android(安卓)Studio 3.0 发行说明
  10. 异步任务——AsyncTask