android之UEventObserver分析和用法

from http://blog.csdn.net/yaphet__s/article/details/48136897

android之UEventObserver分析

众所周知，在安卓系统中有状态栏，不管是手机还是电视，在插入外设的时候，会在顶部状态栏显示小图标。比如，camera设备，耳机设备，U盘，以及电池等等。这些都需要在状态栏动态显示。

从上面这张图片可以看出这些设备都有自己的服务一直在跑，并且都是继承了UEventObserver.Java这个类去获取kernel的Event事件。下面将着重分析UEventObserver是如何去监听kernel的Event事件。

以Camera为例，CameraObserver会调用EventObserver的StartObserving方法并重写onEvent方法，从下面的代码看出startobserving会传入一个参数CAMERA_UEVENT_MATCH.

[java]  view plain  copy

1. <span style="font-size:18px;">public CameraObserver(Context context) {  
2.         mContext = context;  
3.         startObserving(CAMERA_UEVENT_MATCH);  
4.   
5.     }  
6.   
7.     @Override  
8.     public void onUEvent(UEventObserver.UEvent event) {  
9.      ……    //检测到Event事件之后，发广播等等  
10.     ｝</span>  

找到UEventObserver看startobserving方法如何实现的。

framework/base/core/java/android/os/UEventObserver.java -- startObserving()

[java]  view plain  copy

1. <span style="font-size:18px;">public final void startObserving(String match) {  
2.         if (match == null || match.isEmpty()) {  
3.             throw new IllegalArgumentException("match substring must be non-empty");  
4.         }  
5.   
6.         final UEventThread t = getThread();  
7.         t.addObserver(match, this);  
8.     }   
9. </span>  

函数一开始先判断match（前一个代码片段所传入的参数是CAMERA_UEVENT_MATCH）是否为空，如果不为空会做两个动作，调用getThread()方法来获取UEventThread实例t，然后调用t的addObserver()方法。

framework/base/core/java/Android/os/UEventObserver.java  -- getThread()

[java]  view plain  copy

1. <span style="font-size:18px;">private static UEventThread getThread() {  
2.         synchronized (UEventObserver.class) {  
3.             if (sThread == null) {  
4.                 sThread = new UEventThread();  
5.                 sThread.start();  
6.             }  
7.             return sThread;  
8.         }  
9.     }  
10. </span>  

这个函数比较简单，首先判断sThread是否为NULL，为空就新建一个UEventThread线程，如果不为空，就直接返回线程。因为很多外设的Observer都是继承UEventObserver，所以sThread是static变量，只要被第一次创建后，这个值就不会为NULL，这样就能做到多个外设通过一个线程来监控。进入到UEventThread看一下。

framework/base/core/java/android/os/UEventObserver.java -- UEventThread()

[java]  view plain  copy

1. <span style="font-size:18px;">private static final class UEventThread extends Thread {  
2.         /** Many to many mapping of string match to observer. 
3.          *  Multimap would be better, but not available in android, so use 
4.          *  an ArrayList where even elements are the String match and odd 
5.          *  elements the corresponding UEventObserver observer */  
6.         private final ArrayList<Object> mKeysAndObservers = new ArrayList<Object>();  
7.   
8.         private final ArrayList<UEventObserver> mTempObserversToSignal =  
9.                 new ArrayList<UEventObserver>();  
10.   
11.         public UEventThread() {  
12.             super("UEventObserver");  
13.         }  
14.   
15.         @Override  
16.         public void run() {  
17.             nativeSetup();//jni调用  
18.   
19.             while (true) {  
20.                 String message = nativeWaitForNextEvent();  
21.                 if (message != null) {  
22.                     if (DEBUG) {  
23.                         Log.d(TAG, message);  
24.                     }  
25.                     sendEvent(message);  
26.                 }  
27.             }  
28.         }  
29.         ……  
30.     }  
31. </span>  

当第一次启动这个线程的时候，会调用nativeSetup()方法做初始化，从名字可以看出这个函数是native层来实现的。初始化完之后，进入一个while的死循环，不停的调用native层的nativeWaitForNextEvent()函数来获取Event事件，然后将Event事件转换成message，再通过sendEvent()将message事件传递给外设对应的Observer。先看一下初始化过程，nativeSetup()。

framework/base/core/jni/android_os_UEventObserver.cpp -- nativeSetup()

[java]  view plain  copy

1. <span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">static void nativeSetup(JNIEnv *env, jclass clazz) {  
2.     if (!uevent_init()) {  
3.         jniThrowException(env, "java/lang/RuntimeException",  
4.                 "Unable to open socket for UEventObserver");  
5.     }  
6. }  
7. </span>  

这个函数比较简单，就调用uevent_init()函数来做初始化，这个函数是一个C函数，实现在Uevent.c文件中。

hardware/libhardware_legacy/uevent/Uevent.c -- uevent_init()

[cpp]  view plain  copy

1. <span style="font-size:18px;">int uevent_init()  
2. {  
3.     struct sockaddr_nl addr;  
4.     int sz = 64*1024;  
5.     int s;  
6.   
7.     memset(&addr, 0, sizeof(addr));  
8.     addr.nl_family = AF_NETLINK;放  
9.     addr.nl_pid = getpid();  
10.     addr.nl_groups = 0xffffffff;  
11.   
12.     s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);  
13.     if(s < 0)  
14.         return 0;  
15.   
16.     setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz));  
17.   
18.     if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {  
19.         close(s);  
20.         return 0;  
21.     }  
22.   
23.     fd = s;  
24.     return (fd > 0);  
25. }  
26. </span>  

初始化socket，用来接收来自内核的event事件。从这个代码可以看出，用户空间是用socket和内核通信的。初始化完之后就等待接受内核的Event事件。我们回到run()方法里面。初始化完了之后进入到while循环，不停地调用nativeWaitForNextEvent()。

framework/base/core/jni/android_os_UEventObserver.cpp -- nativeWaitForNextEvent()

[cpp]  view plain  copy

1. <span style="font-size:18px;">static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {  
2.     char buffer[1024];  
3.   
4.     for (;;) {  
5.         int length = uevent_next_event(buffer, sizeof(buffer) - 1);  
6.         if (length <= 0) {  
7.             return NULL;  
8.         }  
9.         buffer[length] = '\0';  
10.   
11.         ALOGV("Received uevent message: %s", buffer);  
12.   
13.         if (isMatch(buffer, length)) {  
14.             // Assume the message is ASCII.  
15.             jchar message[length];  
16.             for (int i = 0; i < length; i++) {  
17.                 message[i] = buffer[i];  
18.             }  
19.             return env->NewString(message, length);  
20.         }  
21.     }  
22. }  
23. </span>  

这个函数又是一个死循环，不停地调用uevent_next_event()，从传入的参数可以看出，从kernel传出来的event事件存在buffer中，紧接着调用isMatch判断buffer的数据是否匹配，如果匹配就将buffer的数据转换成message，抛给上层server。

[cpp]  view plain  copy

1. <span style="font-size:18px;">int uevent_next_event(char* buffer, int buffer_length)  
2. {  
3.     while (1) {  
4.         struct pollfd fds;  
5.         int nr;  
6.       
7.         fds.fd = fd;  
8.         fds.events = POLLIN;  
9.         fds.revents = 0;  
10.         nr = poll(&fds, 1, -1);  
11.        
12.         if(nr > 0 && (fds.revents & POLLIN)) {  
13.             int count = recv(fd, buffer, buffer_length, 0);  
14.             if (count > 0) {  
15.                 struct uevent_handler *h;  
16.                 pthread_mutex_lock(&uevent_handler_list_lock);  
17.                 LIST_FOREACH(h, &uevent_handler_list, list)  
18.                     h->handler(h->handler_data, buffer, buffer_length);  
19.                 pthread_mutex_unlock(&uevent_handler_list_lock);  
20.   
21.                 return count;  
22.             }   
23.         }  
24.     }  
25.       
26.     // won't get here  
27.     return 0;  
28. }</span>  

这个函数定义在Uevent.c中，死循环，不停的调用poll来等待socket的数据，并将数据存放在buffer中，然后返回。数据返回后，会调用isMatch()函数来判断buffer的数据是否匹配。isMatch比较简单，就是for循环将buffer中的数据和gMatches比较，如果匹配返回true。回到nativeWaitForNextEvent()函数中，匹配OK之后，将buffer中的数据转换成message并return给Java层。返回到UEventThread的run()方法中，如果message不为空，则调用sendEvent()方法将message传递给apk。最后看一下sendEvent()方法如何实现的。

[cpp]  view plain  copy

1. <span style="font-size:18px;"> private void sendEvent(String message) {  
2.             synchronized (mKeysAndObservers) {  
3.                 final int N = mKeysAndObservers.size();  
4.                 for (int i = 0; i < N; i += 2) {  
5.                     final String key = (String)mKeysAndObservers.get(i);  
6.                     if (message.contains(key)) {  
7.                         final UEventObserver observer =  
8.                                 (UEventObserver)mKeysAndObservers.get(i + 1);  
9.                         mTempObserversToSignal.add(observer);  
10.                     }  
11.                 }  
12.             }  
13.   
14.             if (!mTempObserversToSignal.isEmpty()) {  
15.                 final UEvent event = new UEvent(message);  
16.                 final int N = mTempObserversToSignal.size();  
17.                 for (int i = 0; i < N; i++) {  
18.                     final UEventObserver observer = mTempObserversToSignal.get(i);  
19.                     observer.onUEvent(event);  
20.                 }  
21.                 mTempObserversToSignal.clear();  
22.             }  
23.         }  
24. </span>  

之前我们知道在AddObserver()方法中的          mKeysAndObservers.add(match)和mKeysAndObservers.add(observer);将查询字符串match和UEventObserver类添加到mKeysAndObservers中。在此方法中将之前返回的message和match匹配，如果匹配将对应的UEventObserver添加到mtempObserversToSignal里。当所有的UEventObserver被添加完之后，循环调用每一个类的onUEvent回调函数。

最后贴上时序图：

from :　http://blog.csdn.net/lushengchu_luis/article/details/9466405

android UEventObserver的用法

在Android的framework中想要监听底层的uevent事件是一件很简单的事情,只要以下几个步骤即可，拿UsbDeviceManager.Java为例子。

首先，创建一个UEventObserver类：

[cpp]  view plain  copy

1. private final UEventObserver mUEventObserver = new UEventObserver() {                                                                                        
2.     @Override  
3.     public void onUEvent(UEventObserver.UEvent event) {  
4.         if (DEBUG) Slog.v(TAG, "USB UEVENT: " + event.toString());  
5.   
6.         String state = event.get("USB_STATE");  
7.         String accessory = event.get("ACCESSORY");  
8.         if (state != null) {  
9.             mHandler.updateState(state);  
10.         } else if ("START".equals(accessory)) {  
11.             if (DEBUG) Slog.d(TAG, "got accessory start");  
12.             startAccessoryMode();  
13.         }  
14.     }  
15. };  

在这个类中要重写onUevent方法，在该方法中处理你得到的事件。

接着，调用startObserving方法即可：

[cpp]  view plain  copy

1. mUEventObserver.startObserving(USB_STATE_MATCH);                                                                                                 
2. mUEventObserver.startObserving(ACCESSORY_START_MATCH);  

这里：

[cpp]  view plain  copy

1. private static final String USB_STATE_MATCH =                                                                                                                
2.         "DEVPATH=/devices/virtual/android_usb/android0";  
3. private static final String ACCESSORY_START_MATCH =                                                                                                          
4.         "DEVPATH=/devices/virtual/misc/usb_accessory";  

这样就可以监听上述路径下的uevent事件了。是不是很简单！