Allow multi-window multiple device streams
Before this CL, only one device could be active in the system at a given
time. This was enforced early inside the dispatcher code.
In this CL, this restriction is removed, and a new restriction is
introduced:
- At most one input device can be active for a given connection
That means that it's now possible to touch one window and draw with
stylus in another.
This is implemented by moving the "changed device" check from the
TouchState into InputState.
This should work OK because there will be a unique ViewRootImpl per
connection, and the UI toolkit will continue to process the events in a
single-device mode.
In the future, we can consider enabling same-window multi-device
streams. This would likely require a new public API.
After this CL, the dispatcher will work in the following manner:
TouchState -> always works in the multi-device mode. Assumes 1 window
can receive multiple pointers from different devices.
InputState (per-connection) -> acts as a rejector / multiplexor. It only
selects a single device to be active for the given connection. This is
done so that in the future, we can potentially turn off the "single
device active" behaviour of InputState without having to change other
parts of the dispatcher.
What happens if there are multiple device streams being sent?
- In general, latest device always wins
- Exception: stylus always takes precedence over other devices
- Latest stylus device cancels the current stylus device
One other behaviour there:
- If for the same device id, source changed (this is one of the tests),
then the current gesture is canceled.
Additional changes:
The case of touch pointer down -> mouse down -> second touch pointer
down does not cancel mouse. For simplicity, we just wait for a new touch
gesture to start before canceling the current mouse gesture.
Pilfer pointers changes:
Previously, two devices being active in one window cause pilferPointers
to fail. The new behaviour is that all of the active gestures in the spy
window that's doing the pilfering are going to get pilfered.
So if a spy window is receiving mouse and touch, then both mouse and
touch gestures are going to be pilfered (because the windows below the
spy would be getting independent mouse and touch streams). In practice,
in this CL the spy will never receive two devices at the same time,
because we are only allowing single device to be active per-window. But
the understanding here is that eventually, we may want to have multiple
devices going to the spy.
How same-token windows are handled:
During TouchState computation, the windows with the same token are
treated separately (since they do have a different layer id). Then
later, during TouchState -> InputTarget conversion, they are all lumped
into one target. One problem with this approach is that sometimes, we
want to generate HOVER_EXIT with response to receiving ACTION_DOWN
event. This is because InputReader today doesn't always generate
HOVER_EXIT prior to sending ACTION_DOWN. That means that the dispatcher
has to have a special logic for dealing with these cases. The approach
taken in this CL is to force-generate new DISPATCH_AS_HOVER_EXIT input
targets, which would allow them to remain separate from DISPATCH_AS_IS
input targets for the ACTION_DOWN event.
This avoid the collision of pointers. Otherwise, we would add a pointer
id for the HOVER_EXIT event, which would not be valid for the
ACTION_DOWN event's pointer id.
Bug: 211379801
Test: TEST=inputflinger_tests; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST
Change-Id: If2eae87bc2a40b61144ddcd019a9800c2d526072
diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp
index 45649dd..7dfbf94 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.cpp
+++ b/services/inputflinger/dispatcher/InputDispatcher.cpp
@@ -634,11 +634,10 @@
const MotionEntry& entry) {
std::vector<TouchedWindow> out;
const int32_t maskedAction = MotionEvent::getActionMasked(entry.action);
- if (maskedAction != AMOTION_EVENT_ACTION_HOVER_ENTER &&
- maskedAction != AMOTION_EVENT_ACTION_HOVER_MOVE &&
- maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
- // Not a hover event - don't need to do anything
- return out;
+
+ if (maskedAction == AMOTION_EVENT_ACTION_SCROLL) {
+ // ACTION_SCROLL events should not affect the hovering pointer dispatch
+ return {};
}
// We should consider all hovering pointers here. But for now, just use the first one
@@ -1315,8 +1314,9 @@
if (info.inputConfig.test(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH)) {
std::bitset<MAX_POINTER_ID + 1> pointerIds;
pointerIds.set(pointerId);
- addWindowTargetLocked(windowHandle, InputTarget::Flags::DISPATCH_AS_OUTSIDE, pointerIds,
- /*firstDownTimeInTarget=*/std::nullopt, outsideTargets);
+ addPointerWindowTargetLocked(windowHandle, InputTarget::Flags::DISPATCH_AS_OUTSIDE,
+ pointerIds,
+ /*firstDownTimeInTarget=*/std::nullopt, outsideTargets);
}
}
return outsideTargets;
@@ -1821,7 +1821,7 @@
std::vector<InputTarget> inputTargets;
addWindowTargetLocked(focusedWindow,
InputTarget::Flags::FOREGROUND | InputTarget::Flags::DISPATCH_AS_IS,
- /*pointerIds=*/{}, getDownTime(*entry), inputTargets);
+ getDownTime(*entry), inputTargets);
// Add monitor channels from event's or focused display.
addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
@@ -1905,7 +1905,6 @@
// Identify targets.
std::vector<InputTarget> inputTargets;
- bool conflictingPointerActions = false;
InputEventInjectionResult injectionResult;
if (isPointerEvent) {
// Pointer event. (eg. touchscreen)
@@ -1917,8 +1916,7 @@
}
inputTargets =
- findTouchedWindowTargetsLocked(currentTime, *entry, &conflictingPointerActions,
- /*byref*/ injectionResult);
+ findTouchedWindowTargetsLocked(currentTime, *entry, /*byref*/ injectionResult);
LOG_ALWAYS_FATAL_IF(injectionResult != InputEventInjectionResult::SUCCEEDED &&
!inputTargets.empty());
} else {
@@ -1930,7 +1928,7 @@
addWindowTargetLocked(focusedWindow,
InputTarget::Flags::FOREGROUND |
InputTarget::Flags::DISPATCH_AS_IS,
- /*pointerIds=*/{}, getDownTime(*entry), inputTargets);
+ getDownTime(*entry), inputTargets);
}
}
if (injectionResult == InputEventInjectionResult::PENDING) {
@@ -1954,11 +1952,6 @@
addGlobalMonitoringTargetsLocked(inputTargets, getTargetDisplayId(*entry));
// Dispatch the motion.
- if (conflictingPointerActions) {
- CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
- "conflicting pointer actions");
- synthesizeCancelationEventsForAllConnectionsLocked(options);
- }
dispatchEventLocked(currentTime, entry, inputTargets);
return true;
}
@@ -2258,7 +2251,7 @@
}
std::vector<InputTarget> InputDispatcher::findTouchedWindowTargetsLocked(
- nsecs_t currentTime, const MotionEntry& entry, bool* outConflictingPointerActions,
+ nsecs_t currentTime, const MotionEntry& entry,
InputEventInjectionResult& outInjectionResult) {
ATRACE_CALL();
@@ -2283,20 +2276,13 @@
}
bool isSplit = shouldSplitTouch(tempTouchState, entry);
- bool switchedDevice = false;
- if (oldState != nullptr) {
- std::set<int32_t> oldActiveDevices = oldState->getActiveDeviceIds();
- const bool anotherDeviceIsActive =
- oldActiveDevices.count(entry.deviceId) == 0 && !oldActiveDevices.empty();
- switchedDevice |= anotherDeviceIsActive;
- }
const bool isHoverAction = (maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE ||
maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
maskedAction == AMOTION_EVENT_ACTION_HOVER_EXIT);
// A DOWN could be generated from POINTER_DOWN if the initial pointers did not land into any
// touchable windows.
- const bool wasDown = oldState != nullptr && oldState->isDown();
+ const bool wasDown = oldState != nullptr && oldState->isDown(entry.deviceId);
const bool isDown = (maskedAction == AMOTION_EVENT_ACTION_DOWN) ||
(maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN && !wasDown);
const bool newGesture = isDown || maskedAction == AMOTION_EVENT_ACTION_SCROLL ||
@@ -2304,34 +2290,19 @@
maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE;
const bool isFromMouse = isFromSource(entry.source, AINPUT_SOURCE_MOUSE);
- // If pointers are already down, let's finish the current gesture and ignore the new events
- // from another device. However, if the new event is a down event, let's cancel the current
- // touch and let the new one take over.
- if (switchedDevice && wasDown && !isDown) {
- LOG(INFO) << "Dropping event because a pointer for another device "
- << " is already down in display " << displayId << ": " << entry.getDescription();
- // TODO(b/211379801): test multiple simultaneous input streams.
- outInjectionResult = InputEventInjectionResult::FAILED;
- return {}; // wrong device
+ if (newGesture) {
+ isSplit = false;
}
- if (newGesture) {
- // If a new gesture is starting, clear the touch state completely.
- tempTouchState.reset();
- isSplit = false;
- } else if (switchedDevice && maskedAction == AMOTION_EVENT_ACTION_MOVE) {
- ALOGI("Dropping move event because a pointer for a different device is already active "
- "in display %" PRId32,
- displayId);
- // TODO(b/211379801): test multiple simultaneous input streams.
- outInjectionResult = InputEventInjectionResult::FAILED;
- return {}; // wrong device
+ if (isDown && tempTouchState.hasHoveringPointers(entry.deviceId)) {
+ // Compatibility behaviour: ACTION_DOWN causes HOVER_EXIT to get generated.
+ tempTouchState.clearHoveringPointers(entry.deviceId);
}
if (isHoverAction) {
// For hover actions, we will treat 'tempTouchState' as a new state, so let's erase
// all of the existing hovering pointers and recompute.
- tempTouchState.clearHoveringPointers();
+ tempTouchState.clearHoveringPointers(entry.deviceId);
}
if (newGesture || (isSplit && maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN)) {
@@ -2402,8 +2373,7 @@
continue;
}
- if (maskedAction == AMOTION_EVENT_ACTION_HOVER_ENTER ||
- maskedAction == AMOTION_EVENT_ACTION_HOVER_MOVE) {
+ if (isHoverAction) {
// The "windowHandle" is the target of this hovering pointer.
tempTouchState.addHoveringPointerToWindow(windowHandle, entry.deviceId, pointerId);
}
@@ -2426,31 +2396,24 @@
}
// Update the temporary touch state.
- std::bitset<MAX_POINTER_ID + 1> pointerIds;
+
if (!isHoverAction) {
+ std::bitset<MAX_POINTER_ID + 1> pointerIds;
pointerIds.set(pointerId);
- }
-
- const bool isDownOrPointerDown = maskedAction == AMOTION_EVENT_ACTION_DOWN ||
- maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN;
-
- // TODO(b/211379801): Currently, even if pointerIds are empty (hover case), we would
- // still add a window to the touch state. We should avoid doing that, but some of the
- // later checks ("at least one foreground window") rely on this in order to dispatch
- // the event properly, so that needs to be updated, possibly by looking at InputTargets.
- tempTouchState.addOrUpdateWindow(windowHandle, targetFlags, entry.deviceId, pointerIds,
- isDownOrPointerDown
- ? std::make_optional(entry.eventTime)
- : std::nullopt);
-
- // If this is the pointer going down and the touched window has a wallpaper
- // then also add the touched wallpaper windows so they are locked in for the duration
- // of the touch gesture.
- // We do not collect wallpapers during HOVER_MOVE or SCROLL because the wallpaper
- // engine only supports touch events. We would need to add a mechanism similar
- // to View.onGenericMotionEvent to enable wallpapers to handle these events.
- if (isDownOrPointerDown) {
- if (targetFlags.test(InputTarget::Flags::FOREGROUND) &&
+ const bool isDownOrPointerDown = maskedAction == AMOTION_EVENT_ACTION_DOWN ||
+ maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN;
+ tempTouchState.addOrUpdateWindow(windowHandle, targetFlags, entry.deviceId,
+ pointerIds,
+ isDownOrPointerDown
+ ? std::make_optional(entry.eventTime)
+ : std::nullopt);
+ // If this is the pointer going down and the touched window has a wallpaper
+ // then also add the touched wallpaper windows so they are locked in for the
+ // duration of the touch gesture. We do not collect wallpapers during HOVER_MOVE or
+ // SCROLL because the wallpaper engine only supports touch events. We would need to
+ // add a mechanism similar to View.onGenericMotionEvent to enable wallpapers to
+ // handle these events.
+ if (isDownOrPointerDown && targetFlags.test(InputTarget::Flags::FOREGROUND) &&
windowHandle->getInfo()->inputConfig.test(
gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
sp<WindowInfoHandle> wallpaper = findWallpaperWindowBelow(windowHandle);
@@ -2488,8 +2451,10 @@
/* Case 2: Pointer move, up, cancel or non-splittable pointer down. */
// If the pointer is not currently down, then ignore the event.
- if (!tempTouchState.isDown() && maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
- LOG(INFO) << "Dropping event because the pointer is not down or we previously "
+ if (!tempTouchState.isDown(entry.deviceId) &&
+ maskedAction != AMOTION_EVENT_ACTION_HOVER_EXIT) {
+ LOG(INFO) << "Dropping event because the pointer for device " << entry.deviceId
+ << " is not down or we previously "
"dropped the pointer down event in display "
<< displayId << ": " << entry.getDescription();
outInjectionResult = InputEventInjectionResult::FAILED;
@@ -2538,7 +2503,7 @@
if (newTouchedWindowHandle != nullptr &&
!haveSameToken(oldTouchedWindowHandle, newTouchedWindowHandle)) {
- ALOGD("Touch is slipping out of window %s into window %s in display %" PRId32,
+ ALOGI("Touch is slipping out of window %s into window %s in display %" PRId32,
oldTouchedWindowHandle->getName().c_str(),
newTouchedWindowHandle->getName().c_str(), displayId);
@@ -2549,9 +2514,11 @@
const TouchedWindow& touchedWindow =
tempTouchState.getTouchedWindow(oldTouchedWindowHandle);
- addWindowTargetLocked(oldTouchedWindowHandle,
- InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT, pointerIds,
- touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
+ addPointerWindowTargetLocked(oldTouchedWindowHandle,
+ InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
+ pointerIds,
+ touchedWindow.getDownTimeInTarget(entry.deviceId),
+ targets);
// Make a slippery entrance into the new window.
if (newTouchedWindowHandle->getInfo()->supportsSplitTouch()) {
@@ -2664,16 +2631,14 @@
// Output targets from the touch state.
for (const TouchedWindow& touchedWindow : tempTouchState.windows) {
- if (!touchedWindow.hasTouchingPointers(entry.deviceId) &&
- !touchedWindow.hasHoveringPointers(entry.deviceId)) {
- // Windows with hovering pointers are getting persisted inside TouchState.
- // Do not send this event to those windows.
+ std::bitset<MAX_POINTER_ID + 1> touchingPointers =
+ touchedWindow.getTouchingPointers(entry.deviceId);
+ if (touchingPointers.none()) {
continue;
}
-
- addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
- touchedWindow.getTouchingPointers(entry.deviceId),
- touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
+ addPointerWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
+ touchingPointers,
+ touchedWindow.getDownTimeInTarget(entry.deviceId), targets);
}
// During targeted injection, only allow owned targets to receive events
@@ -2706,37 +2671,30 @@
}
outInjectionResult = InputEventInjectionResult::SUCCEEDED;
- // Drop the outside or hover touch windows since we will not care about them
- // in the next iteration.
- tempTouchState.filterNonAsIsTouchWindows();
- // Update final pieces of touch state if the injector had permission.
- if (switchedDevice) {
- if (DEBUG_FOCUS) {
- ALOGD("Conflicting pointer actions: Switched to a different device.");
+ for (TouchedWindow& touchedWindow : tempTouchState.windows) {
+ // Targets that we entered in a slippery way will now become AS-IS targets
+ if (touchedWindow.targetFlags.test(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER)) {
+ touchedWindow.targetFlags.clear(InputTarget::Flags::DISPATCH_AS_SLIPPERY_ENTER);
+ touchedWindow.targetFlags |= InputTarget::Flags::DISPATCH_AS_IS;
}
- *outConflictingPointerActions = true;
}
+ // Update final pieces of touch state if the injector had permission.
if (isHoverAction) {
- // Started hovering, therefore no longer down.
- if (oldState && oldState->isDown()) {
- ALOGD_IF(DEBUG_FOCUS,
- "Conflicting pointer actions: Hover received while pointer was down.");
- *outConflictingPointerActions = true;
+ if (oldState && oldState->isDown(entry.deviceId)) {
+ // Started hovering, but the device is already down: reject the hover event
+ LOG(ERROR) << "Got hover event " << entry.getDescription()
+ << " but the device is already down " << oldState->dump();
+ outInjectionResult = InputEventInjectionResult::FAILED;
+ return {};
}
} else if (maskedAction == AMOTION_EVENT_ACTION_UP) {
// Pointer went up.
tempTouchState.removeTouchingPointer(entry.deviceId, entry.pointerProperties[0].id);
} else if (maskedAction == AMOTION_EVENT_ACTION_CANCEL) {
// All pointers up or canceled.
- tempTouchState.reset();
- } else if (maskedAction == AMOTION_EVENT_ACTION_DOWN) {
- // First pointer went down.
- if (oldState && (oldState->isDown() || oldState->hasHoveringPointers())) {
- ALOGD("Conflicting pointer actions: Down received while already down or hovering.");
- *outConflictingPointerActions = true;
- }
+ tempTouchState.removeAllPointersForDevice(entry.deviceId);
} else if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
// One pointer went up.
const int32_t pointerIndex = MotionEvent::getActionIndex(action);
@@ -2885,7 +2843,6 @@
void InputDispatcher::addWindowTargetLocked(const sp<WindowInfoHandle>& windowHandle,
ftl::Flags<InputTarget::Flags> targetFlags,
- std::bitset<MAX_POINTER_ID + 1> pointerIds,
std::optional<nsecs_t> firstDownTimeInTarget,
std::vector<InputTarget>& inputTargets) const {
std::vector<InputTarget>::iterator it =
@@ -2907,8 +2864,54 @@
it = inputTargets.end() - 1;
}
- ALOG_ASSERT(it->flags == targetFlags);
- ALOG_ASSERT(it->globalScaleFactor == windowInfo->globalScaleFactor);
+ LOG_ALWAYS_FATAL_IF(it->flags != targetFlags);
+ LOG_ALWAYS_FATAL_IF(it->globalScaleFactor != windowInfo->globalScaleFactor);
+}
+
+void InputDispatcher::addPointerWindowTargetLocked(
+ const sp<android::gui::WindowInfoHandle>& windowHandle,
+ ftl::Flags<InputTarget::Flags> targetFlags, std::bitset<MAX_POINTER_ID + 1> pointerIds,
+ std::optional<nsecs_t> firstDownTimeInTarget, std::vector<InputTarget>& inputTargets) const
+ REQUIRES(mLock) {
+ if (pointerIds.none()) {
+ for (const auto& target : inputTargets) {
+ LOG(INFO) << "Target: " << target;
+ }
+ LOG(FATAL) << "No pointers specified for " << windowHandle->getName();
+ return;
+ }
+ std::vector<InputTarget>::iterator it =
+ std::find_if(inputTargets.begin(), inputTargets.end(),
+ [&windowHandle](const InputTarget& inputTarget) {
+ return inputTarget.inputChannel->getConnectionToken() ==
+ windowHandle->getToken();
+ });
+
+ // This is a hack, because the actual entry could potentially be an ACTION_DOWN event that
+ // causes a HOVER_EXIT to be generated. That means that the same entry of ACTION_DOWN would
+ // have DISPATCH_AS_HOVER_EXIT and DISPATCH_AS_IS. And therefore, we have to create separate
+ // input targets for hovering pointers and for touching pointers.
+ // If we picked an existing input target above, but it's for HOVER_EXIT - let's use a new
+ // target instead.
+ if (it != inputTargets.end() && it->flags.test(InputTarget::Flags::DISPATCH_AS_HOVER_EXIT)) {
+ // Force the code below to create a new input target
+ it = inputTargets.end();
+ }
+
+ const WindowInfo* windowInfo = windowHandle->getInfo();
+
+ if (it == inputTargets.end()) {
+ std::optional<InputTarget> target =
+ createInputTargetLocked(windowHandle, targetFlags, firstDownTimeInTarget);
+ if (!target) {
+ return;
+ }
+ inputTargets.push_back(*target);
+ it = inputTargets.end() - 1;
+ }
+
+ LOG_ALWAYS_FATAL_IF(it->flags != targetFlags);
+ LOG_ALWAYS_FATAL_IF(it->globalScaleFactor != windowInfo->globalScaleFactor);
it->addPointers(pointerIds, windowInfo->transform);
}
@@ -3366,6 +3369,27 @@
dispatchEntry->resolvedFlags |= AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
}
+ // Check if we need to cancel any of the ongoing gestures. We don't support multiple
+ // devices being active at the same time in the same window, so if a new device is
+ // active, cancel the gesture from the old device.
+
+ std::unique_ptr<EventEntry> cancelEvent =
+ connection->inputState
+ .cancelConflictingInputStream(motionEntry,
+ dispatchEntry->resolvedAction);
+ if (cancelEvent != nullptr) {
+ LOG(INFO) << "Canceling pointers for device " << motionEntry.deviceId << " in "
+ << connection->getInputChannelName() << " with event "
+ << cancelEvent->getDescription();
+ std::unique_ptr<DispatchEntry> cancelDispatchEntry =
+ createDispatchEntry(inputTarget, std::move(cancelEvent),
+ InputTarget::Flags::DISPATCH_AS_IS);
+
+ // Send these cancel events to the queue before sending the event from the new
+ // device.
+ connection->outboundQueue.emplace_back(std::move(cancelDispatchEntry));
+ }
+
if (!connection->inputState.trackMotion(motionEntry, dispatchEntry->resolvedAction,
dispatchEntry->resolvedFlags)) {
LOG(WARNING) << "channel " << connection->getInputChannelName()
@@ -3975,7 +3999,7 @@
: std::nullopt;
if (const auto& window = getWindowHandleLocked(token, targetDisplay); window) {
addWindowTargetLocked(window, InputTarget::Flags::DISPATCH_AS_IS,
- /*pointerIds=*/{}, keyEntry.downTime, targets);
+ keyEntry.downTime, targets);
} else {
targets.emplace_back(fallbackTarget);
}
@@ -3994,8 +4018,8 @@
pointerIndex++) {
pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
}
- addWindowTargetLocked(window, InputTarget::Flags::DISPATCH_AS_IS, pointerIds,
- motionEntry.downTime, targets);
+ addPointerWindowTargetLocked(window, InputTarget::Flags::DISPATCH_AS_IS,
+ pointerIds, motionEntry.downTime, targets);
} else {
targets.emplace_back(fallbackTarget);
const auto it = mDisplayInfos.find(motionEntry.displayId);
@@ -4069,8 +4093,8 @@
pointerIndex++) {
pointerIds.set(motionEntry.pointerProperties[pointerIndex].id);
}
- addWindowTargetLocked(windowHandle, targetFlags, pointerIds,
- motionEntry.downTime, targets);
+ addPointerWindowTargetLocked(windowHandle, targetFlags, pointerIds,
+ motionEntry.downTime, targets);
} else {
targets.emplace_back(InputTarget{.inputChannel = connection->inputChannel,
.flags = targetFlags});
@@ -5139,10 +5163,8 @@
for (size_t i = 0; i < state.windows.size();) {
TouchedWindow& touchedWindow = state.windows[i];
if (getWindowHandleLocked(touchedWindow.windowHandle) == nullptr) {
- if (DEBUG_FOCUS) {
- ALOGD("Touched window was removed: %s in display %" PRId32,
- touchedWindow.windowHandle->getName().c_str(), displayId);
- }
+ LOG(INFO) << "Touched window was removed: " << touchedWindow.windowHandle->getName()
+ << " in display %" << displayId;
std::shared_ptr<InputChannel> touchedInputChannel =
getInputChannelLocked(touchedWindow.windowHandle->getToken());
if (touchedInputChannel != nullptr) {
@@ -5973,9 +5995,8 @@
return BAD_VALUE;
}
std::set<int32_t> deviceIds = windowPtr->getTouchingDeviceIds();
- if (deviceIds.size() != 1) {
- LOG(WARNING) << "Can't pilfer. Currently touching devices: " << dumpSet(deviceIds)
- << " in window: " << windowPtr->dump();
+ if (deviceIds.empty()) {
+ LOG(WARNING) << "Can't pilfer: no touching devices in window: " << windowPtr->dump();
return BAD_VALUE;
}
@@ -6818,10 +6839,11 @@
if (oldWallpaper != nullptr) {
const TouchedWindow& oldTouchedWindow = state.getTouchedWindow(oldWallpaper);
- addWindowTargetLocked(oldWallpaper,
- oldTouchedWindow.targetFlags |
- InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
- pointerIds, oldTouchedWindow.getDownTimeInTarget(deviceId), targets);
+ addPointerWindowTargetLocked(oldWallpaper,
+ oldTouchedWindow.targetFlags |
+ InputTarget::Flags::DISPATCH_AS_SLIPPERY_EXIT,
+ pointerIds, oldTouchedWindow.getDownTimeInTarget(deviceId),
+ targets);
state.removeTouchingPointerFromWindow(deviceId, pointerId, oldWallpaper);
}