am 09340a4b: Merge "Replace epoll() with poll() and rename PollLoop to Looper." into gingerbread (14bc6b5d) · Commits · e / os / android_frameworks_base

core/jni/android_app_NativeActivity.cpp

+20 −20

Original line number	Diff line number	Diff line
		@@ -28,7 +28,7 @@
		#include <surfaceflinger/Surface.h>
		#include <ui/egl/android_natives.h>
		#include <ui/InputTransport.h>
		#include <utils/PollLoop.h>
		#include <utils/Looper.h>

		#include "JNIHelp.h"
		#include "android_os_MessageQueue.h"
		@@ -128,17 +128,17 @@ AInputQueue::~AInputQueue() {
		}

		void AInputQueue::attachLooper(ALooper* looper, int ident,
		ALooper_callbackFunc* callback, void* data) {
		mPollLoop = static_cast<android::PollLoop*>(looper);
		mPollLoop->setLooperCallback(mConsumer.getChannel()->getReceivePipeFd(),
		ident, POLLIN, callback, data);
		mPollLoop->setLooperCallback(mDispatchKeyRead,
		ident, POLLIN, callback, data);
		ALooper_callbackFunc callback, void* data) {
		mLooper = static_cast<android::Looper*>(looper);
		mLooper->addFd(mConsumer.getChannel()->getReceivePipeFd(),
		ident, ALOOPER_EVENT_INPUT, callback, data);
		mLooper->addFd(mDispatchKeyRead,
		ident, ALOOPER_EVENT_INPUT, callback, data);
		}

		void AInputQueue::detachLooper() {
		mPollLoop->removeCallback(mConsumer.getChannel()->getReceivePipeFd());
		mPollLoop->removeCallback(mDispatchKeyRead);
		mLooper->removeFd(mConsumer.getChannel()->getReceivePipeFd());
		mLooper->removeFd(mDispatchKeyRead);
		}

		int32_t AInputQueue::hasEvents() {
		@@ -440,8 +440,8 @@ struct NativeCode : public ANativeActivity {
		if (env != NULL && clazz != NULL) {
		env->DeleteGlobalRef(clazz);
		}
		if (pollLoop != NULL && mainWorkRead >= 0) {
		pollLoop->removeCallback(mainWorkRead);
		if (looper != NULL && mainWorkRead >= 0) {
		looper->removeFd(mainWorkRead);
		}
		if (nativeInputQueue != NULL) {
		nativeInputQueue->mWorkWrite = -1;
		@@ -509,7 +509,7 @@ struct NativeCode : public ANativeActivity {
		// These are used to wake up the main thread to process work.
		int mainWorkRead;
		int mainWorkWrite;
		sp<PollLoop> pollLoop;
		sp<Looper> looper;
		};

		void android_NativeActivity_setWindowFormat(
		@@ -541,15 +541,15 @@ void android_NativeActivity_hideSoftInput(
		/*
		* Callback for handling native events on the application's main thread.
		*/
		static bool mainWorkCallback(int fd, int events, void* data) {
		static int mainWorkCallback(int fd, int events, void* data) {
		NativeCode* code = (NativeCode*)data;
		if ((events & POLLIN) == 0) {
		return true;
		return 1;
		}

		ActivityWork work;
		if (!read_work(code->mainWorkRead, &work)) {
		return true;
		return 1;
		}

		LOG_TRACE("mainWorkCallback: cmd=%d", work.cmd);
		@@ -593,7 +593,7 @@ static bool mainWorkCallback(int fd, int events, void* data) {
		break;
		}

		return true;
		return 1;
		}

		// ------------------------------------------------------------------------
		@@ -621,9 +621,9 @@ loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jobject messageQ
		return 0;
		}

		code->pollLoop = android_os_MessageQueue_getPollLoop(env, messageQueue);
		if (code->pollLoop == NULL) {
		LOGW("Unable to retrieve MessageQueue's PollLoop");
		code->looper = android_os_MessageQueue_getLooper(env, messageQueue);
		if (code->looper == NULL) {
		LOGW("Unable to retrieve MessageQueue's Looper");
		delete code;
		return 0;
		}
		@@ -642,7 +642,7 @@ loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jobject messageQ
		result = fcntl(code->mainWorkWrite, F_SETFL, O_NONBLOCK);
		SLOGW_IF(result != 0, "Could not make main work write pipe "
		"non-blocking: %s", strerror(errno));
		code->pollLoop->setCallback(code->mainWorkRead, POLLIN, mainWorkCallback, code);
		code->looper->addFd(code->mainWorkRead, 0, ALOOPER_EVENT_INPUT, mainWorkCallback, code);

		code->ANativeActivity::callbacks = &code->callbacks;
		if (env->GetJavaVM(&code->vm) < 0) {

core/jni/android_hardware_SensorManager.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -60,7 +60,7 @@ sensors_module_get_next_sensor(JNIEnv *env, jobject clazz, jobject sensor, jint

		Sensor const* const* sensorList;
		size_t count = mgr.getSensorList(&sensorList);
		if (next >= count)
		if (size_t(next) >= count)
		return -1;

		Sensor const* const list = sensorList[next];
		@@ -78,7 +78,7 @@ sensors_module_get_next_sensor(JNIEnv *env, jobject clazz, jobject sensor, jint
		env->SetIntField(sensor, sensorOffsets.minDelay, list->getMinDelay());

		next++;
		return next<count ? next : 0;
		return size_t(next) < count ? next : 0;
		}

		//----------------------------------------------------------------------------

core/jni/android_os_MessageQueue.cpp

+11 −11

Original line number	Diff line number	Diff line
		@@ -18,7 +18,7 @@

		#include "JNIHelp.h"

		#include <utils/PollLoop.h>
		#include <utils/Looper.h>
		#include <utils/Log.h>
		#include "android_os_MessageQueue.h"

		@@ -39,22 +39,22 @@ public:
		NativeMessageQueue();
		~NativeMessageQueue();

		inline sp<PollLoop> getPollLoop() { return mPollLoop; }
		inline sp<Looper> getLooper() { return mLooper; }

		bool pollOnce(int timeoutMillis);
		void wake();

		private:
		sp<PollLoop> mPollLoop;
		sp<Looper> mLooper;
		};

		// ----------------------------------------------------------------------------

		NativeMessageQueue::NativeMessageQueue() {
		mPollLoop = PollLoop::getForThread();
		if (mPollLoop == NULL) {
		mPollLoop = new PollLoop(false);
		PollLoop::setForThread(mPollLoop);
		mLooper = Looper::getForThread();
		if (mLooper == NULL) {
		mLooper = new Looper(false);
		Looper::setForThread(mLooper);
		}
		}

		@@ -62,11 +62,11 @@ NativeMessageQueue::~NativeMessageQueue() {
		}

		bool NativeMessageQueue::pollOnce(int timeoutMillis) {
		return mPollLoop->pollOnce(timeoutMillis) != PollLoop::POLL_TIMEOUT;
		return mLooper->pollOnce(timeoutMillis) != ALOOPER_POLL_TIMEOUT;
		}

		void NativeMessageQueue::wake() {
		mPollLoop->wake();
		mLooper->wake();
		}

		// ----------------------------------------------------------------------------
		@@ -83,10 +83,10 @@ static void android_os_MessageQueue_setNativeMessageQueue(JNIEnv* env, jobject m
		reinterpret_cast<jint>(nativeMessageQueue));
		}

		sp<PollLoop> android_os_MessageQueue_getPollLoop(JNIEnv* env, jobject messageQueueObj) {
		sp<Looper> android_os_MessageQueue_getLooper(JNIEnv* env, jobject messageQueueObj) {
		NativeMessageQueue* nativeMessageQueue =
		android_os_MessageQueue_getNativeMessageQueue(env, messageQueueObj);
		return nativeMessageQueue != NULL ? nativeMessageQueue->getPollLoop() : NULL;
		return nativeMessageQueue != NULL ? nativeMessageQueue->getLooper() : NULL;
		}

		static void android_os_MessageQueue_nativeInit(JNIEnv* env, jobject obj) {

core/jni/android_os_MessageQueue.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -21,9 +21,9 @@

		namespace android {

		class PollLoop;
		class Looper;

		extern sp<PollLoop> android_os_MessageQueue_getPollLoop(JNIEnv* env, jobject messageQueueObj);
		extern sp<Looper> android_os_MessageQueue_getLooper(JNIEnv* env, jobject messageQueueObj);

		} // namespace android

core/jni/android_view_InputQueue.cpp

+21 −21

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@

		#include <android_runtime/AndroidRuntime.h>
		#include <utils/Log.h>
		#include <utils/PollLoop.h>
		#include <utils/Looper.h>
		#include <utils/KeyedVector.h>
		#include <utils/threads.h>
		#include <ui/InputTransport.h>
		@@ -77,7 +77,7 @@ private:
		};

		Connection(uint16_t id,
		const sp<InputChannel>& inputChannel, const sp<PollLoop>& pollLoop);
		const sp<InputChannel>& inputChannel, const sp<Looper>& looper);

		inline const char* getInputChannelName() const { return inputChannel->getName().string(); }

		@@ -88,7 +88,7 @@ private:

		sp<InputChannel> inputChannel;
		InputConsumer inputConsumer;
		sp<PollLoop> pollLoop;
		sp<Looper> looper;
		jobject inputHandlerObjGlobal;
		PreallocatedInputEventFactory inputEventFactory;

		@@ -110,7 +110,7 @@ private:
		static void handleInputChannelDisposed(JNIEnv* env,
		jobject inputChannelObj, const sp<InputChannel>& inputChannel, void* data);

		static bool handleReceiveCallback(int receiveFd, int events, void* data);
		static int handleReceiveCallback(int receiveFd, int events, void* data);

		static jlong generateFinishedToken(int32_t receiveFd,
		uint16_t connectionId, uint16_t messageSeqNum);
		@@ -141,7 +141,7 @@ status_t NativeInputQueue::registerInputChannel(JNIEnv* env, jobject inputChanne
		LOGD("channel '%s' - Registered", inputChannel->getName().string());
		#endif

		sp<PollLoop> pollLoop = android_os_MessageQueue_getPollLoop(env, messageQueueObj);
		sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj);

		{ // acquire lock
		AutoMutex _l(mLock);
		@@ -153,7 +153,7 @@ status_t NativeInputQueue::registerInputChannel(JNIEnv* env, jobject inputChanne
		}

		uint16_t connectionId = mNextConnectionId++;
		sp<Connection> connection = new Connection(connectionId, inputChannel, pollLoop);
		sp<Connection> connection = new Connection(connectionId, inputChannel, looper);
		status_t result = connection->inputConsumer.initialize();
		if (result) {
		LOGW("Failed to initialize input consumer for input channel '%s', status=%d",
		@@ -166,7 +166,7 @@ status_t NativeInputQueue::registerInputChannel(JNIEnv* env, jobject inputChanne
		int32_t receiveFd = inputChannel->getReceivePipeFd();
		mConnectionsByReceiveFd.add(receiveFd, connection);

		pollLoop->setCallback(receiveFd, POLLIN, handleReceiveCallback, this);
		looper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
		} // release lock

		android_view_InputChannel_setDisposeCallback(env, inputChannelObj,
		@@ -201,7 +201,7 @@ status_t NativeInputQueue::unregisterInputChannel(JNIEnv* env, jobject inputChan

		connection->status = Connection::STATUS_ZOMBIE;

		connection->pollLoop->removeCallback(inputChannel->getReceivePipeFd());
		connection->looper->removeFd(inputChannel->getReceivePipeFd());

		env->DeleteGlobalRef(connection->inputHandlerObjGlobal);
		connection->inputHandlerObjGlobal = NULL;
		@@ -293,7 +293,7 @@ void NativeInputQueue::handleInputChannelDisposed(JNIEnv* env,
		q->unregisterInputChannel(env, inputChannelObj);
		}

		bool NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* data) {
		int NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* data) {
		NativeInputQueue* q = static_cast<NativeInputQueue*>(data);
		JNIEnv* env = AndroidRuntime::getJNIEnv();

		@@ -308,33 +308,33 @@ bool NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* da
		if (connectionIndex < 0) {
		LOGE("Received spurious receive callback for unknown input channel. "
		"fd=%d, events=0x%x", receiveFd, events);
		return false; // remove the callback
		return 0; // remove the callback
		}

		connection = q->mConnectionsByReceiveFd.valueAt(connectionIndex);
		if (events & (POLLERR \| POLLHUP \| POLLNVAL)) {
		if (events & (ALOOPER_EVENT_ERROR \| ALOOPER_EVENT_HANGUP)) {
		LOGE("channel '%s' ~ Publisher closed input channel or an error occurred. "
		"events=0x%x", connection->getInputChannelName(), events);
		return false; // remove the callback
		return 0; // remove the callback
		}

		if (! (events & POLLIN)) {
		if (! (events & ALOOPER_EVENT_INPUT)) {
		LOGW("channel '%s' ~ Received spurious callback for unhandled poll event. "
		"events=0x%x", connection->getInputChannelName(), events);
		return true;
		return 1;
		}

		status_t status = connection->inputConsumer.receiveDispatchSignal();
		if (status) {
		LOGE("channel '%s' ~ Failed to receive dispatch signal. status=%d",
		connection->getInputChannelName(), status);
		return false; // remove the callback
		return 0; // remove the callback
		}

		if (connection->messageInProgress) {
		LOGW("channel '%s' ~ Publisher sent spurious dispatch signal.",
		connection->getInputChannelName());
		return true;
		return 1;
		}

		status = connection->inputConsumer.consume(& connection->inputEventFactory, & inputEvent);
		@@ -342,7 +342,7 @@ bool NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* da
		LOGW("channel '%s' ~ Failed to consume input event. status=%d",
		connection->getInputChannelName(), status);
		connection->inputConsumer.sendFinishedSignal();
		return true;
		return 1;
		}

		connection->messageInProgress = true;
		@@ -394,7 +394,7 @@ bool NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* da
		connection->getInputChannelName());
		env->DeleteLocalRef(inputHandlerObjLocal);
		q->finished(env, finishedToken, false);
		return true;
		return 1;
		}

		#if DEBUG_DISPATCH_CYCLE
		@@ -417,7 +417,7 @@ bool NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* da

		env->DeleteLocalRef(inputEventObj);
		env->DeleteLocalRef(inputHandlerObjLocal);
		return true;
		return 1;
		}

		jlong NativeInputQueue::generateFinishedToken(int32_t receiveFd, uint16_t connectionId,
		@@ -435,9 +435,9 @@ void NativeInputQueue::parseFinishedToken(jlong finishedToken,
		// ----------------------------------------------------------------------------

		NativeInputQueue::Connection::Connection(uint16_t id,
		const sp<InputChannel>& inputChannel, const sp<PollLoop>& pollLoop) :
		const sp<InputChannel>& inputChannel, const sp<Looper>& looper) :
		id(id), status(STATUS_NORMAL), inputChannel(inputChannel), inputConsumer(inputChannel),
		pollLoop(pollLoop), inputHandlerObjGlobal(NULL),
		looper(looper), inputHandlerObjGlobal(NULL),
		messageSeqNum(0), messageInProgress(false) {
		}