package android.os;
+import android.util.Log;
+
import java.util.ArrayList;
import java.util.HashMap;
* @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 native_setup();
- private static native int next_event(byte[] buffer);
+ private static native void nativeSetup();
+ private static native String nativeWaitForNextEvent();
+ private static native void nativeAddMatch(String match);
+ private static native void nativeRemoveMatch(String match);
public UEventObserver() {
}
+ @Override
protected void finalize() throws Throwable {
try {
stopObserving();
* 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. Use "" to match all
- * UEvent's
+ *
+ * @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.
*/
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);
}
while (offset < length) {
int equals = message.indexOf('=', offset);
- int at = message.indexOf(0, offset);
+ int at = message.indexOf('\0', offset);
if (at < 0) break;
if (equals > offset && equals < at) {
super("UEventObserver");
}
+ @Override
public void run() {
- native_setup();
+ nativeSetup();
- byte[] buffer = new byte[1024];
- int len;
while (true) {
- len = next_event(buffer);
- if (len > 0) {
- sendEvent(new String(buffer, 0, len));
+ String message = nativeWaitForNextEvent();
+ if (message != null) {
+ if (DEBUG) {
+ Log.d(TAG, message);
+ }
+ sendEvent(message);
}
}
}
final int N = mKeysAndObservers.size();
for (int i = 0; i < N; i += 2) {
final String key = (String)mKeysAndObservers.get(i);
- if (message.indexOf(key) != -1) {
+ if (message.contains(key)) {
final UEventObserver observer =
(UEventObserver)mKeysAndObservers.get(i + 1);
mTempObserversToSignal.add(observer);
synchronized (mKeysAndObservers) {
mKeysAndObservers.add(match);
mKeysAndObservers.add(observer);
+ nativeAddMatch(match);
}
}
for (int i = 0; i < mKeysAndObservers.size(); ) {
if (mKeysAndObservers.get(i + 1) == observer) {
mKeysAndObservers.remove(i + 1);
- mKeysAndObservers.remove(i);
+ final String match = (String)mKeysAndObservers.remove(i);
+ nativeRemoveMatch(match);
} else {
i += 2;
}
*/
#define LOG_TAG "UEventObserver"
+//#define LOG_NDEBUG 0
+
#include "utils/Log.h"
#include "hardware_legacy/uevent.h"
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"
-namespace android
-{
+#include <utils/Mutex.h>
+#include <utils/Vector.h>
+#include <utils/String8.h>
+#include <ScopedUtfChars.h>
-static void
-android_os_UEventObserver_native_setup(JNIEnv *env, jclass clazz)
-{
+namespace android {
+
+static Mutex gMatchesMutex;
+static Vector<String8> gMatches;
+
+static void nativeSetup(JNIEnv *env, jclass clazz) {
if (!uevent_init()) {
jniThrowException(env, "java/lang/RuntimeException",
- "Unable to open socket for UEventObserver");
+ "Unable to open socket for UEventObserver");
}
}
-static int
-android_os_UEventObserver_next_event(JNIEnv *env, jclass clazz, jbyteArray jbuffer)
-{
- int buf_sz = env->GetArrayLength(jbuffer);
- char *buffer = (char*)env->GetByteArrayElements(jbuffer, NULL);
+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);
+
+ // Consider all zero-delimited fields of the buffer.
+ const char* field = buffer;
+ const char* end = buffer + length;
+ do {
+ if (strstr(field, match.string())) {
+ ALOGV("Matched uevent message with pattern: %s", match.string());
+ return true;
+ }
+ field += strlen(field) + 1;
+ } while (field != end);
+ }
+ return false;
+}
- int length = uevent_next_event(buffer, buf_sz - 1);
+static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {
+ char buffer[1024];
- env->ReleaseByteArrayElements(jbuffer, (jbyte*)buffer, 0);
+ for (;;) {
+ int length = uevent_next_event(buffer, sizeof(buffer) - 1);
+ if (length <= 0) {
+ return NULL;
+ }
+ buffer[length] = '\0';
- return length;
+ 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);
+ }
+ }
+}
+
+static void nativeAddMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
+ ScopedUtfChars match(env, matchStr);
+
+ AutoMutex _l(gMatchesMutex);
+ gMatches.add(String8(match.c_str()));
+}
+
+static void nativeRemoveMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
+ ScopedUtfChars match(env, matchStr);
+
+ AutoMutex _l(gMatchesMutex);
+ for (size_t i = 0; i < gMatches.size(); i++) {
+ if (gMatches.itemAt(i) == match.c_str()) {
+ gMatches.removeAt(i);
+ break; // only remove first occurrence
+ }
+ }
}
static JNINativeMethod gMethods[] = {
- {"native_setup", "()V", (void *)android_os_UEventObserver_native_setup},
- {"next_event", "([B)I", (void *)android_os_UEventObserver_next_event},
+ { "nativeSetup", "()V",
+ (void *)nativeSetup },
+ { "nativeWaitForNextEvent", "()Ljava/lang/String;",
+ (void *)nativeWaitForNextEvent },
+ { "nativeAddMatch", "(Ljava/lang/String;)V",
+ (void *)nativeAddMatch },
+ { "nativeRemoveMatch", "(Ljava/lang/String;)V",
+ (void *)nativeRemoveMatch },
};
}
return AndroidRuntime::registerNativeMethods(env,
- "android/os/UEventObserver", gMethods, NELEM(gMethods));
+ "android/os/UEventObserver", gMethods, NELEM(gMethods));
}
} // namespace android