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

原创已于 2025-09-16 12:06:00 修改 · 911 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#android #安卓framework开发 #fw面试 #audio #uevent #Observer #车机

于 2025-09-16 12:05:35 首次发布

audio 专栏收录该内容

23 篇文章

订阅专栏

背景：

经常在做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);

    @UnsupportedAppUsage
    public UEventObserver() {
    }

    @Override
    protected 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.
     */
    @UnsupportedAppUsage
    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);
    }

    /**
     * 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.
     */
    @UnsupportedAppUsage
    public final void stopObserving() {
        final UEventThread t = peekThread();
        if (t != null) {
            t.removeObserver(this);
        }
    }

    /**
     * Subclasses of UEventObserver should override this method to handle
     * UEvents.
     */
    @UnsupportedAppUsage
    public 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");
        }

        @Override
        public void run() {
            nativeSetup();//运行之后主要就是一个nativeSetup初始化

            while (true) {
                String message = nativeWaitForNextEvent();//等待轮询获取message
                if (message != null) {
                    sendEvent(message);//发送Message
                }
            }
        }

        private void sendEvent(String message) {
            synchronized (mKeysAndObservers) {
                final int N = mKeysAndObservers.size();//遍历一个个的observer
                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);//发送给各个observer
                }
                mTempObserversToSignal.clear();
            }
        }

        public void addObserver(String match, UEventObserver observer) {
            synchronized (mKeysAndObservers) {
                mKeysAndObservers.add(match);
                mKeysAndObservers.add(observer);//添加observer
                nativeAddMatch(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 here
    return 0;
}