devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android驱动程序开发实例精讲-0_Android系统HAL驱动开发经典案例详解（基于Android4.0）_cmd = atoi(argv[2]);

作者：AllinToyou | 2024-06-02 18:33:34

赞

踩

cmd = atoi(argv[2]);

Android系统HAL驱动开发经典案例详解（基于Android4.0）

 

目的：通过学习一个LED点灯的简单功能，掌握Linux驱动程序与HAL硬件抽象层之间的调用方法，同时掌握JNI层的编写思想，学会使用Eclipse编写Android应用程序，深入体会Android HAL架构。本章内容主要参考文献：《Android深度探索（卷1） HAL与驱动开发》、《TQ210开发板Android_HAL_LED_V1.2.pdf》

目录：

一、架构分析

1.1 功能介绍

1.2 HAL架构

1.3 接口定义

二、驱动程序

2.1 驱动功能简介

2.2 驱动源码分析

2.3 利用可执行文件测试驱动

2.3.1 源文件

2.3.2 利用交叉编译器编译

2.3.3 使用原生C程序测试驱动

三、HAL硬件抽象层

3.1 HAL简介

3.2 HAL层源码与分析

3.3 HAL源码编译

四、Jni/Service服务层

4.1 直接使用JNI调用驱动程序

4.2 JNI/Service程序代码

五、APP应用程序层

5.1 activity_main.xml

5.2 LedServer.java

5.3 MainActivity.java

 

一、架构分析

1.1 功能介绍

Linux版本：3.0.8

Android版本：4.0

开发板：FriendlyARM smart210

功能介绍：应用程序界面如下图所示，为求方便，截图来自模拟器，实际开发板界面和下图是一样的。CheckBox复选框分别对应开发板上四个LED灯，选中复选框，按动led_hal_jni按键后，相应LED就会亮起来。功能很简单，代码中几乎不会涉及任何逻辑算法，主要是为了方便理清整个程序架构，体会Android系统通过HAL硬件抽象层与实际硬件之间交互的编程思想。

 

 

1.2 HAL架构

想要点亮一个灯当然简单，可以直接烧写ARM裸机程序，也可以在跑Linux系统的板子上通过写/dev/leds这样的设备文件来达到目的。Android系统为了解决一些调用接口和版权方面的问题提出了一个HAL架构。目前最新的HAL架构是下面这个样子的。

 

 

可以看出，Android应用程序直接调用的是JNI或者Service程序库文件(.so)，程序库文件是通过一个ID来定位到相应的HAL的库文件(.so)，最终和硬件打交道的是HAL模块。需要注意的是，HAL及其以上层均属于应用程序范畴，也就是都运行在了用户空间，只有Linux驱动程序运行在了Linux内核空间。

 

1.3 接口定义

 

从Android HAL架构来看，一套完整的点灯的程序应该包括四个层次。为了方便程序维护，层与层之间应该尽可能的降低耦合程度，每个层对其他层开放的仅仅是一个操作接口即可。每个层的源文件位置和其向其他层提供的关键接口表述如下，这里指的关键接口实际上就是“调用函数”。各个源文件的具体内容会在下文给出。如果你能亲自动手写完整套程序再回过头来看这部分接口定义，应该能体会得更深些。

1、底层驱动。

源文件位置：$(linux_source)/drivers/char/mini210_led.c    

对应开发板上的驱动设备文件为：/dev/leds

关键接口定义：

//发送IO命令

ioctl(file_handler, cmd, arg);

//调用方法如下

./ioctl_test /dev/leds 1 2   //表示点亮第二盏灯

//发送写命令

write(fd,buf,strlen(buf));

//调用方法如下

./write_test /dev/s3c6410_leds "1111" // 点亮所有灯

这里的ioctl_test和write_test是两个可执行文件，它们分别是由ioctl_test.c和write_test.c源文件通过交叉编译器或Android原生代码编译出来的，这两个源文件是为了验证驱动程序专门写的，后文会贴出具体代码。

 

2、HAL层。

源文件位置：

//这个.c文件也可以放到其他目录

$(Android_source)/device/friendly-arm/mini210/libled/led_hal.c 

//这个.h文件最好放到指定位置，以免包含头文件的时候发生错误

$(Android_source)/hardware/libhardware/include/hardware/led_hal.h

生成模块位置：Android_source/out/target/product/mini210/lib/hw/led_hal.default.so

关键接口定义：

int led_on(struct led_control_device_t *dev, int32_t LED_NUMBER)  //表示LED_NUMBER灯亮

{

... ...

ioctl(fd,IOCTL_GPIO_ON,LED_NUMBER);

... ...

}

int led_off(struct led_control_device *dev, int32_t LED_NUMBER)   //表示LED_NUMBER灯灭

{

... ...

ioctl(fd,IOCTL_GPIO_OFF,LED_NUMBER);

... ...

}

 

3、jni/service层

源文件位置：$(Android_source)/packages/apps/led/jni/LedHalService.cpp

生成模块位置：Android_source/out/target/product/mini210/lib/libled_hal_jni.so

关键接口定义：

jboolean Java_com_example_leds_MainActivity_ledSetOn (JNIEnv* env, jobject obj,jint number)

{

... ...

return sLedDevice->set_on(sLedDevice,number);

... ...

}

jboolean Java_com_example_leds_MainActivity_ledSetOff (JNIEnv* env, jobject obj,jint number)

{

... ...

return sLedDevice->set_off(sLedDevice,number);

... ...

}

类名定义：

//注意这里的kClassName决定了调用该JNI模块的应用程序的包名与类名。

int register_android_server_LedService(JNIEnv *env)

{

... ...

static const char* const kClassName = "com/example/leds/LedService";

... ...

}

 

二、驱动程序

2.1 驱动功能简介

mini210_led.c主要提供了mini210_leds_ioctl和mini210_leds_write两个接口。应用程序通过向/dev/leds发送I/O指令或写命令就可以实现控制LED灯的功能了。

2.2 驱动源码分析

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <linux/kernel.h>
  2.  
  3. #include <linux/module.h>
  4.  
  5. #include <linux/miscdevice.h>
  6.  
  7. #include <linux/fs.h>
  8.  
  9. #include <linux/types.h>
  10.  
  11. #include <linux/moduleparam.h>
  12.  
  13. #include <linux/slab.h>
  14.  
  15. #include <linux/ioctl.h>
  16.  
  17. #include <linux/cdev.h>
  18.  
  19. #include <linux/delay.h>
  20.  
  21.  
  22.  
  23. #include <mach/gpio.h>
  24.  
  25. #include <mach/regs-gpio.h>
  26.  
  27. #include <plat/gpio-cfg.h>
  28.  
  29. #include <asm/uaccess.h>
  30.  
  31.  
  32.  
  33. #define DEVICE_NAME "leds"
  34.  
  35. static unsigned char mem[4];
  36.  
  37. static int led_gpios[] = {
  38.  
  39. S5PV210_GPJ2(0),
  40.  
  41. S5PV210_GPJ2(1),
  42.  
  43. S5PV210_GPJ2(2),
  44.  
  45. S5PV210_GPJ2(3),
  46.  
  47. };
  48.  
  49.  
  50.  
  51. #define LED_NUM ARRAY_SIZE(led_gpios)
  52.  
  53.  
  54.  
  55. //mini210_leds_ioctl函数实现了发送IO控制命令
  56.  
  57. static long mini210_leds_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  58.  
  59. {
  60.  
  61. switch(cmd) {
  62.  
  63. case 0:
  64.  
  65. case 1:
  66.  
  67. if (arg > LED_NUM) {
  68.  
  69. return -EINVAL;
  70.  
  71. }
  72.  
  73.  
  74.  
  75. gpio_set_value(led_gpios[arg], !cmd);
  76.  
  77. //printk(DEVICE_NAME": %d %d\n", arg, cmd);
  78.  
  79. break;
  80.  
  81.  
  82.  
  83. default:
  84.  
  85. return -EINVAL;
  86.  
  87. }
  88.  
  89.  
  90.  
  91. return 0;
  92.  
  93. }
  94.  
  95. //mini210_leds_write函数实现了写文件命令
  96.  
  97. ssize_t mini210_leds_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
  98.  
  99. {
  100.  
  101. int i=0;
  102.  
  103. int tmp=count;
  104.  
  105. memset(mem,0,4);
  106.  
  107. if(count>4)
  108.  
  109. {
  110.  
  111. tmp=4;
  112.  
  113. }
  114.  
  115. if(copy_from_user(mem,buf,tmp))
  116.  
  117. {
  118.  
  119. return -EFAULT;
  120.  
  121. }
  122.  
  123.  
  124.  
  125. for(i=0;i<4;i++)
  126.  
  127. {
  128.  
  129. if(mem[i]=='1')
  130.  
  131. {
  132.  
  133. gpio_set_value(led_gpios[i], 0);
  134.  
  135. }
  136.  
  137. else if(mem[i]=='0')
  138.  
  139. {
  140.  
  141. gpio_set_value(led_gpios[i], 1);
  142.  
  143. }
  144.  
  145. }
  146.  
  147. return count;
  148.  
  149. }
  150.  
  151. static struct file_operations mini210_led_dev_fops = {
  152.  
  153. .owner = THIS_MODULE,
  154.  
  155. .unlocked_ioctl = mini210_leds_ioctl,
  156.  
  157. .write                    = mini210_leds_write,
  158.  
  159. };
  160.  
  161.  
  162.  
  163. static struct miscdevice mini210_led_dev = {
  164.  
  165. .minor = MISC_DYNAMIC_MINOR,
  166.  
  167. .name = DEVICE_NAME,
  168.  
  169. .fops = &mini210_led_dev_fops,
  170.  
  171. };
  172.  
  173.  
  174.  
  175. static int __init mini210_led_dev_init(void) {
  176.  
  177. int ret;
  178.  
  179. int i;
  180.  
  181.  
  182.  
  183. for (i = 0; i < LED_NUM; i++) {
  184.  
  185. ret = gpio_request(led_gpios[i], "LED");
  186.  
  187. if (ret) {
  188.  
  189. printk("%s: request GPIO %d for LED failed, ret = %d\n", DEVICE_NAME,
  190.  
  191. led_gpios[i], ret);
  192.  
  193. return ret;
  194.  
  195. }
  196.  
  197.  
  198.  
  199. s3c_gpio_cfgpin(led_gpios[i], S3C_GPIO_OUTPUT);
  200.  
  201. gpio_set_value(led_gpios[i], 1);
  202.  
  203. }
  204.  
  205.  
  206.  
  207. ret = misc_register(&mini210_led_dev);
  208.  
  209.  
  210.  
  211. printk(DEVICE_NAME"\tinitialized\n");
  212.  
  213.  
  214.  
  215. return ret;
  216.  
  217. }
  218.  
  219.  
  220.  
  221. static void __exit mini210_led_dev_exit(void) {
  222.  
  223. int i;
  224.  
  225.  
  226.  
  227. for (i = 0; i < LED_NUM; i++) {
  228.  
  229. gpio_free(led_gpios[i]);
  230.  
  231. }
  232.  
  233.  
  234.  
  235. misc_deregister(&mini210_led_dev);
  236.  
  237. }
  238.  
  239.  
  240.  
  241. module_init(mini210_led_dev_init);
  242.  
  243. module_exit(mini210_led_dev_exit);
  244.  
  245.  
  246.  
  247. MODULE_LICENSE("GPL");</span>

 

2.3 利用可执行文件测试驱动

 

2.3.1 源文件

首先给出两个可执行文件的源文件

//ioctl_test.c

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <fcntl.h>
  2.  
  3. #include <stdio.h>
  4.  
  5. #include <stdlib.h>
  6.  
  7. #include <sys/ioctl.h>  
  8.  
  9. /*
  11. * ./ioctl_test /dev/leds 1 2  //表示将第二个灯点亮 
  13. */
  14.  
  15. int main(int argc, char **argv)
  16.  
  17. {
  18.  
  19. int file_handler = 0;
  20.  
  21. int cmd = 0;
  22.  
  23. int arg = 0;
  24.  
  25. if(argc < 4)
  26.  
  27. {
  28.  
  29. printf("Usage: ioctl <dev_file> <cmd> <arg>\n");
  30.  
  31. return 0;
  32.  
  33. }
  34.  
  35. cmd = atoi(argv[2]);
  36.  
  37. arg = atoi(argv[3]);
  38.  
  39. printf("dev:%s\n", argv[1]);
  40.  
  41. printf("cmd:%d\n", cmd);
  42.  
  43. printf("arg:%d\n", arg);
  44.  
  45. file_handler = open(argv[1], 0);
  46.  
  47.  
  48.  
  49. ioctl(file_handler, cmd, arg);
  50.  
  51. close(file_handler);
  52.  
  53. return 0;
  54.  
  55. }</span>

 

 

//write_test.c

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <unistd.h>
  2.  
  3. #include <sys/types.h>
  4.  
  5. #include <sys/stat.h>
  6.  
  7. #include <fcntl.h>
  8.  
  9. #include <stdio.h>
  10.  
  11. #include <string.h>
  12.  
  13. /*
  15. * ./write_test /dev/s3c6410_leds "1111" 表示四个灯全亮
  17. */
  18.  
  19. void main(int argc, char *argv[])
  20.  
  21. {
  22.  
  23. int fd;
  24.  
  25. char *buf;
  26.  
  27. buf=argv[2];
  28.  
  29. fd=open(argv[1],O_WRONLY);
  30.  
  31. if(fd<0)
  32.  
  33. {
  34.  
  35. printf("file_open failed!\n");
  36.  
  37. return;
  38.  
  39. } 
  40.  
  41. write(fd,buf,strlen(buf));
  42.  
  43. close(fd);
  44.  
  45. }</span>

源文件的内容比较简单，不再深入讨论。Android系统有两种编译可执行程序的方法，下面分别介绍。

2.3.2 利用交叉编译器编译

这种方法比较容易实现。直接在命令行模式下编译即可。需要注意的是最好加上静态编译选项“-static”。

Pc:#arm-linux-gcc -static ioctl_test.c -o ioctl_test

Pc:#arm-linux-gcc -static write_test.c -o write_test

然后利用adb命令将可执行文件上传到开发板

Pc:# adb push ioctl_test write_test /data/local

 

进入开发板的命令行终端

Pc:# adb shell

然后就可以执行可执行文件了

Phone#: cd /data/local

Phone:# ./ioctl_test /dev/leds 1 2

Phone:#./write_test /dev/leds “1111”

 

2.3.3 使用原生C程序测试驱动

这种方式更加地道，其编译方式是通过Android源代码直接编译的。所使用的工具就是Android系统自带的编译器以及一些Android系统的头文件，所以编译之前一定确保自己的电脑上已经成功编译了一套Android系统。至于如何编译Android系统，网上有很多教程，难点就是编译的过程中会出现一些莫名其妙的错误，往往是少安装了某些库造成的，耐着性子上网查查一般就能解决。

接下来以ioctl_test为例讲解如何使用原生C程序测试驱动。首先一定要在Android系统源代码目录或子目录下为ioctl_test应用程序单独建立一个文件夹，作为其主目录。然后在ioctrl_test.c的主目录下新建一个Android.mk文件，内容如下：

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">LOCAL_PATH:=$(call my-dir)
  2.  
  3. include $(CLEAR_VARS)
  4.  
  5. LOCAL_SRC_FILES:=ioctl_test.c
  6.  
  7. LOCAL_MODULE:=ioctl_test
  8.  
  9. LOCAL_MODULE_TAGS:=optional
  10.  
  11. include $(BUILD_EXECUTABLE)</span>

Android.mk其实就相当与Android系统中的Makefile文档，就是给出了一些编译选项，需要执行mm命令或mmm命令进行编译。关于Android.mk的书写规则，网上有很多，看看就知道了。

在使用mm命令之前，一定确保首先在Android系统源代码下执行：

Pc:# source ./build/envsetup.sh  执行后会出现类似下面的信息。

including device/friendly-arm/mini210/vendorsetup.sh

including device/moto/stingray/vendorsetup.sh

including device/moto/wingray/vendorsetup.sh

including device/samsung/crespo4g/vendorsetup.sh

including device/samsung/crespo/vendorsetup.sh

including device/samsung/maguro/vendorsetup.sh

including device/samsung/toro/vendorsetup.sh

including device/samsung/tuna/vendorsetup.sh

including device/ti/panda/vendorsetup.sh

including sdk/bash_completion/adb.bash

 

这个envsetup.sh就是包含自定义的vendorsetup.sh和初始化mm等命令用的（插一句题外话，如果你想从官方的Android源码定制适合自己开发板的Android系统的话，通常需要自己写一个新的vendorsetup.sh文件）。注意的是，每次启动一个新的Linux命令终端，好像都要重新运行source ./build/envsetup.sh，否则mm命令不能用。

然后执行lunch

Pc:# lunch  

You're building on Linux

 

Lunch menu... pick a combo:

     1. full-eng

     2. full_x86-eng

     3. vbox_x86-eng

     4. full_mini210-userdebug

     5. full_stingray-userdebug

     6. full_wingray-userdebug

     7. full_crespo4g-userdebug

     8. full_crespo-userdebug

     9. full_maguro-userdebug

     10. full_toro-userdebug

     11. full_tuna-userdebug

     12. full_panda-eng

 

Which would you like? [full-eng] 4

在这里选择4。同样的，每次运行完source ./build/envsetup.sh之后也要重新运行lunch命令，否则系统仍会默认以full-eng的方式进行编译。当你编译ioctl_test.c这样的Android应用程序的时候就会出现类似下面的错误。

make: Entering directory `/home/zbl/Android/MySystem/3_Android_resource/android-4.0.3_r1'

make: *** No rule to make target `out/target/product/generic/obj/lib/crtbegin_dynamic.o', needed by `out/target/product/generic/obj/EXECUTABLES/ioctl_test_intermediates/LINKED/ioctl_test'.  Stop.

make: Leaving directory `/home/zbl/Android/MySystem/3_Android_resource/android-4.0.3_r1'

一定要选择full_mini210-userdebug。然后会出现下面的信息。

============================================

PLATFORM_VERSION_CODENAME=REL

PLATFORM_VERSION=4.0.3

TARGET_PRODUCT=full_mini210

TARGET_BUILD_VARIANT=userdebug

TARGET_BUILD_TYPE=release

TARGET_BUILD_APPS=

TARGET_ARCH=arm

TARGET_ARCH_VARIANT=armv7-a-neon

HOST_ARCH=x86

HOST_OS=linux

HOST_BUILD_TYPE=release

BUILD_ID=IML74K

============================================

 

好了，最后然后进入到ioctl_test.c的主目录中执行：

Pc:#mm

============================================

PLATFORM_VERSION_CODENAME=REL

PLATFORM_VERSION=4.0.3

TARGET_PRODUCT=full_mini210

TARGET_BUILD_VARIANT=userdebug

TARGET_BUILD_TYPE=release

TARGET_BUILD_APPS=

TARGET_ARCH=arm

TARGET_ARCH_VARIANT=armv7-a-neon

HOST_ARCH=x86

HOST_OS=linux

HOST_BUILD_TYPE=release

BUILD_ID=IML74K

============================================

make: Entering directory `/home/zbl/Android/MySystem/3_Android_resource/android-4.0.3_r1'

target thumb C: ioctl_test <= /work/MySystem/3_Android_resource/android-4.0.3_r1/ioctl_test/ioctl_test.c

target Executable: ioctl_test (out/target/product/mini210/obj/EXECUTABLES/ioctl_test_intermediates/LINKED/ioctl_test)

target Symbolic: ioctl_test (out/target/product/mini210/symbols/system/bin/ioctl_test)

target Strip: ioctl_test (out/target/product/mini210/obj/EXECUTABLES/ioctl_test_intermediates/ioctl_test)

Install: out/target/product/mini210/system/bin/ioctl_test

make: Leaving directory `/home/zbl/Android/MySystem/3_Android_resource/android-4.0.3_r1'

从编译结果可以看出，编译出的可执行文件ioctl_test被放在了out/target/product/mini210/system/bin/文件下。按照2.3.2的方法将其上传到开发板后即可使用。

 

三、HAL硬件抽象层

3.1 HAL简介

Google为Android加入HAL主要有如下目的。

Ø 统一硬件的调用接口。由于HAL有标准的调用接口，可以利用HAL屏蔽Linux驱动复杂、不统一的接口。

Ø 解决了GPL版权问题。Android系统基于Apache Licence2.0协议。可以让那些不想开源的驱动作者屏蔽源代码。这是基于GPL开源协议的Linux系统所不允许的。所以Linux毫不客气的将Android系统开除族籍了。

Ø 访问用户空间资源。对于有些硬件，可能需要访问一些用户空间的资源，或在内核空间不方便完成的工作以及特殊需要。在这种情况下，可以利用位于用户空间的HAL代码来辅助Linux驱动完成一些工作。

在编写HAL层程序的时候要时刻注意HAL是运行在用户空间的，这有助于理解HAL层的设计思想。HAL（硬件抽象层）的诞生意味着Android系统被Linux大家族给剔除了。原因其实就是HAL层可以不开源。

3.2 HAL层源码与分析

撰写HAL程序关键之处在于3个重要的结构体。分别是描述HAL模块的hw_module_t结构体；描述HAL设备的hw_device_t结构体；描述模块入口函数的hw_module_methods_t结构体。

首先给出头文件led_hal.h

//led_hal.h

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#ifndef ANDROID_LED_INTERFACE_H
  2.  
  3. #define ANDROID_LED_INTERFACE_H
  4.  
  5. #include <stdint.h>
  6.  
  7. #include <sys/cdefs.h>
  8.  
  9. #include <sys/types.h>
  10.  
  11. #include <hardware/hardware.h>
  12.  
  13. #include <fcntl.h>
  14.  
  15. #include <errno.h>
  16.  
  17. #include <math.h>
  18.  
  19. #include <poll.h>
  20.  
  21. #include <unistd.h>
  22.  
  23. #include <dirent.h>
  24.  
  25. #include <sys/select.h>
  26.  
  27. #include <cutils/log.h>
  28.  
  29.  
  30.  
  31. __BEGIN_DECLS
  32.  
  33. /*下面这个ID重要的很，Jni/Service层主要通过它来寻找相应的HAL库文件(.so)，所以HAL源文件的名字是可以随便改的，只要保证其中的ID值不变即可*/
  34.  
  35. #define LED_HARDWARE_MODULE_ID "led_hal"  
  36.  
  37.  
  38.  
  39. /*HAL规定不能直接使用hw_module_t结构体，需要在hw_modult_t外再套一层结构体。hw_module_t结构体表示HAL模块的相关信息，成员变量可以随便起，但是hw_module_t结构体必须是led_module_t结构体的第1个成员变量的数据类型。这个东西是整个HAL的核心，后续的工作其实就是不断的完善这个module。*/
  40.  
  41. struct led_module_t
  42.  
  43. {
  44.  
  45. struct hw_module_t common;
  46.  
  47. };
  48.  
  49.  
  50.  
  51. #define IOCTL_GPIO_ON 1
  52.  
  53. #define IOCTL_GPIO_OFF 0
  54.  
  55.  
  56.  
  57. /*led_control_device_t是自定义的hw_device_t类型的结构体，但是hw_device_t必须是该结构体的第一个成员变量，另外还定义了两个控制LED的成员函数*/
  58.  
  59. struct led_control_device_t
  60.  
  61. {
  62.  
  63. struct hw_device_t common;
  64.  
  65. int (*set_on)(struct led_control_device_t* dev, int32_t LED_NUMBER);
  66.  
  67. int (*set_off)(struct led_control_device_t* dev, int32_t LED_NUMBER);
  68.  
  69. };
  70.  
  71. __END_DECLS
  72.  
  73. #endif         //ANDROID_LED_INTERFACE_H</span>

/

Led_hal.c文件是HAL层的源文件，我在每个函数前都做了注解，其编号是按照代码书写顺序标注的。也就是说，HAL代码的编写顺序并不是自上而下一行一行写出来的，而是类似于驱动程序的形式，先从接口程序开始写，然后一层一层的把用到的函数补充出来。

 

//Led_hal.c

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <hardware/led_hal.h>
  2.  
  3. char const * const LED_DEVICE = "/dev/leds";
  4.  
  5. static int fd = -1;
  6.  
  7. /*4、打开设备文件，这里的open函数就是运行在了用户空间*/
  8.  
  9. static int open_led()
  10.  
  11. {
  12.  
  13. if((fd = open(LED_DEVICE,O_RDWR))==-1)
  14.  
  15. {
  16.  
  17. LOGV("LED stub: open %s failed\n",LED_DEVICE);
  18.  
  19. return -1;
  20.  
  21. }
  22.  
  23. else
  24.  
  25. {LOGV("LED stub: open %s successed\n",LED_DEVICE);}
  26.  
  27. return 1;
  28.  
  29. }
  30.  
  31. /*5、关闭设备，没什么说的*/
  32.  
  33. static int close_led(struct hw_device_t *dev)
  34.  
  35. {
  36.  
  37. LOGV("close_light is called");
  38.  
  39. if(fd!=-1)
  40.  
  41. {
  42.  
  43. close(fd);
  44.  
  45. if(dev)
  46.  
  47. free(dev);
  48.  
  49. }
  50.  
  51. return 0;
  52.  
  53. }
  54.  
  55. /*6、ioctl(fd,IOCTL_GPIO_ON,LED_NUMBER)运行在了用户空间*/
  56.  
  57. int led_on(struct led_control_device_t *dev, int32_t LED_NUMBER)
  58.  
  59. {
  60.  
  61. if(fd == -1)
  62.  
  63. return -1;
  64.  
  65. return ioctl(fd,IOCTL_GPIO_ON,LED_NUMBER);
  66.  
  67. }
  68.  
  69. /*7、ioctl(fd,IOCTL_GPIO_OFF,LED_NUMBER)运行在了用户空间*/
  70.  
  71. int led_off(struct led_control_device *dev, int32_t LED_NUMBER)
  72.  
  73. {
  74.  
  75. if(fd == -1)
  76.  
  77. return -1;
  78.  
  79. return ioctl(fd,IOCTL_GPIO_OFF,LED_NUMBER);
  80.  
  81. }
  82.  
  83. /*3、初始化设备文件*/
  84.  
  85. static int led_init(const struct hw_module_t* module, const char* name, struct hw_device_t** device)
  86.  
  87. {
  88.  
  89. struct led_control_device_t *dev;
  90.  
  91. /*为led_control_device结构体分配内存空间*/
  92.  
  93. dev = (struct led_control_device_t *)malloc(sizeof(*dev));
  94.  
  95. if(dev==NULL)
  96.  
  97. return 0;
  98.  
  99. memset(dev,0,sizeof(*dev));
  100.  
  101. dev->common.tag = HARDWARE_DEVICE_TAG;
  102.  
  103. dev->common.version = 0;
  104.  
  105. dev->common.module = (struct hw_module_t*)module;
  106.  
  107. //dev->common.close = (int (*)(struct hw_device_t *))close_led;
  108.  
  109. dev->common.close = close_led;
  110.  
  111. //设置打开LED的函数指针
  112.  
  113. dev->set_on = led_on;
  114.  
  115. //设置关闭LED的函数指针
  116.  
  117. dev->set_off = led_off; 
  118.  
  119.  
  120.  
  121. *device = (struct hw_device_t *)&dev->common;
  122.  
  123. if(open_led() == -1)
  124.  
  125. {
  126.  
  127. free(dev);
  128.  
  129. dev = NULL;
  130.  
  131. return -1;
  132.  
  133. }
  134.  
  135. return 0;
  136.  
  137. }
  138.  
  139. /*2、hw_module_methods_t中定义了打开设备的open函数的指针。也就是在这个函数中进行了一些列的初始化工作*/
  140.  
  141. static struct hw_module_methods_t led_module_methods={
  142.  
  143. open: led_init
  144.  
  145. };
  146.  
  147. /*1、HAL_MODULE_INFO_SYM才是HAL真正的入口，这里面最重要的两个参数是id: LED_HARDWARE_MODULE_ID和methods: &led_module_methods*/
  148.  
  149. struct led_module_t HAL_MODULE_INFO_SYM={
  150.  
  151. common:
  152.  
  153. {
  154.  
  155. tag: HARDWARE_MODULE_TAG,
  156.  
  157. version_major: 1,
  158.  
  159. version_minor: 0,
  160.  
  161. id: LED_HARDWARE_MODULE_ID,
  162.  
  163. name: "sample led hal stub",
  164.  
  165. author: "xxx",
  166.  
  167. methods: &led_module_methods,
  168.  
  169. }
  170.  
  171. };</span>

 

 

3.3 HAL源码编译

//Android.mk

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">LOCAL_PATH:= $(call my-dir)
  2.  
  3. # HAL module implemenation stored in
  4.  
  5. # hw/<COPYPIX_HARDWARE_MODULE_ID>.<ro.board.platform>.so
  6.  
  7. include $(CLEAR_VARS)
  8.  
  9. LOCAL_PRELINK_MODULE := false
  10.  
  11. LOCAL_SRC_FILES := led_hal.c
  12.  
  13. LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
  14.  
  15. #LOCAL_SHARED_LIBRARIES := liblog
  16.  
  17. LOCAL_MODULE := led_hal.default
  18.  
  19. #LOCAL_MODULE := led_hal.$(TARGET_BOARD_PLATFORM)
  20.  
  21. LOCAL_MODULE_TAGS := optional
  22.  
  23. include $(BUILD_SHARED_LIBRARY)</span>

编译出来的led_hal.default.so模块保存在了$(Android_source)/out/target/produce/mini210/system/lib/hw中。将之上传到开发板中相应的/system/lib/hw文件夹中即可。

 

四、Jni/Service服务层

 

这一层的主要任务就是调用HAL层的程序库，并为上层应用程序层提供调用接口。

4.1 直接使用JNI调用驱动程序

在Java中是可以写C/C++代码的，虽然并不是100%的C/C++语言，但只需要改动一下数据类型的标志并注意一些新定义的用法即可。我们常把C/C++代码称之为原生代码，如果不是特别讲究叫法的话，在Java体系中还可以勉为其难的称之为JNI或NDK，其实JNI和NDK意义并不同，首先介绍一下JNI和NDK的区别。

JNI是java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI 是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。

 

NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动态库，并能自动将so和java应用一起打包成apk。这些工具对开发者的帮助是巨大的。它集成了交叉编译器，并提供了相应的mk文件隔离CPU、平台、ABI等差异，开发人员只需要简单修改mk文件（指出“哪些文件需要编译”、“编译特性要求”等），就可以创建出so。它可以自动地将so和Java应用一起打包，极大地减轻了开发人员的打包工作。

所以可以简单的理解为JNI是接口，NDK是工具。

在涉及到操作硬件的思路上，我们其实可以直接通过Java程序去调用驱动程序，Java程序提供了File.write(str)这样的写函数操作类，所以可以直接向/dev/leds设备驱动文件中写数据。不过Java并没有提供ioctl这样的发送IO控制命令的函数。如果就想发送IO控制命令该怎么办？可以通过JNI层来调用C/C++语言实现。

先给出完成后的操作界面。

 

然后直接贴出各个源文件。

//activity_main.xml

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;"><?xml version="1.0" encoding="utf-8"?>
  2.  
  3. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  4.  
  5.     android:layout_width="fill_parent"
  6.  
  7.     android:layout_height="fill_parent"
  8.  
  9.     android:orientation="vertical" >
  10.  
  11.     <LinearLayout
  12.  
  13.         android:layout_width="fill_parent"
  14.  
  15.         android:layout_height="wrap_content"
  16.  
  17.         android:orientation="horizontal" >
  18.  
  19.  
  20.  
  21.         <CheckBox
  22.  
  23.             android:id="@+id/checkbox_str_led1"
  24.  
  25.             android:layout_width="wrap_content"
  26.  
  27.             android:layout_height="wrap_content"
  28.  
  29.             android:text="LED1" />
  30.  
  31.  
  32.  
  33.         <CheckBox
  34.  
  35.             android:id="@+id/checkbox_str_led2"
  36.  
  37.             android:layout_width="wrap_content"
  38.  
  39.             android:layout_height="wrap_content"
  40.  
  41.             android:text="LED2" />
  42.  
  43.  
  44.  
  45.         <CheckBox
  46.  
  47.             android:id="@+id/checkbox_str_led3"
  48.  
  49.             android:layout_width="wrap_content"
  50.  
  51.             android:layout_height="wrap_content"
  52.  
  53.             android:text="LED3" />
  54.  
  55.  
  56.  
  57.         <CheckBox
  58.  
  59.             android:id="@+id/checkbox_str_led4"
  60.  
  61.             android:layout_width="wrap_content"
  62.  
  63.             android:layout_height="wrap_content"
  64.  
  65.             android:text="LED4" />
  66.  
  67.     </LinearLayout>
  68.  
  69.  
  70.  
  71.     <Button
  72.  
  73.         
  74.  
  75.         android:layout_width="fill_parent"
  76.  
  77.         android:layout_height="wrap_content"
  78.  
  79.         android:onClick="onClick_write"
  80.  
  81.         android:text="write_test" />
  82.  
  83.     <LinearLayout
  84.  
  85.         android:layout_width="fill_parent"
  86.  
  87.         android:layout_height="wrap_content"
  88.  
  89.         android:orientation="horizontal" >
  90.  
  91.  
  92.  
  93.         <CheckBox
  94.  
  95.             android:id="@+id/checkbox_cmd_led1"
  96.  
  97.             android:layout_width="wrap_content"
  98.  
  99.             android:layout_height="wrap_content"
  100.  
  101.             android:text="LED1" />
  102.  
  103.  
  104.  
  105.         <CheckBox
  106.  
  107.             android:id="@+id/checkbox_cmd_led2"
  108.  
  109.             android:layout_width="wrap_content"
  110.  
  111.             android:layout_height="wrap_content"
  112.  
  113.             android:text="LED2" />
  114.  
  115.  
  116.  
  117.         <CheckBox
  118.  
  119.             android:id="@+id/checkbox_cmd_led3"
  120.  
  121.             android:layout_width="wrap_content"
  122.  
  123.             android:layout_height="wrap_content"
  124.  
  125.             android:text="LED3" />
  126.  
  127.  
  128.  
  129.         <CheckBox
  130.  
  131.             android:id="@+id/checkbox_cmd_led4"
  132.  
  133.             android:layout_width="wrap_content"
  134.  
  135.             android:layout_height="wrap_content"
  136.  
  137.             android:text="LED4" />
  138.  
  139.     </LinearLayout>
  140.  
  141.  
  142.  
  143.     <Button
  144.  
  145.         
  146.  
  147.         android:layout_width="fill_parent"
  148.  
  149.         android:layout_height="wrap_content"
  150.  
  151.         android:onClick="onClick_ioctl"
  152.  
  153.         android:text="ioctl_test" />
  154.  
  155.  
  156.  
  157.     <TextView
  158.  
  159.         android:id="@+id/textView"
  160.  
  161.         android:layout_width="wrap_content"
  162.  
  163.         android:layout_height="wrap_content"
  164.  
  165.         android:text="TextView" />
  166.  
  167.  
  168.  
  169. </LinearLayout></span>

 

// jni/leds.c

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <string.h>
  2.  
  3. #include <stdio.h>
  4.  
  5. #include <jni.h>
  6.  
  7. #include <fcntl.h>
  8.  
  9. #include <sys/types.h>
  10.  
  11. #include <sys/stat.h>
  12.  
  13. #include <unistd.h>
  14.  
  15. #include <stdlib.h>
  16.  
  17. jstring Java_com_example_leds1_MainActivity_getText (JNIEnv* env, jobject obj)
  18.  
  19. {
  20.  
  21.     return (*env)->NewStringUTF(env, "Test Android NDK!Test My NDK!");
  22.  
  23. }
  24.  
  25.  
  26.  
  27. char* jstring_to_pchar(JNIEnv* env, jstring str)
  28.  
  29. {
  30.  
  31. char* pstr = NULL;
  32.  
  33. jclass clsstring = (*env)->FindClass(env, "java/lang/String");
  34.  
  35. jstring strencode = (*env)->NewStringUTF(env, "utf-8");
  36.  
  37. jmethodID mid = (*env)->GetMethodID(env, clsstring, "getBytes",
  38.  
  39.         "(Ljava/lang/String;)[B");
  40.  
  41. jbyteArray byteArray = (jbyteArray)(
  42.  
  43.         (*env)->CallObjectMethod(env, str, mid, strencode));
  44.  
  45. jsize size = (*env)->GetArrayLength(env, byteArray);
  46.  
  47. jbyte* pbyte = (*env)->GetByteArrayElements(env, byteArray, JNI_FALSE);
  48.  
  49. if (size > 0)
  50.  
  51. {
  52.  
  53. pstr = (char*) malloc(size);
  54.  
  55. memcpy(pstr, pbyte, size);
  56.  
  57. }
  58.  
  59. return pstr;
  60.  
  61. }
  62.  
  63.  
  64.  
  65. void Java_com_example_leds1_MainActivity_writeLeds(JNIEnv* env, jobject thiz, jstring str)
  66.  
  67. {
  68.  
  69. int fd;
  70.  
  71. fd = open("/dev/leds",O_RDWR);
  72.  
  73. char* pstr = jstring_to_pchar(env,str);
  74.  
  75. write(fd,pstr,strlen(pstr));
  76.  
  77. close(fd);
  78.  
  79. }
  80.  
  81. void Java_com_example_leds1_MainActivity_ioctlLeds(JNIEnv* env, jobject thiz, jint cmd, jint arg)
  82.  
  83. {
  84.  
  85. int fd;
  86.  
  87. fd = open("/dev/leds",O_RDWR);
  88.  
  89. ioctl(fd,cmd,arg);
  90.  
  91. close(fd);
  92.  
  93. }</span>

 

//jni/Android.mk

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">LOCAL_PATH := $(call my-dir)  
  2.  
  3.       
  4.  
  5. include $(CLEAR_VARS)  
  6.  
  7.      
  8.  
  9. LOCAL_MODULE := leds  
  10.  
  11. LOCAL_SRC_FILES := leds.c  
  12.  
  13.       
  14.  
  15. include $(BUILD_SHARED_LIBRARY)  </span>

 

//MainActivity.java

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">package com.example.leds1;
  2.  
  3.  
  4.  
  5. import android.app.Activity;
  6.  
  7. import android.os.Bundle;
  8.  
  9. import android.view.Menu;
  10.  
  11. import android.view.View;
  12.  
  13. import android.view.MenuItem;
  14.  
  15. import android.widget.TextView;
  16.  
  17. import android.widget.CheckBox;
  18.  
  19.  
  20.  
  21. public class MainActivity extends Activity {
  22.  
  23. private CheckBox[] cbStrLeds = new CheckBox[4];
  24.  
  25. private CheckBox[] cbCmdLeds = new CheckBox[4];
  26.  
  27. TextView textView;  
  28.  
  29.     public native String getText();//声明native 方法  
  30.  
  31.     public native void writeLeds(String str);
  32.  
  33.     public native void ioctlLeds(int cmd, int arg);
  34.  
  35.     @Override  
  36.  
  37.     public void onCreate(Bundle savedInstanceState) {  
  38.  
  39.         super.onCreate(savedInstanceState);  
  40.  
  41.         setContentView(R.layout.activity_main);  
  42.  
  43.         cbStrLeds[0] = (CheckBox)findViewById(R.id.checkbox_str_led1);
  44.  
  45.      cbStrLeds[1] = (CheckBox)findViewById(R.id.checkbox_str_led2);
  46.  
  47.      cbStrLeds[2] = (CheckBox)findViewById(R.id.checkbox_str_led3);
  48.  
  49.      cbStrLeds[3] = (CheckBox)findViewById(R.id.checkbox_str_led4);
  50.  
  51.     
  52.  
  53.      cbCmdLeds[0] = (CheckBox)findViewById(R.id.checkbox_cmd_led1);
  54.  
  55.      cbCmdLeds[1] = (CheckBox)findViewById(R.id.checkbox_cmd_led2);
  56.  
  57.      cbCmdLeds[2] = (CheckBox)findViewById(R.id.checkbox_cmd_led3);
  58.  
  59.      cbCmdLeds[3] = (CheckBox)findViewById(R.id.checkbox_cmd_led4);
  60.  
  61.         
  62.  
  63.        
  64.  
  65.         String myString = getText();//调用native方法
  66.  
  67.      //   long z = add(2, 3);
  68.  
  69.      //   String zstr=Long.toString(z);
  70.  
  71.         textView = (TextView)findViewById(R.id.textView); 
  72.  
  73.         textView.setText(myString);  
  74.  
  75.     }
  76.  
  77. public void onClick_write(View view)
  78.  
  79. {
  80.  
  81.  
  82.  
  83. String str="";
  84.  
  85. for(int i=0;i<4;i++)
  86.  
  87. {
  88.  
  89. if(cbStrLeds[i].isChecked())
  90.  
  91. str +='1';
  92.  
  93. else
  94.  
  95. str +='0';
  96.  
  97. }
  98.  
  99. TextView textview = (TextView)findViewById(R.id.textView);
  100.  
  101. textview.setText(str);
  102.  
  103. writeLeds(str);
  104.  
  105. }
  106.  
  107. public void onClick_ioctl(View view)
  108.  
  109. {
  110.  
  111. TextView textview = (TextView)findViewById(R.id.textView);
  112.  
  113. textview.setText("ioctl_test!");
  114.  
  115. for(int i=0;i<4;i++)
  116.  
  117. {
  118.  
  119. if(cbCmdLeds[i].isChecked())
  120.  
  121. ioctlLeds(1,i);
  122.  
  123. else
  124.  
  125. ioctlLeds(0,i);
  126.  
  127. }
  128.  
  129. }   
  130.  
  131.     
  132.  
  133. @Override
  134.  
  135. public boolean onCreateOptionsMenu(Menu menu) {
  136.  
  137. // Inflate the menu; this adds items to the action bar if it is present.
  138.  
  139. getMenuInflater().inflate(R.menu.main, menu);
  140.  
  141. return true;
  142.  
  143. }
  144.  
  145.  
  146.  
  147. @Override
  148.  
  149. public boolean onOptionsItemSelected(MenuItem item) {
  150.  
  151. // Handle action bar item clicks here. The action bar will
  152.  
  153. // automatically handle clicks on the Home/Up button, so long
  154.  
  155. // as you specify a parent activity in AndroidManifest.xml.
  156.  
  157. int id = item.getItemId();
  158.  
  159. if (id == R.id.action_settings) {
  160.  
  161. return true;
  162.  
  163. }
  164.  
  165. return super.onOptionsItemSelected(item);
  166.  
  167. }
  168.  
  169.     static {  
  170.  
  171.         System.loadLibrary("leds"); //导入链接库   
  172.  
  173.     }  
  174.  
  175. }</span>

需要注意的是，想要编译jni中的文件，必须在电脑上提前装好ndk，这也是一个非常客观的工程量。然后重点是，需要在命令行或者界面形式下编译jni，具体方法上网查查吧。

 

 

4.2 JNI/Service程序代码

//LedHalService.cpp

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <stdlib.h>
  2.  
  3. #include <string.h>
  4.  
  5.  
  6.  
  7. #include <assert.h>
  8.  
  9. #include <jni.h>
  10.  
  11. #include <hardware/led_hal.h>   //用到了和HAL层同一个LED_HARDWARE_MODULE_ID = led_hal
  12.  
  13.  
  14.  
  15. #ifdef __cplusplus
  16.  
  17. extern "C" {
  18.  
  19. #endif
  20.  
  21.  
  22.  
  23. struct led_control_device_t *sLedDevice = NULL;
  24.  
  25.  
  26.  
  27. //open the led device  by hal
  28.  
  29.  
  30.  
  31. static inline int led_control_open(struct hw_module_t *module,struct led_control_device_t **device)
  32.  
  33. {
  34.  
  35. return module->methods->open(module,LED_HARDWARE_MODULE_ID,(struct hw_device_t**)device);
  36.  
  37. }
  38.  
  39.  
  40.  
  41. //close the led device  by hal
  42.  
  43. jboolean Java_com_example_leds_MainActivity_ledClose (JNIEnv* env, jobject obj)
  44.  
  45. {
  46.  
  47. if(sLedDevice)
  48.  
  49. {
  50.  
  51. sLedDevice->common.close(&(sLedDevice->common));
  52.  
  53. }
  54.  
  55. return 0;
  56.  
  57. }
  58.  
  59. //turn on the led
  60.  
  61. jboolean Java_com_example_leds_MainActivity_ledSetOn (JNIEnv* env, jobject obj,jint number)
  62.  
  63. {
  64.  
  65. if(sLedDevice)
  66.  
  67. {
  68.  
  69. return sLedDevice->set_on(sLedDevice,number);
  70.  
  71. }
  72.  
  73. return false;
  74.  
  75. }
  76.  
  77. //turn off the led
  78.  
  79. jboolean Java_com_example_leds_MainActivity_ledSetOff (JNIEnv* env, jobject obj,jint number)
  80.  
  81. {
  82.  
  83. if(sLedDevice)
  84.  
  85. {
  86.  
  87. return sLedDevice->set_off(sLedDevice,number);
  88.  
  89. }
  90.  
  91. return false;
  92.  
  93. }
  94.  
  95.  
  96.  
  97. //led init
  98.  
  99.  
  100.  
  101. jboolean Java_com_example_leds_MainActivity_ledInit (JNIEnv* env, jobject obj)
  102.  
  103. {
  104.  
  105. led_module_t *module;
  106.  
  107. /*看到了吗，hw_get_module是调用HAL模块的核心函数，其中的LED_HARDWARE_MODULE_ID就是前文一直在提的ID号，JNI模块就是通过这个ID号找到的/system/lib/hw文件中相应的HAL共享库模块*/
  108.  
  109. int err = hw_get_module(LED_HARDWARE_MODULE_ID,(hw_module_t const**)&module);
  110.  
  111. if(err == 0)
  112.  
  113. {
  114.  
  115. if(led_control_open(&(module->common),&sLedDevice) == 0)
  116.  
  117. return true;
  118.  
  119. }
  120.  
  121. sLedDevice = NULL;
  122.  
  123. return false;
  124.  
  125. }
  126.  
  127.  
  128.  
  129. static led_control_device_t * get_device(hw_module_t* module, char const* name)
  130.  
  131. {
  132.  
  133. int err;
  134.  
  135. hw_device_t* device;
  136.  
  137. err = module->methods->open(module,name,&device);
  138.  
  139. if(err == 0)
  140.  
  141. {
  142.  
  143. return (led_control_device_t*)device;
  144.  
  145. }
  146.  
  147. else
  148.  
  149. {
  150.  
  151. return NULL;
  152.  
  153. }
  154.  
  155. }
  156.  
  157. /*通过JNINativeMethod数组定义了函数映射表，注册给Java虚拟机，这样JVM就可以用函数映射表来调用相应的函数，该方式属于动态调用共享库*/
  158.  
  159. static JNINativeMethod method_table[]={
  160.  
  161. {"led_init","()Z",(void*)Java_com_example_leds_MainActivity_ledInit},
  162.  
  163. {"led_setOn","(I)Z",(void*)Java_com_example_leds_MainActivity_ledSetOn},
  164.  
  165. {"led_setOff","(I)Z",(void*)Java_com_example_leds_MainActivity_ledSetOff},
  166.  
  167. {"led_close","()Z",(void*)Java_com_example_leds_MainActivity_ledClose},
  168.  
  169. };
  170.  
  171. int register_android_server_LedService(JNIEnv *env)
  172.  
  173. {
  174.  
  175. //This sentence is very important because we will use this class to call the service
  176.  
  177. static const char* const kClassName = "com/example/leds/LedService";
  178.  
  179. //static const char* const kClassName = "com/example/leds";
  180.  
  181. jclass clazz;
  182.  
  183. /*Look up the class*/
  184.  
  185. clazz = env->FindClass(kClassName);
  186.  
  187. if(clazz == NULL)
  188.  
  189. {
  190.  
  191. return -1;
  192.  
  193. }
  194.  
  195. /*Register all the methods*/
  196.  
  197. if(env->RegisterNatives(clazz,method_table,sizeof(method_table)/sizeof(method_table[0]))!=JNI_OK)
  198.  
  199. {
  200.  
  201. return -1;
  202.  
  203. }
  204.  
  205. /*Fill out the rest of the ID cache*/
  206.  
  207. return 0;
  208.  
  209. }
  210.  
  211. /*系统在成功装在JNI共享库后会自动调用JNI_OnLoad函数，该函数一般用与初始化JNI模块*/
  212.  
  213. jint JNI_OnLoad(JavaVM* vm, void* reserved)
  214.  
  215. {
  216.  
  217. JNIEnv* env = NULL;
  218.  
  219. jint result = -1;
  220.  
  221. if(vm->GetEnv((void**) &env,JNI_VERSION_1_4)!=JNI_OK)
  222.  
  223. {
  224.  
  225. return result;
  226.  
  227. }
  228.  
  229. /*使用下面的函数绑定JNI程序库与Java程序库。若想使用静态调用libled_hal_jni.so，则需要将下面的代码屏蔽掉*/
  230.  
  231. register_android_server_LedService(env);
  232.  
  233. /*返回JNI_VERSION_1_4，表明只有运行在JDK1.4及以上版本的Java程序才能调用当前的JNI模块*/
  234.  
  235. return JNI_VERSION_1_4;
  236.  
  237. }
  238.  
  239. #ifdef __cplusplus
  240.  
  241. }
  242.  
  243. #endif</span>
 

//Android.mk

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">LOCAL_PATH:= $(call my-dir)
  2.  
  3. include $(CLEAR_VARS)
  4.  
  5. LOCAL_PRELINK_MODULE :=false
  6.  
  7. LOCAL_MODULE_TAGS:=optional
  8.  
  9. LOCAL_SRC_FILES:=LedHalService.cpp
  10.  
  11. LOCAL_MODULE:=libled_hal_jni
  12.  
  13.  
  14.  
  15. LOCAL_SHARED_LIBRARIES := \
  16.  
  17. libandroid_runtime \
  18.  
  19. libcutils \
  20.  
  21. libhardware \
  22.  
  23. libhardware_legacy \
  24.  
  25. libnativehelper \
  26.  
  27. libsystem_server \
  28.  
  29. libutils \
  30.  
  31. libui \
  32.  
  33. libsurfaceflinger_client
  34.  
  35.  
  36.  
  37. include $(BUILD_SHARED_LIBRARY)
  38.  
  39.  </span>

 

五、APP应用程序层

关于如何在APP中调用JNI库文件，上文中4.1节有提到，不过那是在工程中建立了一个jni文件夹，生成的JNI的库文件直接保存到了当前工程的lib文件夹下。当然也可以不用在当前工程下建立jni文件夹，像4.2那样通过Android原生代码进行编译，然后直接通过绝对路径加载模块也能产生相同功能。

 

5.1 activity_main.xml

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;"><?xml version="1.0" encoding="utf-8"?>
  2.  
  3. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  4.  
  5.     android:layout_width="fill_parent"
  6.  
  7.     android:layout_height="fill_parent"
  8.  
  9.     android:orientation="vertical" >
  10.  
  11.  
  12.  
  13.     <LinearLayout
  14.  
  15.         android:layout_width="fill_parent"
  16.  
  17.         android:layout_height="wrap_content"
  18.  
  19.         android:orientation="horizontal" >
  20.  
  21.  
  22.  
  23.         <CheckBox
  24.  
  25.             android:id="@+id/checkbox_cmd_led1"
  26.  
  27.             android:layout_width="wrap_content"
  28.  
  29.             android:layout_height="wrap_content"
  30.  
  31.             android:text="LED1" />
  32.  
  33.  
  34.  
  35.         <CheckBox
  36.  
  37.             android:id="@+id/checkbox_cmd_led2"
  38.  
  39.             android:layout_width="wrap_content"
  40.  
  41.             android:layout_height="wrap_content"
  42.  
  43.             android:text="LED2" />
  44.  
  45.  
  46.  
  47.         <CheckBox
  48.  
  49.             android:id="@+id/checkbox_cmd_led3"
  50.  
  51.             android:layout_width="wrap_content"
  52.  
  53.             android:layout_height="wrap_content"
  54.  
  55.             android:text="LED3" />
  56.  
  57.  
  58.  
  59.         <CheckBox
  60.  
  61.             android:id="@+id/checkbox_cmd_led4"
  62.  
  63.             android:layout_width="wrap_content"
  64.  
  65.             android:layout_height="wrap_content"
  66.  
  67.             android:text="LED4" />
  68.  
  69.     </LinearLayout>
  70.  
  71.  
  72.  
  73.     <Button
  74.  
  75.         
  76.  
  77.         android:layout_width="fill_parent"
  78.  
  79.         android:layout_height="wrap_content"
  80.  
  81.         android:onClick="onClick_led"
  82.  
  83.         android:text="led_hal_jni" />
  84.  
  85.  
  86.  
  87. </LinearLayout></span>

5.2 LedServer.java

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">package com.example.leds;
  2.  
  3.  
  4.  
  5.  
  6.  
  7. public class LedService {
  8.  
  9. private static LedService LedService;
  10.  
  11.  
  12.  
  13. public static LedService getInstance()
  14.  
  15. {
  16.  
  17. if (LedService == null)
  18.  
  19.     LedService = new LedService();
  20.  
  21. return LedService;
  22.  
  23. }
  24.  
  25.     
  26.  
  27. private LedService()  
  28.  
  29. {  
  30.  
  31. init(); 
  32.  
  33. }
  34.  
  35.     
  36.  
  37. public boolean init()
  38.  
  39. {
  40.  
  41. return led_init();
  42.  
  43. } 
  44.  
  45. public boolean setOn(int led)
  46.  
  47. {
  48.  
  49. return led_setOn(led);
  50.  
  51. }  
  52.  
  53. public boolean setOff(int led)
  54.  
  55. { 
  56.  
  57. return led_setOff(led);
  58.  
  59. } 
  60.  
  61.   
  62.  
  63. //  native method 
  64.  
  65. private native boolean led_init();
  66.  
  67.  
  68.  
  69. private native boolean led_setOn(int led);
  70.  
  71.  
  72.  
  73. private native boolean led_setOff(int led);
  74.  
  75.  
  76.  
  77. static
  78.  
  79. {
  80.  
  81. System.load("/system/lib/libled_hal_jni.so");
  82.  
  83. }
  84.  
  85. }</span>

 

5.3 MainActivity.java

  1. <span style="font-family:KaiTi_GB2312;font-size:18px;">package com.example.leds;
  2.  
  3.  
  4.  
  5. import com.example.leds.LedService;
  6.  
  7. import android.app.Activity;
  8.  
  9. import android.os.Bundle;
  10.  
  11. import android.view.Menu;
  12.  
  13. import android.view.MenuItem;
  14.  
  15. import android.view.View;
  16.  
  17. import android.widget.CheckBox;
  18.  
  19.  
  20.  
  21. public class MainActivity extends Activity {
  22.  
  23.  
  24.  
  25. private CheckBox[] cbCmdLeds = new CheckBox[4];
  26.  
  27. @Override
  28.  
  29. protected void onCreate(Bundle savedInstanceState) {
  30.  
  31. super.onCreate(savedInstanceState);
  32.  
  33. setContentView(R.layout.activity_main);
  34.  
  35.     cbCmdLeds[0] = (CheckBox)findViewById(R.id.checkbox_cmd_led1);
  36.  
  37.      cbCmdLeds[1] = (CheckBox)findViewById(R.id.checkbox_cmd_led2);
  38.  
  39.      cbCmdLeds[2] = (CheckBox)findViewById(R.id.checkbox_cmd_led3);
  40.  
  41.      cbCmdLeds[3] = (CheckBox)findViewById(R.id.checkbox_cmd_led4);
  42.  
  43. /*
  45. LedService ledService = LedService.getInstance();
  47. ledService.setOn(0);
  49. ledService.setOff(1);
  51. ledService.setOn(2);  
  53. ledService.setOff(3);
  55. */
  56.  
  57. }
  58.  
  59. public void onClick_led(View view)
  60.  
  61. {
  62.  
  63. LedService ledService = LedService.getInstance();
  64.  
  65. for(int i=0;i<4;i++)
  66.  
  67. {
  68.  
  69. if(cbCmdLeds[i].isChecked())
  70.  
  71. ledService.setOn(i);
  72.  
  73. else
  74.  
  75. ledService.setOff(i);
  76.  
  77. }
  78.  
  79. }   
  80.  
  81. @Override
  82.  
  83. public boolean onCreateOptionsMenu(Menu menu) {
  84.  
  85. // Inflate the menu; this adds items to the action bar if it is present.
  86.  
  87. getMenuInflater().inflate(R.menu.main, menu);
  88.  
  89. return true;
  90.  
  91. }
  92.  
  93.  
  94.  
  95. @Override
  96.  
  97. public boolean onOptionsItemSelected(MenuItem item) {
  98.  
  99. // Handle action bar item clicks here. The action bar will
  100.  
  101. // automatically handle clicks on the Home/Up button, so long
  102.  
  103. // as you specify a parent activity in AndroidManifest.xml.
  104.  
  105. int id = item.getItemId();
  106.  
  107. if (id == R.id.action_settings) {
  108.  
  109. return true;
  110.  
  111. }
  112.  
  113. return super.onOptionsItemSelected(item);
  114.  
  115. }
  116.  
  117. }</span>

 

好了，关于整套程序都已经写完了。


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/663853
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号