android之UEventObserver分析

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

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

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

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

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

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

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

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

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

<span style="font-size:18px;">private static UEventThread getThread() {        synchronized (UEventObserver.class) {            if (sThread == null) {                sThread = new UEventThread();                sThread.start();            }            return sThread;        }    }</span>

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

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

<span style="font-size:18px;">private static final class UEventThread extends Thread {        /** Many to many mapping of string match to observer.         *  Multimap would be better, but not available in android, so use         *  an ArrayList where even elements are the String match and odd         *  elements the corresponding UEventObserver observer */        private final ArrayList<Object> mKeysAndObservers = new ArrayList<Object>();        private final ArrayList<UEventObserver> mTempObserversToSignal =                new ArrayList<UEventObserver>();        public UEventThread() {            super("UEventObserver");        }        @Override        public void run() {            nativeSetup();//jni调用            while (true) {                String message = nativeWaitForNextEvent();                if (message != null) {                    if (DEBUG) {                        Log.d(TAG, message);                    }                    sendEvent(message);                }            }        }        ……    }</span>

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

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

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

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

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

<span style="font-size:18px;">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);}</span>

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

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

<span style="font-size:18px;">static jstring nativeWaitForNextEvent(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);        }    }}</span>

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

<span style="font-size:18px;">int uevent_next_event(char* buffer, int buffer_length){    while (1) {        struct pollfd fds;        int nr;            fds.fd = fd;        fds.events = POLLIN;        fds.revents = 0;        nr = poll(&fds, 1, -1);             if(nr > 0 && (fds.revents & POLLIN)) {            int count = recv(fd, buffer, buffer_length, 0);            if (count > 0) {                struct uevent_handler *h;                pthread_mutex_lock(&uevent_handler_list_lock);                LIST_FOREACH(h, &uevent_handler_list, list)                    h->handler(h->handler_data, buffer, buffer_length);                pthread_mutex_unlock(&uevent_handler_list_lock);                return count;            }         }    }        // won't get here    return 0;}</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()方法如何实现的。

<span style="font-size:18px;"> 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 UEventObserver observer =                                (UEventObserver)mKeysAndObservers.get(i + 1);                        mTempObserversToSignal.add(observer);                    }                }            }            if (!mTempObserversToSignal.isEmpty()) {                final UEvent event = new UEvent(message);                final int N = mTempObserversToSignal.size();                for (int i = 0; i < N; i++) {                    final UEventObserver observer = mTempObserversToSignal.get(i);                    observer.onUEvent(event);                }                mTempObserversToSignal.clear();            }        }</span>

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

最后贴上时序图：