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方法如何实现的。

[align=left]framework/base/core/java/android/os/UEventObserver.java -- startObserving()[/align]

<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回调函数。

最后贴上时序图：