Merge "Remove non-split touch from input code" into main (a1635a6f) · Commits · e / os / android_frameworks_native

libs/gui/WindowInfo.cpp

+0 −4

Original line number	Diff line number	Diff line
		@@ -99,10 +99,6 @@ void WindowInfo::addTouchableRegion(const Rect& region) {
		touchableRegion.orSelf(region);
		}

		bool WindowInfo::supportsSplitTouch() const {
		return !inputConfig.test(InputConfig::PREVENT_SPLITTING);
		}

		bool WindowInfo::isSpy() const {
		return inputConfig.test(InputConfig::SPY);
		}

libs/gui/include/gui/WindowInfo.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -150,8 +150,6 @@ struct WindowInfo : public Parcelable {
		static_cast<uint32_t>(os::InputConfig::NOT_FOCUSABLE),
		NOT_TOUCHABLE =
		static_cast<uint32_t>(os::InputConfig::NOT_TOUCHABLE),
		PREVENT_SPLITTING =
		static_cast<uint32_t>(os::InputConfig::PREVENT_SPLITTING),
		DUPLICATE_TOUCH_TO_WALLPAPER =
		static_cast<uint32_t>(os::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER),
		IS_WALLPAPER =

libs/input/android/os/InputConfig.aidl

+3 −10

Original line number	Diff line number	Diff line
		@@ -57,16 +57,9 @@ enum InputConfig {
		NOT_TOUCHABLE = 1 << 3,

		/**
		* Indicates that this window will not accept a touch event that is split between
		* more than one window. When set:
		* - If this window receives a DOWN event with the first pointer, all successive
		* pointers that go down, regardless of their location on the screen, will be
		* directed to this window;
		* - If the DOWN event lands outside the touchable bounds of this window, no
		* successive pointers that go down, regardless of their location on the screen,
		* will be directed to this window.
		*/
		PREVENT_SPLITTING = 1 << 4,
		* This flag is now deprecated and should not be used.
		*/
		DEPRECATED_PREVENT_SPLITTING = 1 << 4,

		/**
		* Indicates that this window shows the wallpaper behind it, so all touch events

libs/input/input_flags.aconfig

+2 −2

Original line number	Diff line number	Diff line
		@@ -37,9 +37,9 @@ flag {
		}

		flag {
		name: "split_all_touches"
		name: "deprecate_split_touch_apis"
		namespace: "input"
		description: "Set FLAG_SPLIT_TOUCHES to true for all windows, regardless of what they specify. This is essentially deprecating this flag by forcefully enabling the split functionality"
		description: "Deprecate all public APIs related to split touch because now all windows behave as if split touch is permanently enabled and there's no way for a window to disable split touch."
		bug: "239934827"
		}

services/inputflinger/dispatcher/InputDispatcher.cpp

+13 −98

Original line number	Diff line number	Diff line
		@@ -788,38 +788,14 @@ void filterUntrustedTargets(TouchState& touchState, std::vector<InputTarget>& ta
		});
		}

		/**
		* In general, touch should be always split between windows. Some exceptions:
		* 1. Don't split touch if all of the below is true:
		* (a) we have an active pointer down and
		* (b) a new pointer is going down that's from the same device and
		* (c) the window that's receiving the current pointer does not support split touch.
		* 2. Don't split mouse events
		*/
		bool shouldSplitTouch(const TouchState& touchState, const MotionEntry& entry) {
		if (isFromSource(entry.source, AINPUT_SOURCE_MOUSE)) {
		// We should never split mouse events
		return false;
		}
		for (const TouchedWindow& touchedWindow : touchState.windows) {
		if (touchedWindow.windowHandle->getInfo()->isSpy()) {
		// Spy windows should not affect whether or not touch is split.
		continue;
		}
		if (touchedWindow.windowHandle->getInfo()->supportsSplitTouch()) {
		continue;
		}
		if (touchedWindow.windowHandle->getInfo()->inputConfig.test(
		gui::WindowInfo::InputConfig::IS_WALLPAPER)) {
		// Wallpaper window should not affect whether or not touch is split
		continue;
		}

		if (touchedWindow.hasTouchingPointers(entry.deviceId)) {
		return false;
		}
		}
		return true;
		bool shouldSplitTouch(int32_t source) {
		// We should never split mouse events. This is because the events that are produced by touchpad
		// are sent to InputDispatcher as two fingers (for example, pinch zoom), but they need to be
		// dispatched to the same window. In those cases, the behaviour is also slightly different from
		// default because the events should be sent to the cursor position rather than the x,y values
		// of each of the fingers.
		// The "normal" (uncaptured) events produced by touchpad and by mouse have SOURCE_MOUSE.
		return !isFromSource(source, AINPUT_SOURCE_MOUSE);
		}

		/**
		@@ -1528,21 +1504,9 @@ std::vector<sp<WindowInfoHandle>> InputDispatcher::DispatcherWindowInfo::findTou
		const WindowInfo& info = *windowHandle->getInfo();
		if (!windowAcceptsTouchAt(info, displayId, x, y, isStylus,
		getDisplayTransform(displayId))) {
		// Generally, we would skip any pointer that's outside of the window. However, if the
		// spy prevents splitting, and already has some of the pointers from this device, then
		// it should get more pointers from the same device, even if they are outside of that
		// window
		if (info.supportsSplitTouch()) {
		continue;
		}

		// We know that split touch is not supported. Skip this window only if it doesn't have
		// any touching pointers for this device already.
		if (!windowHasTouchingPointers(windowHandle, deviceId, touchStatesByDisplay)) {
		// Skip if the pointer is outside of the window.
		continue;
		}
		// If it already has pointers down for this device, then give it this pointer, too.
		}
		if (!info.isSpy()) {
		// The first touched non-spy window was found, so return the spy windows touched so far.
		return spyWindows;
		@@ -2448,7 +2412,7 @@ InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, const Motio
		tempTouchState = *oldState;
		}

		bool isSplit = shouldSplitTouch(tempTouchState, entry);
		bool isSplit = shouldSplitTouch(entry.source);

		const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE \|\|
		maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER \|\|
		@@ -2501,17 +2465,6 @@ InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, const Motio
		LOG_IF(INFO, newTouchedWindowHandle == nullptr)
		<< "No new touched window at (" << std::format("{:.1f}, {:.1f}", x, y)
		<< ") in display " << displayId;
		// Handle the case where we did not find a window.
		if (!input_flags::split_all_touches()) {
		// If we are force splitting all touches, then touches outside of the window should
		// be dropped, even if this device already has pointers down in another window.
		if (newTouchedWindowHandle == nullptr) {
		// Try to assign the pointer to the first foreground window we find, if there is
		// one.
		newTouchedWindowHandle =
		tempTouchState.getFirstForegroundWindowHandle(entry.deviceId);
		}
		}

		// Verify targeted injection.
		if (const auto err = verifyTargetedInjection(newTouchedWindowHandle, entry); err) {
		@@ -2519,24 +2472,7 @@ InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, const Motio
		return injectionError(InputEventInjectionResult::TARGET_MISMATCH);
		}

		// Figure out whether splitting will be allowed for this window.
		if (newTouchedWindowHandle != nullptr) {
		if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
		// New window supports splitting, but we should never split mouse events.
		isSplit = !isFromMouse;
		} else if (isSplit) {
		// New window does not support splitting but we have already split events.
		// Ignore the new window.
		LOG(INFO) << "Skipping " << newTouchedWindowHandle->getName()
		<< " because it doesn't support split touch";
		newTouchedWindowHandle = nullptr;
		}
		} else {
		// No window is touched, so set split to true. This will allow the next pointer down to
		// be delivered to a new window which supports split touch. Pointers from a mouse device
		// should never be split.
		isSplit = !isFromMouse;
		}

		std::vector<sp<WindowInfoHandle>> newTouchedWindows =
		mWindowInfos.findTouchedSpyWindowsAt(displayId, x, y, isStylus, entry.deviceId,
		@@ -2711,9 +2647,7 @@ InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime, const Motio
		targets);

		// Make a slippery entrance into the new window.
		if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
		isSplit = !isFromMouse;
		}

		ftl::Flags<InputTarget::Flags> targetFlags;
		if (canReceiveForegroundTouches(*newTouchedWindowHandle->getInfo())) {
		@@ -5845,18 +5779,6 @@ InputDispatcher::findTouchStateWindowAndDisplay(
		const_cast<TouchedWindow*>(constTouchedWindow), displayId);
		}

		bool InputDispatcher::windowHasTouchingPointers(
		const sp<WindowInfoHandle>& windowHandle, DeviceId deviceId,
		const std::unordered_map<ui::LogicalDisplayId, TouchState>& touchStatesByDisplay) {
		const auto& [touchState, touchedWindow, _] =
		findTouchStateWindowAndDisplay(windowHandle->getToken(), touchStatesByDisplay);
		if (touchState == nullptr) {
		// No touching pointers at all
		return false;
		}
		return touchState->hasTouchingPointers(deviceId);
		}

		bool InputDispatcher::transferTouchGesture(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
		bool isDragDrop) {
		if (fromToken == toToken) {
		@@ -7176,13 +7098,6 @@ void InputDispatcher::onWindowInfosChanged(const gui::WindowInfosUpdate& update)
		for (const auto& info : update.windowInfos) {
		handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
		handlesPerDisplay[info.displayId].push_back(sp<WindowInfoHandle>::make(info));
		if (input_flags::split_all_touches()) {
		handlesPerDisplay[info.displayId]
		.back()
		->editInfo()
		->setInputConfig(android::gui::WindowInfo::InputConfig::PREVENT_SPLITTING,
		false);
		}
		}

		{ // acquire lock