Android模拟器学framework和driver之传感器篇6（Android 通过JNI连接驱动层和framework）

之前，我们已经实现了android HAL层，在android模拟器上移植了一个虚拟的temperature sensor，我之前在模拟器上也移植了backlight，RTC等驱动，都能在应用层得到需要的数据，其实自己想学点东西，给自己布置点任务还是不错的，通过模拟器也可以来学习linux 中的device driver，这部分在今后的博客中我会涉及到，这篇blog我主要是想在之前所做的东西的基础上来实现android 的另外一种架构层的实现。

driver--->framework JNI(server)---->framework JAVA(server)

我们的任务分为如下几个步骤：

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

||  1.在temperature sensor驱动中添加sysfs中添加一个只读的文件让JNI 读数据。                    

||  2.在temperature sensor驱动中添加uevent通知user space数据发生了改变需要读取。        

||  3.在android framework中添加jni server读取底层数据，封装操作函数。                                  

||  4.在android framework中添加uevent observer来监听uevent事件的变化。                              

||  5.（可选）在java server中添加系统ACTION，然后编写android apk来接收ACTION。          

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

下面会根据这个步骤来展开我们的学习！！！！！！！

 

之前的代码可以参照之前的文章。

1.在temperature sensor驱动中添加sysfs中添加一个只读的文件让JNI 读数据。      

首先来看的还是驱动，我们在之前的驱动中加入如下代码：

首先是添加value文件节点，可以参照name是如何做的 

 

[cpp] view plaincopy
  1. static int tempValue;  
  2.   
  3. static ssize_t temperature_show_value(struct device *dev,  
  4.     struct device_attribute *attr, char *buf)  
  5. {     
  6.     return sprintf(buf, "%d\n", tempValue);  
  7. }  
  8.   
  9. static IIO_DEVICE_ATTR(name, S_IRUGO, temperature_show_name, NULL,0);  
  10. static IIO_DEVICE_ATTR(value, S_IRUGO, temperature_show_value, NULL,0);  
  11.   
  12. static struct attribute *temperature_attributes[] = {  
  13.     &iio_dev_attr_name.dev_attr.attr,  
  14.     &iio_dev_attr_value.dev_attr.attr,  
  15.     NULL  
  16. };  

 

 

这样的话会生成/sys/bus/iio/devices/device0/value 可以read 这个节点来得到温度值。

2.在temperature sensor驱动中添加uevent通知user space数据发生了改变需要读取。

接下来是uevent的添加，这边先把代码贴上，我们在分析uvent的代码。

 

[cpp] view plaincopy
  1. <pre name="code" class="cpp">static void temperature_dev_poll(struct input_polled_dev *dev)  
  2. {  
  3.     //++++add uevent in driver  
  4.     char *buf;  
  5.     char *envp[3];  
  6.     sysfs_notify(&dev->input->dev.kobj,NULL, "value");  
  7.     buf = kmalloc(32,GFP_ATOMIC);  
  8.     if(!buf){  
  9.         printk(KERN_ERR "%s kmalloc failed\n", __func__);  
  10.         return;  
  11.     }     
  12.     envp[0] = "NAME=temperature";  
  13.     snprintf(buf , 32 , "TEMPERATURE=%d",tempValue);  
  14.     envp[1] = buf;  
  15.     envp[2] =NULL;  
  16.     kobject_uevent_env(&dev->input->dev.kobj,KOBJ_CHANGE,envp);  
  17.     kfree(buf);  
  18.     //----------  
  19.     printk(KERN_INFO "Current Temperature: %d\n",tempValue);  
  20.     if((tempValue++)==100)  
  21.         tempValue=0;  
  22.     input_event(dev->input,EV_ABS,ABS_PRESSURE,tempValue);  
  23.     input_sync(dev->input);  
  24. }  





 




 


其实大家可以看到这边最主要的就是kobject_uevent_env函数，这个函数会通知user space 环境变量发生了变化，然后user space可以通过监听uevent来知道这个时候需要读数据，好，来分析下这个函数：


 


 






[cpp] view plaincopy







    

  1. /** 
    2. 

  2.  * kobject_uevent_env - send an uevent with environmental data 
    3. 

  3.  * 
    4. 

  4.  * @action: action that is happening 
    5. 

  5.  * @kobj: struct kobject that the action is happening to 
    6. 

  6.  * @envp_ext: pointer to environmental data 
    7. 

  7.  * 
    8. 

  8.  * Returns 0 if kobject_uevent() is completed with success or the 
    9. 

  9.  * corresponding error when it fails. 
    10. 

  10.  */  
    11. 

  11. int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,  
    12. 

  12.                char *envp_ext[])  
    13. 

  13. {  
    14. 

  14.     struct kobj_uevent_env *env;  
    15. 

  15.     const char *action_string = kobject_actions[action];  
    16. 

  16.     const char *devpath = NULL;  
    17. 

  17.     const char *subsystem;  
    18. 

  18.     struct kobject *top_kobj;  
    19. 

  19.     struct kset *kset;  
    20. 

  20.     struct kset_uevent_ops *uevent_ops;  
    21. 

  21.     u64 seq;  
    22. 

  22.     int i = 0;  
    23. 

  23.     int retval = 0;  
    24. 

  24.   
    25. 

  25.     pr_debug("kobject: '%s' (%p): %s\n",  
    26. 

  26.          kobject_name(kobj), kobj, __func__);  
    27. 

  27.   
    28. 

  28.     /* search the kset we belong to */  
    29. 

  29.     top_kobj = kobj;  
    30. 

  30.      /*找到其所属的kset容器，如果没找到就从其父kobj找，一直继续下去，直到父kobj不存在*/  
    31. 

  31.     while (!top_kobj->kset && top_kobj->parent)  
    32. 

  32.         top_kobj = top_kobj->parent;  
    33. 

  33.   
    34. 

  34.     if (!top_kobj->kset) {  
    35. 

  35.         pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "  
    36. 

  36.              "without kset!\n", kobject_name(kobj), kobj,  
    37. 

  37.              __func__);  
    38. 

  38.         return -EINVAL;  
    39. 

  39.     }  
    40. 

  40.   
    41. 

  41.     kset = top_kobj->kset;  
    42. 

  42.     uevent_ops = kset->uevent_ops;  
    43. 

  43.     /*回调uevent_ops->filter()函数，我们这边是dev_uevent_filter()函数，主要是检查是否是uevent_suppress*/  
    44. 

  44.     /* skip the event, if the filter returns zero. */  
    45. 

  45.     if (uevent_ops && uevent_ops->filter)  
    46. 

  46.         if (!uevent_ops->filter(kset, kobj)) {   //如果不成功，就是uevent_suppress,则直接返回  
    47. 

  47.             pr_debug("kobject: '%s' (%p): %s: filter function "  
    48. 

  48.                  "caused the event to drop!\n",  
    49. 

  49.                  kobject_name(kobj), kobj, __func__);  
    50. 

  50.             return 0;  
    51. 

  51.         }  
    52. 

  52.     /*回调uevent_ops->name()，来获取bus或者class的名字，这边是iio bus，所以bus的名字是“iio”*/  
    53. 

  53.     /* originating subsystem */  
    54. 

  54.     if (uevent_ops && uevent_ops->name)  
    55. 

  55.         subsystem = uevent_ops->name(kset, kobj);  
    56. 

  56.     else  
    57. 

  57.         subsystem = kobject_name(&kset->kobj);  
    58. 

  58.     if (!subsystem) {  
    59. 

  59.         pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "  
    60. 

  60.              "event to drop!\n", kobject_name(kobj), kobj,  
    61. 

  61.              __func__);  
    62. 

  62.         return 0;  
    63. 

  63.     }  
    64. 

  64.       
    65. 

  65.     /*获得用于存放环境变量的buffer*/  
    66. 

  66.     /* environment buffer */  
    67. 

  67.     env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);  
    68. 

  68.     if (!env)  
    69. 

  69.         return -ENOMEM;  
    70. 

  70.       
    71. 

  71.     /*获取该kobj在sysfs的路径，通过遍历其父kobj来获得，这边是/sys/devices/platform/android-temperature*/  
    72. 

  72.     /* complete object path */  
    73. 

  73.     devpath = kobject_get_path(kobj, GFP_KERNEL);  
    74. 

  74.     if (!devpath) {  
    75. 

  75.         retval = -ENOENT;  
    76. 

  76.         goto exit;  
    77. 

  77.     }  
    78. 

  78.   
    79. 

  79.     /*添加ACTION环境变量，这边是“change” 命令，这里提供了add,remove,change,move,online,offline六种命令*/  
    80. 

  80.     /* default keys */  
    81. 

  81.     retval = add_uevent_var(env, "ACTION=%s", action_string);  
    82. 

  82.     if (retval)  
    83. 

  83.         goto exit;  
    84. 

  84.     /*添加DEVPATH环境变量，这边是/sys/devices/platform/android-temperature 之后会用到*/  
    85. 

  85.     retval = add_uevent_var(env, "DEVPATH=%s", devpath);  
    86. 

  86.     if (retval)  
    87. 

  87.         goto exit;  
    88. 

  88.     /*添加subsystem环境变量，这里是input*/  
    89. 

  89.     retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);  
    90. 

  90.     if (retval)  
    91. 

  91.         goto exit;  
    92. 

  92.   
    93. 

  93.     /* keys passed in from the caller */  
    94. 

  94.     if (envp_ext) {  
    95. 

  95.         for (i = 0; envp_ext[i]; i++) {  
    96. 

  96.             retval = add_uevent_var(env, "%s", envp_ext[i]);  
    97. 

  97.             if (retval)  
    98. 

  98.                 goto exit;  
    99. 

  99.         }  
    100. 

  100.     }  
    101. 

  101.   
    102. 

  102.     //回调uevent_ops->event()，输出一些环境变量  
    103. 

  103.     /* let the kset specific function add its stuff */  
    104. 

  104.     if (uevent_ops && uevent_ops->uevent) {  
    105. 

  105.         retval = uevent_ops->uevent(kset, kobj, env);  
    106. 

  106.         if (retval) {  
    107. 

  107.             pr_debug("kobject: '%s' (%p): %s: uevent() returned "  
    108. 

  108.                  "%d\n", kobject_name(kobj), kobj,  
    109. 

  109.                  __func__, retval);  
    110. 

  110.             goto exit;  
    111. 

  111.         }  
    112. 

  112.     }  
    113. 

  113.   
    114. 

  114.     /* 
    115. 

  115.      * Mark "add" and "remove" events in the object to ensure proper 
    116. 

  116.      * events to userspace during automatic cleanup. If the object did 
    117. 

  117.      * send an "add" event, "remove" will automatically generated by 
    118. 

  118.      * the core, if not already done by the caller. 
    119. 

  119.      */  
    120. 

  120.     if (action == KOBJ_ADD)  
    121. 

  121.         kobj->state_add_uevent_sent = 1;  
    122. 

  122.     else if (action == KOBJ_REMOVE)  
    123. 

  123.         kobj->state_remove_uevent_sent = 1;  
    124. 

  124.   
    125. 

  125.     /* we will send an event, so request a new sequence number */  
    126. 

  126.     /*增加event序列号的值，并输出到环境变量的buffer。该序列号可以从sys/kernel/uevent_seqnum属性文件读取*/  
    127. 

  127.     spin_lock(&sequence_lock);  
    128. 

  128.     seq = ++uevent_seqnum;  
    129. 

  129.     spin_unlock(&sequence_lock);  
    130. 

  130.     retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);  
    131. 

  131.     if (retval)  
    132. 

  132.         goto exit;  
    133. 

  133. /*如果配置了网络，那么就会通过netlink socket向用户控件发送环境变量，而用户控件则通过netlink socket接收，然后采取一系列的动作。这种机制目前在udev中，也就是pc机系统中，我们这边不是PC机所以不在分析*/  
    134. 

  134. #if defined(CONFIG_NET)  
    135. 

  135.     /* send netlink message */  
    136. 

  136.     if (uevent_sock) {  
    137. 

  137.         struct sk_buff *skb;  
    138. 

  138.         size_t len;  
    139. 

  139.   
    140. 

  140.         /* allocate message with the maximum possible size */  
    141. 

  141.         len = strlen(action_string) + strlen(devpath) + 2;  
    142. 

  142.         skb = alloc_skb(len + env->buflen, GFP_KERNEL);  
    143. 

  143.         if (skb) {  
    144. 

  144.             char *scratch;  
    145. 

  145.   
    146. 

  146.             /* add header */  
    147. 

  147.             scratch = skb_put(skb, len);  
    148. 

  148.             sprintf(scratch, "%s@%s", action_string, devpath);  
    149. 

  149.   
    150. 

  150.             /* copy keys to our continuous event payload buffer */  
    151. 

  151.             for (i = 0; i < env->envp_idx; i++) {  
    152. 

  152.                 len = strlen(env->envp[i]) + 1;  
    153. 

  153.                 scratch = skb_put(skb, len);  
    154. 

  154.                 strcpy(scratch, env->envp[i]);  
    155. 

  155.             }  
    156. 

  156.   
    157. 

  157.             NETLINK_CB(skb).dst_group = 1;  
    158. 

  158.             retval = netlink_broadcast(uevent_sock, skb, 0, 1,  
    159. 

  159.                            GFP_KERNEL);  
    160. 

  160.         } else  
    161. 

  161.             retval = -ENOMEM;  
    162. 

  162.     }  
    163. 

  163. #endif  
    164. 

  164. /*对于嵌入式系统来说，busybox采用的是mdev，在系统启动脚本rcS中会使用echo /sbin/mdev > /proc/sys/kernelhotplug命令。。。。*/  
    165. 

  165.   
    166. 

  166.     /* call uevent_helper, usually only enabled during early boot */  
    167. 

  167.     if (uevent_helper[0]) {  
    168. 

  168.         char *argv [3];  
    169. 

  169.   
    170. 

  170.         argv [0] = uevent_helper;  
    171. 

  171.         argv [1] = (char *)subsystem;  
    172. 

  172.         argv [2] = NULL;  
    173. 

  173.         retval = add_uevent_var(env, "HOME=/");  
    174. 

  174.         if (retval)  
    175. 

  175.             goto exit;  
    176. 

  176.         retval = add_uevent_var(env,  
    177. 

  177.                     "PATH=/sbin:/bin:/usr/sbin:/usr/bin");  
    178. 

  178.         if (retval)  
    179. 

  179.             goto exit;  
    180. 

  180.           
    181. 

  181.         //呼叫应用程序来处理，UMH_WAIT_EXEC表明等待应用程序处理完  
    182. 

  182.         retval = call_usermodehelper(argv[0], argv,  
    183. 

  183.                          env->envp, UMH_WAIT_EXEC);  
    184. 

  184.     }  
    185. 

  185.   
    186. 

  186. exit:  
    187. 

  187.     kfree(devpath);  
    188. 

  188.     kfree(env);  
    189. 

  189.     return retval;  
    190. 

  190. }  
    191. 

  191. EXPORT_SYMBOL_GPL(kobject_uevent_env);  
    192. 







 


 


这边我们要关注的就是ACTION还有就是环境变量参数，注意，我们这边使用的kobject是input->dev.kobj，所以这边的DEVPATH和SUBSYSTEM都是跟input subsystem有关的。


这里把uevent传到user space了，下面来看user space是怎么做的，涉及的代码有：


 


hardware/libhardware_legacy/uevent frameworks/base/core/jni/android_os_UEventObserver.cpp frameworks/base/core/java/android/os/UEventObserver.java frameworks/base/services/java/com/android/server/SystemServer.java


 


这边我提最重要的，就是hardware/libhardware_legacy/uevent/uevent.c 发送一个socket广播把这个uevent事件发送出去


 






[cpp] view plaincopy







    

  1. s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);  
    2. 

  2. if(s < 0)  
    3. 

  3.     return 0;  
    4. 

  4.   
    5. 

  5. setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz));  
    6. 

  6.   
    7. 

  7. if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {  
    8. 

  8.     close(s);  
    9. 

  9.     return 0;  
    10. 

  10. }  
    11. 




然后就是在framework中通过jni进行封装，使得java中也能通过sokect来监听uevent。


 





3.在android framework中添加jni server读取底层数据，封装操作函数。                 


下面我们来实现在jni中读取文件系统中的节点来获得温度的值。


下面是2个文件的下载地址，一个是jni一个是java（com_android_server_TemperatureObserver.cpp，TemperatureObserver.java）


http://download.csdn.net/detail/zhangjie201412/4049098


其实在这边用到的东西也不是很多，最多就是jni中的一些规则：


在jni中获得java中的域，在jni中注册method函数，在jni中注册等方法，这边很简单，就是open节点，然后读数据，获得java中的变量的fieldID 然后把数据传给java中的变量，最后封装native函数，然后再java中调用。


1.获得java中的域：


 






[cpp] view plaincopy







    

  1. jclass clazz = env->FindClass("com/android/server/TemperatureObserver");  
    2. 

  2. if(clazz == NULL)  
    3. 

  3. {  
    4. 

  4.     LOGE("Can't find com/android/server/TemperatureObserver");  
    5. 

  5.     return -1;  
    6. 

  6. }  
    7. 

  7.   
    8. 

  8. mTemperatureValueID =   
    9. 

  9.     env->GetFieldID(clazz , "mTemperatureValue" , "I");  
    10. 







 


2.open节点读数据，再把数据传到java的变量中：


 






[cpp] view plaincopy







    

  1. jclass clazz = env->FindClass("com/android/server/TemperatureObserver");  
    2. 

  2. if(clazz == NULL)  
    3. 

  3. {  
    4. 

  4.     LOGE("Can't find com/android/server/TemperatureObserver");  
    5. 

  5.     return -1;  
    6. 

  6. }  
    7. 

  7.   
    8. 

  8. mTemperatureValueID =   
    9. 

  9.     env->GetFieldID(clazz , "mTemperatureValue" , "I");  
    10. 







 


4.在android framework中添加uevent observer来监听uevent事件的变化。  


3.在java中注册uevent监听


 






[cpp] view plaincopy







    

  1. public TemperatureObserver(Context context) {  
    2. 

  2.     mContext = context;  
    3. 

  3.     PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);  
    4. 

  4.         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "TemperatureObserver");  
    5. 

  5.         mWakeLock.setReferenceCounted(false);  
    6. 

  6.     //++++add log  
    7. 

  7.     Slog.v(TAG,"------Struct function....");  
    8. 

  8. /           startObserving("EVENT=temperature");  
    9. 

  9.     startObserving(TEMPERATURE_UEVENT_MATCH);  
    10. 

  10. /           init();  // set initial status  
    11. 

  11. }  
    12. 




4.在java中实现onUEvent，并且调用java原生接口


 


 






[cpp] view plaincopy







    

  1. @Override  
    2. 

  2. public void onUEvent(UEventObserver.UEvent event) {  
    3. 

  3.     if (LOG) Slog.v(TAG, "Temperature UEVENT: " + event.toString());  
    4. 

  4.   
    5. 

  5.         try {  
    6. 

  6.             update(event.get("NAME"), Integer.parseInt(event.get("TEMPERATURE")));  
    7. 

  7.         } catch (NumberFormatException e) {  
    8. 

  8.             Slog.e(TAG, "Could not parse switch state from event " + event);  
    9. 

  9.         }  
    10. 

  10. }  
    11. 

  11.   
    12. 

  12. private native void native_temperature_update();  
    13. 

  13.   
    14. 

  14. private synchronized final void update(String newName, int newValue){  
    15. 

  15.     if(LOG)  
    16. 

  16.         Slog.v(TAG,"NAME: "+newName+"   VALUE: "+newValue);  
    17. 

  17.     native_temperature_update();  
    18. 

  18.     Slog.v(TAG,"-----value-----"+mTemperatureValue);  
    19. 

  19. }  
    20. 







 


 


至此，我们的分析就结束了，关于jni的用法我就不多说了，提供一些链接，大家可以拿作参考：


http://blog.csdn.net/thl789/article/details/7212822


http://blog.csdn.net/furongkang/article/details/6857610


 


这一部分到此结束，希望写的这些对大家有点帮助。






	
posted on 
2012-03-31 11:56 
猪君 
阅读(1670) 
评论(0) 
编辑 
收藏 
举报












    
    

    
    

    

        

    

        

            

                
            

        

    

    

    

    











	
		

			

			
                
                    

			

                    

	





	Powered by: 博客园
	Copyright © 2024 猪君

Powered by .NET 8.0 on Kubernetes