当前位置：首页 > news >正文

Android系统基础：底层状态监听UEvent之UEventObserver源码分析

news 2025/9/17 6:59:20

背景：

经常在做framework相关开发时候，会有一些需求需要对系统的一些状态进行监听，获取相关的一些硬件信息，比如usb插入事件，耳机插拔等。这时候经常在framework层面我们只需要使用一下UEventObserver监听就可以了，比如耳机插拔就是WiredAccessoryManager的WiredAccessoryObserver里面onEvent会进行回调。
在这里插入图片描述
但请问这里的onEvent为啥就可以被回调呢？底层原理是什么呢？

Uevent 是什么？

Uevent （User space event）直译为“用户空间事件”。它是 Linux 内核的一种通信机制，专门用于向用户空间程序广播内核中发生的硬件设备相关事件。

你可以把它想象成一个安装在内核里的超级高效的内部广播系统。每当有新的硬件设备加入（如插入USB）、现有设备状态改变（如电量变化）或设备被移除（如拔出耳机）时，这个广播系统就会立刻拉起警报，高声通告：“注意！注意！有设备发生了变化！”，并附带上一份详细的“事件说明书”。

在 Android 这个复杂的生态中，正是依靠 Uevent 这个信使，系统服务才能对硬件变化做出即时反应，实现流畅的“热插拔”体验。

Uevent 的传递主要依靠一种高效的通信方式：Netlink Socket。

Netlink的介绍

Netlink是Linux系统中一种用户空间进程和Kernel进行通信的机制，通过这个机制，位于用户空间的进程，可接收来自Kernel的一些信息（例如Vold中用到的USB或SD的插拔消息），同时应用层也可通过Netlink向Kernel发送一些控制命令。

UEventObserver部分源码剖析

frameworks/base/core/java/android/os/UEventObserver.java


/*** UEventObserver is an abstract class that receives UEvents from the kernel.<p>** Subclass UEventObserver, implementing onUEvent(UEvent event), then call* startObserving() with a match string. The UEvent thread will then call your* onUEvent() method when a UEvent occurs that contains your match string.<p>** Call stopObserving() to stop receiving UEvents.<p>** There is only one UEvent thread per process, even if that process has* multiple UEventObserver subclass instances. The UEvent thread starts when* the startObserving() is called for the first time in that process. Once* started the UEvent thread will not stop (although it can stop notifying* UEventObserver's via stopObserving()).<p>** @hide
*/
public abstract class UEventObserver {private static final String TAG = "UEventObserver";private static final boolean DEBUG = false;private static UEventThread sThread;private static native void nativeSetup();private static native String nativeWaitForNextEvent();private static native void nativeAddMatch(String match);private static native void nativeRemoveMatch(String match);@UnsupportedAppUsagepublic UEventObserver() {}@Overrideprotected void finalize() throws Throwable {try {stopObserving();} finally {super.finalize();}}private static UEventThread getThread() {synchronized (UEventObserver.class) {if (sThread == null) {sThread = new UEventThread();sThread.start();}return sThread;}}private static UEventThread peekThread() {synchronized (UEventObserver.class) {return sThread;}}/*** Begin observation of UEvents.<p>* This method will cause the UEvent thread to start if this is the first* invocation of startObserving in this process.<p>* Once called, the UEvent thread will call onUEvent() when an incoming* UEvent matches the specified string.<p>* This method can be called multiple times to register multiple matches.* Only one call to stopObserving is required even with multiple registered* matches.** @param match A substring of the UEvent to match.  Try to be as specific* as possible to avoid incurring unintended additional cost from processing* irrelevant messages.  Netlink messages can be moderately high bandwidth and* are expensive to parse.  For example, some devices may send one netlink message* for each vsync period.*/@UnsupportedAppUsagepublic 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);}/*** End observation of UEvents.<p>* This process's UEvent thread will never call onUEvent() on this* UEventObserver after this call. Repeated calls have no effect.*/@UnsupportedAppUsagepublic final void stopObserving() {final UEventThread t = peekThread();if (t != null) {t.removeObserver(this);}}/*** Subclasses of UEventObserver should override this method to handle* UEvents.*/@UnsupportedAppUsagepublic abstract void onUEvent(UEvent event);

主要看看使用的UEventThread执行部分代码：

    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");}@Overridepublic void run() {nativeSetup();//运行之后主要就是一个nativeSetup初始化while (true) {String message = nativeWaitForNextEvent();//等待轮询获取messageif (message != null) {sendEvent(message);//发送Message}}}private void sendEvent(String message) {synchronized (mKeysAndObservers) {final int N = mKeysAndObservers.size();//遍历一个个的observerfor (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);//发送给各个observer}mTempObserversToSignal.clear();}}public void addObserver(String match, UEventObserver observer) {synchronized (mKeysAndObservers) {mKeysAndObservers.add(match);mKeysAndObservers.add(observer);//添加observernativeAddMatch(match);}}

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

重点看看nativeSetup和nativeWaitForNextEvent看看它们底层是桌面实现的
nativeSetup方法

static void nativeSetup(JNIEnv *env, jclass clazz) {if (!uevent_init()) {jniThrowException(env, "java/lang/RuntimeException","Unable to open socket for UEventObserver");}
}

uevent_init方法如下

hardware/libhardware_legacy/uevent.c
/* Returns 0 on failure, 1 on success */
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);
}

这里可以这里核心就是创建一个PF_NETLINK的socket与内核进行通讯，接受来自内核的消息

nativeWaitForNextEvent

static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {char buffer[1024];for (;;) {int length = uevent_next_event(buffer, sizeof(buffer) - 1);//进行等待uevent事件if (length <= 0) {return NULL;}buffer[length] = '\0';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，它来不断的等待读取上面创建的socket中内核发来的消息。

uevent_next_event方法如下

hardware/libhardware_legacy/uevent.c
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);//进行poll等待if(nr > 0 && (fds.revents & POLLIN)) {int count = recv(fd, buffer, buffer_length, 0);//读取socket数据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 herereturn 0;
}