Merge changes I50eb7dcf,I7ae92ce1,Icb22db1c into jb-mr1-dev (60fa4617) · Commits · e / os / android_frameworks_base

core/java/android/os/UEventObserver.java

+33 −13

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@

		package android.os;

		import android.util.Log;

		import java.util.ArrayList;
		import java.util.HashMap;

		@@ -37,14 +39,20 @@ 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();
		@@ -78,10 +86,18 @@ public abstract class UEventObserver {
		* 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);
		}
		@@ -117,7 +133,7 @@ public abstract class UEventObserver {

		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) {
		@@ -158,15 +174,17 @@ public abstract class UEventObserver {
		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);
		}
		}
		}
		@@ -176,7 +194,7 @@ public abstract class UEventObserver {
		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);
		@@ -199,6 +217,7 @@ public abstract class UEventObserver {
		synchronized (mKeysAndObservers) {
		mKeysAndObservers.add(match);
		mKeysAndObservers.add(observer);
		nativeAddMatch(match);
		}
		}

		@@ -208,7 +227,8 @@ public abstract class UEventObserver {
		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;
		}

core/jni/android_os_UEventObserver.cpp

+79 −17

Original line number	Diff line number	Diff line
		@@ -15,6 +15,8 @@
		*/

		#define LOG_TAG "UEventObserver"
		//#define LOG_NDEBUG 0

		#include "utils/Log.h"

		#include "hardware_legacy/uevent.h"
		@@ -22,34 +24,94 @@
		#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");
		}
		}

		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;
		}

		static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {
		char buffer[1024];

		int length = uevent_next_event(buffer, buf_sz - 1);
		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);
		}
		}
		}

		static void nativeAddMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
		ScopedUtfChars match(env, matchStr);

		AutoMutex _l(gMatchesMutex);
		gMatches.add(String8(match.c_str()));
		}

		env->ReleaseByteArrayElements(jbuffer, (jbyte*)buffer, 0);
		static void nativeRemoveMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
		ScopedUtfChars match(env, matchStr);

		return length;
		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 },
		};

policy/src/com/android/internal/policy/impl/PhoneWindowManager.java

+5 −5

Original line number	Diff line number	Diff line
		@@ -3692,11 +3692,6 @@ public class PhoneWindowManager implements WindowManagerPolicy {
		updateLockScreenTimeout();
		}

		try {
		mWindowManager.setEventDispatching(true);
		} catch (RemoteException unhandled) {
		}

		waitForKeyguard(screenOnListener);
		}

		@@ -3747,6 +3742,11 @@ public class PhoneWindowManager implements WindowManagerPolicy {
		mScreenOnFully = true;
		}

		try {
		mWindowManager.setEventDispatching(true);
		} catch (RemoteException unhandled) {
		}

		if (screenOnListener != null) {
		screenOnListener.onScreenOn();
		}

services/java/com/android/server/power/ElectronBeam.java

+18 −0

Original line number	Diff line number	Diff line
		@@ -63,6 +63,11 @@ final class ElectronBeam {
		private static final float HSTRETCH_DURATION = 0.5f;
		private static final float VSTRETCH_DURATION = 1.0f - HSTRETCH_DURATION;

		// The number of frames to draw when preparing the animation so that it will
		// be ready to run smoothly. We use 3 frames because we are triple-buffered.
		// See code for details.
		private static final int DEJANK_FRAMES = 3;

		// Set to true when the animation context has been fully prepared.
		private boolean mPrepared;
		private int mMode;
		@@ -145,6 +150,19 @@ final class ElectronBeam {

		// Done.
		mPrepared = true;

		// Dejanking optimization.
		// Some GL drivers can introduce a lot of lag in the first few frames as they
		// initialize their state and allocate graphics buffers for rendering.
		// Work around this problem by rendering the first frame of the animation a few
		// times. The rest of the animation should run smoothly thereafter.
		// The frames we draw here aren't visible because we are essentially just
		// painting the screenshot as-is.
		if (mode == MODE_COOL_DOWN) {
		for (int i = 0; i < DEJANK_FRAMES; i++) {
		draw(1.0f);
		}
		}
		return true;
		}