Merge "Rename functions in InputDispatcher" (3d694145) · Commits · e / os / platform_frameworks_native

services/inputflinger/InputDispatcher.cpp

+22 −22

Original line number	Diff line number	Diff line
		@@ -698,7 +698,7 @@ void InputDispatcher::releaseInboundEventLocked(EventEntry* entry) {
		#if DEBUG_DISPATCH_CYCLE
		ALOGD("Injected inbound event was dropped.");
		#endif
		setInjectionResultLocked(entry, INPUT_EVENT_INJECTION_FAILED);
		setInjectionResult(entry, INPUT_EVENT_INJECTION_FAILED);
		}
		if (entry == mNextUnblockedEvent) {
		mNextUnblockedEvent = nullptr;
		@@ -852,7 +852,7 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,

		// Clean up if dropping the event.
		if (*dropReason != DROP_REASON_NOT_DROPPED) {
		setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
		setInjectionResult(entry, *dropReason == DROP_REASON_POLICY
		? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
		mReporter->reportDroppedKey(entry->sequenceNum);
		return true;
		@@ -866,7 +866,7 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry,
		return false;
		}

		setInjectionResultLocked(entry, injectionResult);
		setInjectionResult(entry, injectionResult);
		if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
		return true;
		}
		@@ -902,7 +902,7 @@ bool InputDispatcher::dispatchMotionLocked(

		// Clean up if dropping the event.
		if (*dropReason != DROP_REASON_NOT_DROPPED) {
		setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
		setInjectionResult(entry, *dropReason == DROP_REASON_POLICY
		? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
		return true;
		}
		@@ -927,7 +927,7 @@ bool InputDispatcher::dispatchMotionLocked(
		return false;
		}

		setInjectionResultLocked(entry, injectionResult);
		setInjectionResult(entry, injectionResult);
		if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
		if (injectionResult != INPUT_EVENT_INJECTION_PERMISSION_DENIED) {
		CancelationOptions::Mode mode(isPointerEvent ?
		@@ -1973,17 +1973,17 @@ void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
		bool wasEmpty = connection->outboundQueue.isEmpty();

		// Enqueue dispatch entries for the requested modes.
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_OUTSIDE);
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_IS);
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);
		enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
		enqueueDispatchEntry(connection, eventEntry, inputTarget,
		InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);

		// If the outbound queue was previously empty, start the dispatch cycle going.
		@@ -1992,7 +1992,7 @@ void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
		}
		}

		void InputDispatcher::enqueueDispatchEntryLocked(
		void InputDispatcher::enqueueDispatchEntry(
		const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget,
		int32_t dispatchMode) {
		int32_t inputTargetFlags = inputTarget->flags;
		@@ -2227,9 +2227,9 @@ void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
		#endif

		// Clear the dispatch queues.
		drainDispatchQueueLocked(&connection->outboundQueue);
		drainDispatchQueue(&connection->outboundQueue);
		traceOutboundQueueLength(connection);
		drainDispatchQueueLocked(&connection->waitQueue);
		drainDispatchQueue(&connection->waitQueue);
		traceWaitQueueLength(connection);

		// The connection appears to be unrecoverably broken.
		@@ -2244,16 +2244,16 @@ void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,
		}
		}

		void InputDispatcher::drainDispatchQueueLocked(Queue<DispatchEntry>* queue) {
		void InputDispatcher::drainDispatchQueue(Queue<DispatchEntry>* queue) {
		while (!queue->isEmpty()) {
		DispatchEntry* dispatchEntry = queue->dequeueAtHead();
		releaseDispatchEntryLocked(dispatchEntry);
		releaseDispatchEntry(dispatchEntry);
		}
		}

		void InputDispatcher::releaseDispatchEntryLocked(DispatchEntry* dispatchEntry) {
		void InputDispatcher::releaseDispatchEntry(DispatchEntry* dispatchEntry) {
		if (dispatchEntry->hasForegroundTarget()) {
		decrementPendingForegroundDispatchesLocked(dispatchEntry->eventEntry);
		decrementPendingForegroundDispatches(dispatchEntry->eventEntry);
		}
		delete dispatchEntry;
		}
		@@ -2400,7 +2400,7 @@ void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(
		target.inputChannel = connection->inputChannel;
		target.flags = InputTarget::FLAG_DISPATCH_AS_IS;

		enqueueDispatchEntryLocked(connection, cancelationEventEntry, // increments ref
		enqueueDispatchEntry(connection, cancelationEventEntry, // increments ref
		&target, InputTarget::FLAG_DISPATCH_AS_IS);

		cancelationEventEntry->release();
		@@ -2960,7 +2960,7 @@ bool InputDispatcher::hasInjectionPermission(int32_t injectorPid, int32_t inject
		\|\| mPolicy->checkInjectEventsPermissionNonReentrant(injectorPid, injectorUid);
		}

		void InputDispatcher::setInjectionResultLocked(EventEntry* entry, int32_t injectionResult) {
		void InputDispatcher::setInjectionResult(EventEntry* entry, int32_t injectionResult) {
		InjectionState* injectionState = entry->injectionState;
		if (injectionState) {
		#if DEBUG_INJECTION
		@@ -3000,7 +3000,7 @@ void InputDispatcher::incrementPendingForegroundDispatches(EventEntry* entry) {
		}
		}

		void InputDispatcher::decrementPendingForegroundDispatchesLocked(EventEntry* entry) {
		void InputDispatcher::decrementPendingForegroundDispatches(EventEntry* entry) {
		InjectionState* injectionState = entry->injectionState;
		if (injectionState) {
		injectionState->pendingForegroundDispatches -= 1;
		@@ -4034,7 +4034,7 @@ void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(
		connection->outboundQueue.enqueueAtHead(dispatchEntry);
		traceOutboundQueueLength(connection);
		} else {
		releaseDispatchEntryLocked(dispatchEntry);
		releaseDispatchEntry(dispatchEntry);
		}
		}

services/inputflinger/InputDispatcher.h

+6 −6

Original line number	Diff line number	Diff line
		@@ -947,11 +947,11 @@ private:
		// Event injection and synchronization.
		std::condition_variable mInjectionResultAvailable;
		bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
		void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult);
		void setInjectionResult(EventEntry* entry, int32_t injectionResult);

		std::condition_variable mInjectionSyncFinished;
		void incrementPendingForegroundDispatches(EventEntry* entry);
		void decrementPendingForegroundDispatchesLocked(EventEntry* entry);
		void decrementPendingForegroundDispatches(EventEntry* entry);

		// Key repeat tracking.
		struct KeyRepeatState {
		@@ -1137,7 +1137,7 @@ private:
		EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock);
		void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
		EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock);
		void enqueueDispatchEntryLocked(const sp<Connection>& connection,
		void enqueueDispatchEntry(const sp<Connection>& connection,
		EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);
		void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)
		REQUIRES(mLock);
		@@ -1145,8 +1145,8 @@ private:
		uint32_t seq, bool handled) REQUIRES(mLock);
		void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
		bool notify) REQUIRES(mLock);
		void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);
		void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);
		void drainDispatchQueue(Queue<DispatchEntry>* queue);
		void releaseDispatchEntry(DispatchEntry* dispatchEntry);
		static int handleReceiveCallback(int fd, int events, void* data);

		void synthesizeCancelationEventsForAllConnectionsLocked(
		@@ -1198,7 +1198,7 @@ private:
		bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
		DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled) REQUIRES(mLock);
		bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
		DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);
		DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled) REQUIRES(mLock);
		void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
		void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);