From 42c03e579aade011b451e2a13ea3f44a2ef0056a Mon Sep 17 00:00:00 2001 From: Dianne Hackborn Date: Tue, 7 Sep 2010 15:28:30 -0700 Subject: [PATCH] Modify native ALooper to take an explicit ident. The ALooper API now uses an explicit "identifier" for the integer that is returned rather than implicitly using the fd. This allows the APIs that had the fd to be a little more sane. Change-Id: I8507f535ad484c0bdc4a1bd016d87bb09acd7ff0 --- core/jni/android_app_NativeActivity.cpp | 7 ++++--- .../android_app_NativeActivity.h | 2 +- include/utils/PollLoop.h | 14 +++++++++++--- libs/gui/SensorEventQueue.cpp | 2 +- libs/utils/PollLoop.cpp | 19 +++++++++++++------ native/android/input.cpp | 4 ++-- native/android/looper.cpp | 4 ++-- native/android/sensor.cpp | 4 ++-- native/include/android/input.h | 4 ++-- native/include/android/looper.h | 16 +++++++++------- native/include/android/sensor.h | 2 +- 11 files changed, 48 insertions(+), 30 deletions(-) diff --git a/core/jni/android_app_NativeActivity.cpp b/core/jni/android_app_NativeActivity.cpp index 0932473aa859c..2517a8a4adaf6 100644 --- a/core/jni/android_app_NativeActivity.cpp +++ b/core/jni/android_app_NativeActivity.cpp @@ -127,12 +127,13 @@ AInputQueue::~AInputQueue() { close(mDispatchKeyWrite); } -void AInputQueue::attachLooper(ALooper* looper, ALooper_callbackFunc* callback, void* data) { +void AInputQueue::attachLooper(ALooper* looper, int ident, + ALooper_callbackFunc* callback, void* data) { mPollLoop = static_cast(looper); mPollLoop->setLooperCallback(mConsumer.getChannel()->getReceivePipeFd(), - POLLIN, callback, data); + ident, POLLIN, callback, data); mPollLoop->setLooperCallback(mDispatchKeyRead, - POLLIN, callback, data); + ident, POLLIN, callback, data); } void AInputQueue::detachLooper() { diff --git a/include/android_runtime/android_app_NativeActivity.h b/include/android_runtime/android_app_NativeActivity.h index c388ba80a3bc0..fdceb84836a4b 100644 --- a/include/android_runtime/android_app_NativeActivity.h +++ b/include/android_runtime/android_app_NativeActivity.h @@ -69,7 +69,7 @@ public: /* Destroys the consumer and releases its input channel. */ ~AInputQueue(); - void attachLooper(ALooper* looper, ALooper_callbackFunc* callback, void* data); + void attachLooper(ALooper* looper, int ident, ALooper_callbackFunc* callback, void* data); void detachLooper(); diff --git a/include/utils/PollLoop.h b/include/utils/PollLoop.h index 81230e84dd988..bc616ebc7d536 100644 --- a/include/utils/PollLoop.h +++ b/include/utils/PollLoop.h @@ -111,12 +111,18 @@ public: * This method can be called on any thread. * This method may block briefly if it needs to wake the poll loop. */ - void setCallback(int fd, int events, Callback callback, void* data = NULL); + void setCallback(int fd, int ident, int events, Callback callback, void* data = NULL); + /** + * Convenience for above setCallback when ident is not used. In this case + * the ident is set to POLL_CALLBACK. + */ + void setCallback(int fd, int events, Callback callback, void* data = NULL); + /** * Like setCallback(), but for the NDK callback function. */ - void setLooperCallback(int fd, int events, ALooper_callbackFunc* callback, + void setLooperCallback(int fd, int ident, int events, ALooper_callbackFunc* callback, void* data); /** @@ -153,11 +159,13 @@ private: struct RequestedCallback { Callback callback; ALooper_callbackFunc* looperCallback; + int ident; void* data; }; struct PendingCallback { int fd; + int ident; int events; Callback callback; ALooper_callbackFunc* looperCallback; @@ -185,7 +193,7 @@ private: void openWakePipe(); void closeWakePipe(); - void setCallbackCommon(int fd, int events, Callback callback, + void setCallbackCommon(int fd, int ident, int events, Callback callback, ALooper_callbackFunc* looperCallback, void* data); ssize_t getRequestIndexLocked(int fd); void wakeAndLock(); diff --git a/libs/gui/SensorEventQueue.cpp b/libs/gui/SensorEventQueue.cpp index 3396f25e714ac..7eb6da5a6e9ba 100644 --- a/libs/gui/SensorEventQueue.cpp +++ b/libs/gui/SensorEventQueue.cpp @@ -86,7 +86,7 @@ sp SensorEventQueue::getPollLoop() const Mutex::Autolock _l(mLock); if (mPollLoop == 0) { mPollLoop = new PollLoop(true); - mPollLoop->setCallback(getFd(), POLLIN, NULL, NULL); + mPollLoop->setCallback(getFd(), getFd(), POLLIN, NULL, NULL); } return mPollLoop; } diff --git a/libs/utils/PollLoop.cpp b/libs/utils/PollLoop.cpp index f740fa0d52557..6d3eeee15cfcd 100644 --- a/libs/utils/PollLoop.cpp +++ b/libs/utils/PollLoop.cpp @@ -95,6 +95,7 @@ void PollLoop::openWakePipe() { RequestedCallback requestedCallback; requestedCallback.callback = NULL; requestedCallback.looperCallback = NULL; + requestedCallback.ident = 0; requestedCallback.data = NULL; mRequestedCallbacks.insertAt(requestedCallback, 0); } @@ -116,7 +117,7 @@ int32_t PollLoop::pollOnce(int timeoutMillis, int* outEvents, void** outData) { mPendingFdsPos++; if (outEvents != NULL) *outEvents = pending.events; if (outData != NULL) *outData = pending.data; - return pending.fd; + return pending.ident; } mLock.lock(); @@ -182,6 +183,7 @@ int32_t PollLoop::pollOnce(int timeoutMillis, int* outEvents, void** outData) { const RequestedCallback& requestedCallback = mRequestedCallbacks.itemAt(i); PendingCallback pending; pending.fd = requestedFd.fd; + pending.ident = requestedCallback.ident; pending.events = revents; pending.callback = requestedCallback.callback; pending.looperCallback = requestedCallback.looperCallback; @@ -191,7 +193,7 @@ int32_t PollLoop::pollOnce(int timeoutMillis, int* outEvents, void** outData) { mPendingCallbacks.push(pending); } else if (pending.fd != mWakeReadPipeFd) { if (result == POLL_CALLBACK) { - result = pending.fd; + result = pending.ident; if (outEvents != NULL) *outEvents = pending.events; if (outData != NULL) *outData = pending.data; } else { @@ -268,16 +270,20 @@ bool PollLoop::getAllowNonCallbacks() const { return mAllowNonCallbacks; } +void PollLoop::setCallback(int fd, int ident, int events, Callback callback, void* data) { + setCallbackCommon(fd, ident, events, callback, NULL, data); +} + void PollLoop::setCallback(int fd, int events, Callback callback, void* data) { - setCallbackCommon(fd, events, callback, NULL, data); + setCallbackCommon(fd, POLL_CALLBACK, events, callback, NULL, data); } -void PollLoop::setLooperCallback(int fd, int events, ALooper_callbackFunc* callback, +void PollLoop::setLooperCallback(int fd, int ident, int events, ALooper_callbackFunc* callback, void* data) { - setCallbackCommon(fd, events, NULL, callback, data); + setCallbackCommon(fd, ident, events, NULL, callback, data); } -void PollLoop::setCallbackCommon(int fd, int events, Callback callback, +void PollLoop::setCallbackCommon(int fd, int ident, int events, Callback callback, ALooper_callbackFunc* looperCallback, void* data) { #if DEBUG_CALLBACKS @@ -305,6 +311,7 @@ void PollLoop::setCallbackCommon(int fd, int events, Callback callback, RequestedCallback requestedCallback; requestedCallback.callback = callback; requestedCallback.looperCallback = looperCallback; + requestedCallback.ident = ident; requestedCallback.data = data; ssize_t index = getRequestIndexLocked(fd); diff --git a/native/android/input.cpp b/native/android/input.cpp index 379960a27c297..c79f913237aed 100644 --- a/native/android/input.cpp +++ b/native/android/input.cpp @@ -246,8 +246,8 @@ float AMotionEvent_getHistoricalOrientation(AInputEvent* motion_event, size_t po void AInputQueue_attachLooper(AInputQueue* queue, ALooper* looper, - ALooper_callbackFunc* callback, void* data) { - queue->attachLooper(looper, callback, data); + int ident, ALooper_callbackFunc* callback, void* data) { + queue->attachLooper(looper, ident, callback, data); } void AInputQueue_detachLooper(AInputQueue* queue) { diff --git a/native/android/looper.cpp b/native/android/looper.cpp index 1564c477d29e7..0aeed7776efe9 100644 --- a/native/android/looper.cpp +++ b/native/android/looper.cpp @@ -72,9 +72,9 @@ void ALooper_release(ALooper* looper) { static_cast(looper)->decStrong((void*)ALooper_acquire); } -void ALooper_addFd(ALooper* looper, int fd, int events, +void ALooper_addFd(ALooper* looper, int fd, int ident, int events, ALooper_callbackFunc* callback, void* data) { - static_cast(looper)->setLooperCallback(fd, events, callback, data); + static_cast(looper)->setLooperCallback(fd, ident, events, callback, data); } int32_t ALooper_removeFd(ALooper* looper, int fd) { diff --git a/native/android/sensor.cpp b/native/android/sensor.cpp index db534e09dab8f..cf7635d2027f0 100644 --- a/native/android/sensor.cpp +++ b/native/android/sensor.cpp @@ -60,12 +60,12 @@ ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type } ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager, - ALooper* looper, ALooper_callbackFunc* callback, void* data) + ALooper* looper, int ident, ALooper_callbackFunc* callback, void* data) { sp queue = static_cast(manager)->createEventQueue(); if (queue != 0) { - ALooper_addFd(looper, queue->getFd(), POLLIN, callback, data); + ALooper_addFd(looper, queue->getFd(), ident, POLLIN, callback, data); queue->looper = looper; queue->incStrong(manager); } diff --git a/native/include/android/input.h b/native/include/android/input.h index 418f6095530ed..5b62da44336ee 100644 --- a/native/include/android/input.h +++ b/native/include/android/input.h @@ -623,10 +623,10 @@ typedef struct AInputQueue AInputQueue; /* * Add this input queue to a looper for processing. See - * ALooper_addFd() for information on the callback and data params. + * ALooper_addFd() for information on the ident, callback, and data params. */ void AInputQueue_attachLooper(AInputQueue* queue, ALooper* looper, - ALooper_callbackFunc* callback, void* data); + int ident, ALooper_callbackFunc* callback, void* data); /* * Remove the input queue from the looper it is currently attached to. diff --git a/native/include/android/looper.h b/native/include/android/looper.h index 2917216246440..287bcd5f00344 100644 --- a/native/include/android/looper.h +++ b/native/include/android/looper.h @@ -111,7 +111,7 @@ enum { * * Returns ALOPER_POLL_ERROR if an error occurred. * - * Returns a value >= 0 containing a file descriptor if it has data + * Returns a value >= 0 containing an identifier if its file descriptor has data * and it has no callback function (requiring the caller here to handle it). * In this (and only this) case outEvents and outData will contain the poll * events and data associated with the fd. @@ -145,10 +145,12 @@ void ALooper_release(ALooper* looper); * descriptor was previously added, it is replaced. * * "fd" is the file descriptor to be added. + * "ident" is an identifier for this event, which is returned from + * ALooper_pollOnce(). Must be >= 0, or ALOOPER_POLL_CALLBACK if + * providing a non-NULL callback. * "events" are the poll events to wake up on. Typically this is POLLIN. * "callback" is the function to call when there is an event on the file * descriptor. - * "id" is an identifier to associated with this file descriptor, or 0. * "data" is a private data pointer to supply to the callback. * * There are two main uses of this function: @@ -156,13 +158,13 @@ void ALooper_release(ALooper* looper); * (1) If "callback" is non-NULL, then * this function will be called when there is data on the file descriptor. It * should execute any events it has pending, appropriately reading from the - * file descriptor. + * file descriptor. The 'ident' is ignored in this case. * - * (2) If "callback" is NULL, the fd will be returned by ALooper_pollOnce - * when it has data available, requiring the caller to take care of processing - * it. + * (2) If "callback" is NULL, the 'ident' will be returned by ALooper_pollOnce + * when its file descriptor has data available, requiring the caller to take + * care of processing it. */ -void ALooper_addFd(ALooper* looper, int fd, int events, +void ALooper_addFd(ALooper* looper, int fd, int ident, int events, ALooper_callbackFunc* callback, void* data); /** diff --git a/native/include/android/sensor.h b/native/include/android/sensor.h index b4ce0242682d8..a102d43c7fcc3 100644 --- a/native/include/android/sensor.h +++ b/native/include/android/sensor.h @@ -166,7 +166,7 @@ ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type * Creates a new sensor event queue and associate it with a looper. */ ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager, - ALooper* looper, ALooper_callbackFunc* callback, void* data); + ALooper* looper, int ident, ALooper_callbackFunc* callback, void* data); /* * Destroys the event queue and free all resources associated to it.