USB线插拔检测使用UEventObserver检测uevent事件的分析

说实话这玩样儿的代码量真的很少，大家如果能耐得住性子啃一会儿也就能撸懂了。

在这之前研究USB线插拔的时候就知道了有这么个东西，当时也就看了看，但没做什么笔记。最近想用起来，却发现就只有个名字在记忆中了。

 

好了，又扯了这么多，来回到正题。

 

首先按照技术博客一贯的作风，得先有个入口点，这里我就先从怎么使用这个UEventObserver开始一步步分析。

 

首先这玩样儿是java代码，所以你就别想着c++什么用了。

 

这里我举例了USB线插拔来分析，代码地址如下：

frameworks/base/services/java/com/android/server/usb/UsbDeviceManager.java    /*    * Listens for uevent messages from the kernel to monitor the USB state    */   private final UEventObserver mUEventObserver = new UEventObserver() {       @Override       public void onUEvent(UEventObserver.UEvent event) {           if (DEBUG) Slog.v(TAG, "USB UEVENT: " + event.toString());            String state =event.get("USB_STATE");           String accessory = event.get("ACCESSORY");           if (state != null) {                mHandler.updateState(state);           } else if ("START".equals(accessory)) {                if (DEBUG) Slog.d(TAG,"got accessory start");                startAccessoryMode();           }       }   };

这里我们可以看到使用前必须先初始化一个新的UEventObserver类来处理事件，即函数onUEvent，这是一个回调函数，之后我们会看到他是怎么被调用的。这里这个回调函数根据处理的事件消息来判断是否要更新USB的状态，继而触发通知栏显示。

 

初始化完UEventObserver之后，我们还需要使用这个类，接下来的代码做了这个事。

 

   private static final String USB_STATE_MATCH =           "DEVPATH=/devices/virtual/android_usb/android0";        public UsbHandler(Looper looper) {           super(looper);                // Watch for USB configurationchanges               mUEventObserver.startObserving(USB_STATE_MATCH);

从中我们看出他直接调用了UEventObserver的startObserving函数，并且指定了参数，即一段字符串。

 

接下来我们看下startObserving到底做了什么事。

    public final void startObserving(String match) {       if (match == null || match.isEmpty()) {           throw new IllegalArgumentException("match substring must benon-empty");       }        final UEventThread t = getThread();       t.addObserver(match, this);    }

这个函数首先会判断是否字符串为空，然后调用getThread来获取UEventThread类，我们来看下getThread

   private static UEventThread getThread() {       synchronized (UEventObserver.class) {           if (sThread == null) {                sThread = new UEventThread();                sThread.start();           }           return sThread;       }    }

我们可以发现，这个函数告诉我们每个UEventObserver类中只有一个UEventThread类。从名字就能看出这货是个处理线程。因为我们这里是第一次进行获取，所以这里会新建一个UEventThread类，并调用start函数启动它。（有些安卓线程经验的同学，应该知道它最终会调用线程类中run函数，具体为神马的请百度吧，或者等我的博客更新）

   private static final class UEventThread extends Thread {        @Override       public void run() {           nativeSetup();            while (true) {                String message =nativeWaitForNextEvent();                if (message != null) {                    if (DEBUG) {                        Log.d(TAG, message);                    }                    sendEvent(message);                }           }       }

我们可以从while循环看出他就是一个不停工作的线程。首先我们先看下nativeSetup做了什么，这货一般你看到就应该知道都是native层实现了，麻溜的就去找对应的cpp文件吧。

frameworks/base/core/jni/android_os_UEventObserver.cpp static void nativeSetup(JNIEnv *env, jclassclazz) {   if (!uevent_init()) {       jniThrowException(env, "java/lang/RuntimeException",                "Unable to open socket forUEventObserver");    }} hardware/libhardware_legacy/uevent/uevent.c int uevent_init(){   struct sockaddr_nl addr;   int sz = 64*1024;   int s;    memset(&addr, 0, sizeof(addr));   addr.nl_family = AF_NETLINK;   addr.nl_pid = getpid();   addr.nl_groups = 0xffffffff;     s= socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);   if(s < 0)       return 0;    setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz));    if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {       close(s);       return 0;    }    fd = s;   return (fd > 0);} 

其实么这个函数调了很多层，最终只是调用了uevent实现里的初始化socket来接收UEVENT消息的，注意这里的接收蔟为NETLINK_KOBJECT_UEVENT，这货好像是全局接收各种uevent的，不只是单单某一种。（具体可以百度下socket知识，我也只是知道个皮毛。）

 

好了建完socket返回fd之后，我们回到UEventThread，他会继续调用native层的nativeWaitForNextEvent来获得一个消息。说实话，以前经常看别人的博客吐槽java层偷懒，时间长了确实感同身受，各种native处理啊。

static jstringnativeWaitForNextEvent(JNIEnv *env, jclass clazz) {   char buffer[1024];    for (;;) {       int length = uevent_next_event(buffer, sizeof(buffer) - 1);       if (length <= 0) {           return NULL;       }       buffer[length] = '\0';        ALOGV("Received uevent message: %s", buffer);        if (isMatch(buffer, length)) {           // Assume the message is ASCII.           jchar message[length];           for (int i = 0; i < length; i++) {                message[i] = buffer[i];           }           return env->NewString(message, length);       }    }}

我们先看下uevent_next_event，它和uevent_init函数一样，都是调到uevent里的。

int uevent_next_event(char* buffer, intbuffer_length){   while (1) {       struct pollfd fds;       int nr;'        nr = poll(&fds, 1, -1);        if(nr > 0 && (fds.revents & POLLIN)) {           int count = recv(fd, buffer, buffer_length, 0);

这个函数其实也很简单，我稍微省略了些内容，它的主要功能就两个，首先调用poll来等socket数据，有数据来的话接收到buffer里，然后返回。

 

好了，回到nativeWaitForNextEvent函数里。在接收到uevent消息后，我们会调用isMatch函数来检测是否匹配。

static bool isMatch(const char* buffer,size_t length) {   AutoMutex _l(gMatchesMutex);    for (size_t i = 0; i < gMatches.size(); i++) {       const String8& match = gMatches.itemAt(i);             if (strstr(field, match.string())) {                ALOGV("Matched ueventmessage with pattern: %s", match.string());                return true;           }

这里就是判断是否这个返回的uevent消息存在于gMatches里，这里大家可能会问gMatches里什么都没有啊，不可能会存在。这时候我们在看下我们当初分析的时候，我们除了启动一个新线程，我们还做了什么。

        final UEventThread t = getThread();       t.addObserver(match, this);

这里我们会调用UEventThread的addObserver函数，参数为传进来的字符串以及新建的UEventObserver，这里我们看下这个函数。

         public void addObserver(String match,UEventObserver observer) {           synchronized (mKeysAndObservers) {                mKeysAndObservers.add(match);               mKeysAndObservers.add(observer);                nativeAddMatch(match);            }       }

这个函数首先会把我们传进来的参数添加到mKeysAndObservers里，并且调用native函数nativeAddMatch添加匹配字符串。

 

static void nativeAddMatch(JNIEnv* env,jclass clazz, jstring matchStr) {   ScopedUtfChars match(env, matchStr);    AutoMutex _l(gMatchesMutex);   gMatches.add(String8(match.c_str()));}

好吧，这里你看到了gMatches了吧，没错他就是记录我们要查询的字符串的。

 

之后我们回到判断gMatches的isMatch函数，这时候我们已经有了一个字符串，如果这时候我们接收的uevent消息里包含了这段字符串就会返回true

 

还记得我们设置的字符串吗

DEVPATH=/devices/virtual/android_usb/android0

一般USB线插拔的时候都会有这段uevent消息来告诉用户所属设配路径。

假设这时候确实插入了USB线，即会返回true

 

那么我们就可以返回nativeWaitForNextEvent函数来看下接下来的处理。

        if (isMatch(buffer, length)) {           // Assume the message is ASCII.           jchar message[length];           for (int i = 0; i < length; i++) {                message[i] = buffer[i];           }           return env->NewString(message, length);       }

之后他会进行保存并返回一个新的字符串，注意这里的字符串类型是jchar，即JAVA中的String类，这样java层才能进行进一步处理。

 

OK，我们也跟着它返回到UEventThread，这时候我们已经得到了一个uevent匹配的消息，然后调用sentEvent进行处理。

                String message = nativeWaitForNextEvent();                if (message != null) {                    if (DEBUG) {                        Log.d(TAG, message);                    }                    sendEvent(message);                }        private void sendEvent(String message) {           synchronized (mKeysAndObservers) {                final int N =mKeysAndObservers.size();                for (int i = 0; i < N; i +=2) {                    final String key =(String)mKeysAndObservers.get(i);                    if (message.contains(key)){                        final UEventObserverobserver =                               (UEventObserver)mKeysAndObservers.get(i + 1);                       mTempObserversToSignal.add(observer);                    }                }           }            if (!mTempObserversToSignal.isEmpty()) {                final UEvent event = newUEvent(message);                final int N =mTempObserversToSignal.size();                for (int i = 0; i < N; i++){                    final UEventObserverobserver = mTempObserversToSignal.get(i);                    observer.onUEvent(event);                }                mTempObserversToSignal.clear();           }       }

这个函数有点长，但是做的事情一目了览，首先它会根据返回的消息在mKeysAndObservers查找UEventObserver，如果有匹配的话就返回下一个类，还记得我们在之前添加的两个参数吗，即查询字符串和UEventObserver类。这里他就会找到UEventObserver，并且添加到mTempObserversToSignal里。当所有匹配的UEventObserver被添加完后，循环调用每个类的onUEvent回调函数。这个函数我们已经在一开始新建UEventObserver的时候实现过了。

    /*    * Listens for uevent messages from the kernel to monitor the USB state    */   private final UEventObserver mUEventObserver = new UEventObserver() {       @Override       public void onUEvent(UEventObserver.UEvent event) {           if (DEBUG) Slog.v(TAG, "USB UEVENT: " + event.toString());            String state =event.get("USB_STATE");           if (state != null) {                mHandler.updateState(state);

这样我们就把UEventObserver说清楚了，大家觉得是不是很简单呢，但是说实话这货确实是java层检测硬件变化的好帮手，推荐使用。

 

最后做个总结，我画了张简单的流程图，大家凑合着看就行了。