diff options
Diffstat (limited to 'services/inputflinger/reader/mapper/TouchInputMapper.cpp')
| -rw-r--r-- | services/inputflinger/reader/mapper/TouchInputMapper.cpp | 1082 |
1 files changed, 610 insertions, 472 deletions
diff --git a/services/inputflinger/reader/mapper/TouchInputMapper.cpp b/services/inputflinger/reader/mapper/TouchInputMapper.cpp index 99a572a5fd..962d8d2935 100644 --- a/services/inputflinger/reader/mapper/TouchInputMapper.cpp +++ b/services/inputflinger/reader/mapper/TouchInputMapper.cpp @@ -14,8 +14,11 @@ * limitations under the License. */ +// clang-format off #include "../Macros.h" +// clang-format on +#include <input/NamedEnum.h> #include "TouchInputMapper.h" #include "CursorButtonAccumulator.h" @@ -102,6 +105,7 @@ void RawPointerData::copyFrom(const RawPointerData& other) { pointerCount = other.pointerCount; hoveringIdBits = other.hoveringIdBits; touchingIdBits = other.touchingIdBits; + canceledIdBits = other.canceledIdBits; for (uint32_t i = 0; i < pointerCount; i++) { pointers[i] = other.pointers[i]; @@ -138,12 +142,15 @@ void CookedPointerData::clear() { pointerCount = 0; hoveringIdBits.clear(); touchingIdBits.clear(); + canceledIdBits.clear(); + validIdBits.clear(); } void CookedPointerData::copyFrom(const CookedPointerData& other) { pointerCount = other.pointerCount; hoveringIdBits = other.hoveringIdBits; touchingIdBits = other.touchingIdBits; + validIdBits = other.validIdBits; for (uint32_t i = 0; i < pointerCount; i++) { pointerProperties[i].copyFrom(other.pointerProperties[i]); @@ -159,11 +166,13 @@ void CookedPointerData::copyFrom(const CookedPointerData& other) { TouchInputMapper::TouchInputMapper(InputDeviceContext& deviceContext) : InputMapper(deviceContext), mSource(0), - mDeviceMode(DEVICE_MODE_DISABLED), + mDeviceMode(DeviceMode::DISABLED), mRawSurfaceWidth(-1), mRawSurfaceHeight(-1), mSurfaceLeft(0), mSurfaceTop(0), + mSurfaceRight(0), + mSurfaceBottom(0), mPhysicalWidth(-1), mPhysicalHeight(-1), mPhysicalLeft(0), @@ -179,11 +188,25 @@ uint32_t TouchInputMapper::getSources() { void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { InputMapper::populateDeviceInfo(info); - if (mDeviceMode != DEVICE_MODE_DISABLED) { + if (mDeviceMode != DeviceMode::DISABLED) { info->addMotionRange(mOrientedRanges.x); info->addMotionRange(mOrientedRanges.y); info->addMotionRange(mOrientedRanges.pressure); + if (mDeviceMode == DeviceMode::UNSCALED && mSource == AINPUT_SOURCE_TOUCHPAD) { + // Populate RELATIVE_X and RELATIVE_Y motion ranges for touchpad capture mode. + // + // RELATIVE_X and RELATIVE_Y motion ranges should be the largest possible relative + // motion, i.e. the hardware dimensions, as the finger could move completely across the + // touchpad in one sample cycle. + const InputDeviceInfo::MotionRange& x = mOrientedRanges.x; + const InputDeviceInfo::MotionRange& y = mOrientedRanges.y; + info->addMotionRange(AMOTION_EVENT_AXIS_RELATIVE_X, mSource, -x.max, x.max, x.flat, + x.fuzz, x.resolution); + info->addMotionRange(AMOTION_EVENT_AXIS_RELATIVE_Y, mSource, -y.max, y.max, y.flat, + y.fuzz, y.resolution); + } + if (mOrientedRanges.haveSize) { info->addMotionRange(mOrientedRanges.size); } @@ -218,7 +241,7 @@ void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f); } - if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_BOX) { + if (mCalibration.coverageCalibration == Calibration::CoverageCalibration::BOX) { const InputDeviceInfo::MotionRange& x = mOrientedRanges.x; const InputDeviceInfo::MotionRange& y = mOrientedRanges.y; info->addMotionRange(AMOTION_EVENT_AXIS_GENERIC_1, mSource, x.min, x.max, x.flat, @@ -235,7 +258,8 @@ void TouchInputMapper::populateDeviceInfo(InputDeviceInfo* info) { } void TouchInputMapper::dump(std::string& dump) { - dump += StringPrintf(INDENT2 "Touch Input Mapper (mode - %s):\n", modeToString(mDeviceMode)); + dump += StringPrintf(INDENT2 "Touch Input Mapper (mode - %s):\n", + NamedEnum::string(mDeviceMode).c_str()); dumpParameters(dump); dumpVirtualKeys(dump); dumpRawPointerAxes(dump); @@ -284,12 +308,14 @@ void TouchInputMapper::dump(std::string& dump) { const PointerProperties& pointerProperties = mLastCookedState.cookedPointerData.pointerProperties[i]; const PointerCoords& pointerCoords = mLastCookedState.cookedPointerData.pointerCoords[i]; - dump += StringPrintf(INDENT4 "[%d]: id=%d, x=%0.3f, y=%0.3f, pressure=%0.3f, " - "touchMajor=%0.3f, touchMinor=%0.3f, toolMajor=%0.3f, " - "toolMinor=%0.3f, " + dump += StringPrintf(INDENT4 "[%d]: id=%d, x=%0.3f, y=%0.3f, dx=%0.3f, dy=%0.3f, " + "pressure=%0.3f, touchMajor=%0.3f, touchMinor=%0.3f, " + "toolMajor=%0.3f, toolMinor=%0.3f, " "orientation=%0.3f, tilt=%0.3f, distance=%0.3f, " "toolType=%d, isHovering=%s\n", i, pointerProperties.id, pointerCoords.getX(), pointerCoords.getY(), + pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X), + pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y), pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR), pointerCoords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR), @@ -311,7 +337,7 @@ void TouchInputMapper::dump(std::string& dump) { dump += INDENT3 "External Stylus State:\n"; dumpStylusState(dump, mExternalStylusState); - if (mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::POINTER) { dump += StringPrintf(INDENT3 "Pointer Gesture Detector:\n"); dump += StringPrintf(INDENT4 "XMovementScale: %0.3f\n", mPointerXMovementScale); dump += StringPrintf(INDENT4 "YMovementScale: %0.3f\n", mPointerYMovementScale); @@ -321,22 +347,6 @@ void TouchInputMapper::dump(std::string& dump) { } } -const char* TouchInputMapper::modeToString(DeviceMode deviceMode) { - switch (deviceMode) { - case DEVICE_MODE_DISABLED: - return "disabled"; - case DEVICE_MODE_DIRECT: - return "direct"; - case DEVICE_MODE_UNSCALED: - return "unscaled"; - case DEVICE_MODE_NAVIGATION: - return "navigation"; - case DEVICE_MODE_POINTER: - return "pointer"; - } - return "unknown"; -} - void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) { InputMapper::configure(when, config, changes); @@ -375,6 +385,7 @@ void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* c if (!changes || (changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO | + InputReaderConfiguration::CHANGE_POINTER_CAPTURE | InputReaderConfiguration::CHANGE_POINTER_GESTURE_ENABLEMENT | InputReaderConfiguration::CHANGE_SHOW_TOUCHES | InputReaderConfiguration::CHANGE_EXTERNAL_STYLUS_PRESENCE))) { @@ -406,16 +417,16 @@ void TouchInputMapper::configureParameters() { // multitouch. The spot-based presentation relies on being able to accurately // locate two or more fingers on the touch pad. mParameters.gestureMode = getDeviceContext().hasInputProperty(INPUT_PROP_SEMI_MT) - ? Parameters::GESTURE_MODE_SINGLE_TOUCH - : Parameters::GESTURE_MODE_MULTI_TOUCH; + ? Parameters::GestureMode::SINGLE_TOUCH + : Parameters::GestureMode::MULTI_TOUCH; String8 gestureModeString; if (getDeviceContext().getConfiguration().tryGetProperty(String8("touch.gestureMode"), gestureModeString)) { if (gestureModeString == "single-touch") { - mParameters.gestureMode = Parameters::GESTURE_MODE_SINGLE_TOUCH; + mParameters.gestureMode = Parameters::GestureMode::SINGLE_TOUCH; } else if (gestureModeString == "multi-touch") { - mParameters.gestureMode = Parameters::GESTURE_MODE_MULTI_TOUCH; + mParameters.gestureMode = Parameters::GestureMode::MULTI_TOUCH; } else if (gestureModeString != "default") { ALOGW("Invalid value for touch.gestureMode: '%s'", gestureModeString.string()); } @@ -423,18 +434,18 @@ void TouchInputMapper::configureParameters() { if (getDeviceContext().hasInputProperty(INPUT_PROP_DIRECT)) { // The device is a touch screen. - mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN; + mParameters.deviceType = Parameters::DeviceType::TOUCH_SCREEN; } else if (getDeviceContext().hasInputProperty(INPUT_PROP_POINTER)) { // The device is a pointing device like a track pad. - mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; + mParameters.deviceType = Parameters::DeviceType::POINTER; } else if (getDeviceContext().hasRelativeAxis(REL_X) || getDeviceContext().hasRelativeAxis(REL_Y)) { // The device is a cursor device with a touch pad attached. // By default don't use the touch pad to move the pointer. - mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD; + mParameters.deviceType = Parameters::DeviceType::TOUCH_PAD; } else { // The device is a touch pad of unknown purpose. - mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; + mParameters.deviceType = Parameters::DeviceType::POINTER; } mParameters.hasButtonUnderPad = getDeviceContext().hasInputProperty(INPUT_PROP_BUTTONPAD); @@ -443,29 +454,29 @@ void TouchInputMapper::configureParameters() { if (getDeviceContext().getConfiguration().tryGetProperty(String8("touch.deviceType"), deviceTypeString)) { if (deviceTypeString == "touchScreen") { - mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_SCREEN; + mParameters.deviceType = Parameters::DeviceType::TOUCH_SCREEN; } else if (deviceTypeString == "touchPad") { - mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_PAD; + mParameters.deviceType = Parameters::DeviceType::TOUCH_PAD; } else if (deviceTypeString == "touchNavigation") { - mParameters.deviceType = Parameters::DEVICE_TYPE_TOUCH_NAVIGATION; + mParameters.deviceType = Parameters::DeviceType::TOUCH_NAVIGATION; } else if (deviceTypeString == "pointer") { - mParameters.deviceType = Parameters::DEVICE_TYPE_POINTER; + mParameters.deviceType = Parameters::DeviceType::POINTER; } else if (deviceTypeString != "default") { ALOGW("Invalid value for touch.deviceType: '%s'", deviceTypeString.string()); } } - mParameters.orientationAware = mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN; + mParameters.orientationAware = mParameters.deviceType == Parameters::DeviceType::TOUCH_SCREEN; getDeviceContext().getConfiguration().tryGetProperty(String8("touch.orientationAware"), mParameters.orientationAware); mParameters.hasAssociatedDisplay = false; mParameters.associatedDisplayIsExternal = false; if (mParameters.orientationAware || - mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN || - mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) { + mParameters.deviceType == Parameters::DeviceType::TOUCH_SCREEN || + mParameters.deviceType == Parameters::DeviceType::POINTER) { mParameters.hasAssociatedDisplay = true; - if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN) { + if (mParameters.deviceType == Parameters::DeviceType::TOUCH_SCREEN) { mParameters.associatedDisplayIsExternal = getDeviceContext().isExternal(); String8 uniqueDisplayId; getDeviceContext().getConfiguration().tryGetProperty(String8("touch.displayId"), @@ -487,33 +498,9 @@ void TouchInputMapper::configureParameters() { void TouchInputMapper::dumpParameters(std::string& dump) { dump += INDENT3 "Parameters:\n"; - switch (mParameters.gestureMode) { - case Parameters::GESTURE_MODE_SINGLE_TOUCH: - dump += INDENT4 "GestureMode: single-touch\n"; - break; - case Parameters::GESTURE_MODE_MULTI_TOUCH: - dump += INDENT4 "GestureMode: multi-touch\n"; - break; - default: - assert(false); - } + dump += INDENT4 "GestureMode: " + NamedEnum::string(mParameters.gestureMode) + "\n"; - switch (mParameters.deviceType) { - case Parameters::DEVICE_TYPE_TOUCH_SCREEN: - dump += INDENT4 "DeviceType: touchScreen\n"; - break; - case Parameters::DEVICE_TYPE_TOUCH_PAD: - dump += INDENT4 "DeviceType: touchPad\n"; - break; - case Parameters::DEVICE_TYPE_TOUCH_NAVIGATION: - dump += INDENT4 "DeviceType: touchNavigation\n"; - break; - case Parameters::DEVICE_TYPE_POINTER: - dump += INDENT4 "DeviceType: pointer\n"; - break; - default: - ALOG_ASSERT(false); - } + dump += INDENT4 "DeviceType: " + NamedEnum::string(mParameters.deviceType) + "\n"; dump += StringPrintf(INDENT4 "AssociatedDisplay: hasAssociatedDisplay=%s, isExternal=%s, " "displayId='%s'\n", @@ -558,14 +545,14 @@ bool TouchInputMapper::hasExternalStylus() const { * 4. Otherwise, use a non-display viewport. */ std::optional<DisplayViewport> TouchInputMapper::findViewport() { - if (mParameters.hasAssociatedDisplay) { + if (mParameters.hasAssociatedDisplay && mDeviceMode != DeviceMode::UNSCALED) { const std::optional<uint8_t> displayPort = getDeviceContext().getAssociatedDisplayPort(); if (displayPort) { // Find the viewport that contains the same port return getDeviceContext().getAssociatedViewport(); } - if (mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::POINTER) { std::optional<DisplayViewport> viewport = mConfig.getDisplayViewportById(mConfig.defaultPointerDisplayId); if (viewport) { @@ -583,18 +570,18 @@ std::optional<DisplayViewport> TouchInputMapper::findViewport() { ViewportType viewportTypeToUse; if (mParameters.associatedDisplayIsExternal) { - viewportTypeToUse = ViewportType::VIEWPORT_EXTERNAL; + viewportTypeToUse = ViewportType::EXTERNAL; } else { - viewportTypeToUse = ViewportType::VIEWPORT_INTERNAL; + viewportTypeToUse = ViewportType::INTERNAL; } std::optional<DisplayViewport> viewport = mConfig.getDisplayViewportByType(viewportTypeToUse); - if (!viewport && viewportTypeToUse == ViewportType::VIEWPORT_EXTERNAL) { + if (!viewport && viewportTypeToUse == ViewportType::EXTERNAL) { ALOGW("Input device %s should be associated with external display, " "fallback to internal one for the external viewport is not found.", getDeviceName().c_str()); - viewport = mConfig.getDisplayViewportByType(ViewportType::VIEWPORT_INTERNAL); + viewport = mConfig.getDisplayViewportByType(ViewportType::INTERNAL); } return viewport; @@ -610,34 +597,33 @@ std::optional<DisplayViewport> TouchInputMapper::findViewport() { } void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { - int32_t oldDeviceMode = mDeviceMode; + DeviceMode oldDeviceMode = mDeviceMode; resolveExternalStylusPresence(); // Determine device mode. - if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER && - mConfig.pointerGesturesEnabled) { + if (mParameters.deviceType == Parameters::DeviceType::POINTER && + mConfig.pointerGesturesEnabled && !mConfig.pointerCapture) { mSource = AINPUT_SOURCE_MOUSE; - mDeviceMode = DEVICE_MODE_POINTER; + mDeviceMode = DeviceMode::POINTER; if (hasStylus()) { mSource |= AINPUT_SOURCE_STYLUS; } - } else if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN && - mParameters.hasAssociatedDisplay) { + } else if (isTouchScreen()) { mSource = AINPUT_SOURCE_TOUCHSCREEN; - mDeviceMode = DEVICE_MODE_DIRECT; + mDeviceMode = DeviceMode::DIRECT; if (hasStylus()) { mSource |= AINPUT_SOURCE_STYLUS; } if (hasExternalStylus()) { mSource |= AINPUT_SOURCE_BLUETOOTH_STYLUS; } - } else if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_NAVIGATION) { + } else if (mParameters.deviceType == Parameters::DeviceType::TOUCH_NAVIGATION) { mSource = AINPUT_SOURCE_TOUCH_NAVIGATION; - mDeviceMode = DEVICE_MODE_NAVIGATION; + mDeviceMode = DeviceMode::NAVIGATION; } else { mSource = AINPUT_SOURCE_TOUCHPAD; - mDeviceMode = DEVICE_MODE_UNSCALED; + mDeviceMode = DeviceMode::UNSCALED; } // Ensure we have valid X and Y axes. @@ -645,7 +631,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { ALOGW("Touch device '%s' did not report support for X or Y axis! " "The device will be inoperable.", getDeviceName().c_str()); - mDeviceMode = DEVICE_MODE_DISABLED; + mDeviceMode = DeviceMode::DISABLED; return; } @@ -656,7 +642,14 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { "display. The device will be inoperable until the display size " "becomes available.", getDeviceName().c_str()); - mDeviceMode = DEVICE_MODE_DISABLED; + mDeviceMode = DeviceMode::DISABLED; + return; + } + + if (!newViewport->isActive) { + ALOGI("Disabling %s (device %i) because the associated viewport is not active", + getDeviceName().c_str(), getDeviceId()); + mDeviceMode = DeviceMode::DISABLED; return; } @@ -665,10 +658,12 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { int32_t rawHeight = mRawPointerAxes.getRawHeight(); bool viewportChanged = mViewport != *newViewport; + bool skipViewportUpdate = false; if (viewportChanged) { + bool viewportOrientationChanged = mViewport.orientation != newViewport->orientation; mViewport = *newViewport; - if (mDeviceMode == DEVICE_MODE_DIRECT || mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::DIRECT || mDeviceMode == DeviceMode::POINTER) { // Convert rotated viewport to natural surface coordinates. int32_t naturalLogicalWidth, naturalLogicalHeight; int32_t naturalPhysicalWidth, naturalPhysicalHeight; @@ -729,6 +724,8 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { mPhysicalLeft = naturalPhysicalLeft; mPhysicalTop = naturalPhysicalTop; + const int32_t oldSurfaceWidth = mRawSurfaceWidth; + const int32_t oldSurfaceHeight = mRawSurfaceHeight; mRawSurfaceWidth = naturalLogicalWidth * naturalDeviceWidth / naturalPhysicalWidth; mRawSurfaceHeight = naturalLogicalHeight * naturalDeviceHeight / naturalPhysicalHeight; mSurfaceLeft = naturalPhysicalLeft * naturalLogicalWidth / naturalPhysicalWidth; @@ -736,8 +733,25 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { mSurfaceRight = mSurfaceLeft + naturalLogicalWidth; mSurfaceBottom = mSurfaceTop + naturalLogicalHeight; - mSurfaceOrientation = - mParameters.orientationAware ? mViewport.orientation : DISPLAY_ORIENTATION_0; + if (isPerWindowInputRotationEnabled()) { + // When per-window input rotation is enabled, InputReader works in the un-rotated + // coordinate space, so we don't need to do anything if the device is already + // orientation-aware. If the device is not orientation-aware, then we need to apply + // the inverse rotation of the display so that when the display rotation is applied + // later as a part of the per-window transform, we get the expected screen + // coordinates. + mSurfaceOrientation = mParameters.orientationAware + ? DISPLAY_ORIENTATION_0 + : getInverseRotation(mViewport.orientation); + // For orientation-aware devices that work in the un-rotated coordinate space, the + // viewport update should be skipped if it is only a change in the orientation. + skipViewportUpdate = mParameters.orientationAware && + mRawSurfaceWidth == oldSurfaceWidth && + mRawSurfaceHeight == oldSurfaceHeight && viewportOrientationChanged; + } else { + mSurfaceOrientation = mParameters.orientationAware ? mViewport.orientation + : DISPLAY_ORIENTATION_0; + } } else { mPhysicalWidth = rawWidth; mPhysicalHeight = rawHeight; @@ -758,17 +772,22 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { mOrientedRanges.clear(); } - // Create pointer controller if needed. - if (mDeviceMode == DEVICE_MODE_POINTER || - (mDeviceMode == DEVICE_MODE_DIRECT && mConfig.showTouches)) { + // Create pointer controller if needed, and keep it around if Pointer Capture is enabled to + // preserve the cursor position. + if (mDeviceMode == DeviceMode::POINTER || + (mDeviceMode == DeviceMode::DIRECT && mConfig.showTouches) || + (mParameters.deviceType == Parameters::DeviceType::POINTER && mConfig.pointerCapture)) { if (mPointerController == nullptr) { mPointerController = getContext()->getPointerController(getDeviceId()); } + if (mConfig.pointerCapture) { + mPointerController->fade(PointerControllerInterface::Transition::IMMEDIATE); + } } else { - mPointerController.clear(); + mPointerController.reset(); } - if (viewportChanged || deviceModeChanged) { + if ((viewportChanged && !skipViewportUpdate) || deviceModeChanged) { ALOGI("Device reconfigured: id=%d, name='%s', size %dx%d, orientation %d, mode %d, " "display id %d", getDeviceId(), getDeviceName().c_str(), mRawSurfaceWidth, mRawSurfaceHeight, @@ -798,7 +817,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { float diagonalSize = hypotf(mRawSurfaceWidth, mRawSurfaceHeight); // Size factors. - if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) { + if (mCalibration.sizeCalibration != Calibration::SizeCalibration::NONE) { if (mRawPointerAxes.touchMajor.valid && mRawPointerAxes.touchMajor.maxValue != 0) { mSizeScale = 1.0f / mRawPointerAxes.touchMajor.maxValue; } else if (mRawPointerAxes.toolMajor.valid && mRawPointerAxes.toolMajor.maxValue != 0) { @@ -847,8 +866,8 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { // Pressure factors. mPressureScale = 0; float pressureMax = 1.0; - if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_PHYSICAL || - mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_AMPLITUDE) { + if (mCalibration.pressureCalibration == Calibration::PressureCalibration::PHYSICAL || + mCalibration.pressureCalibration == Calibration::PressureCalibration::AMPLITUDE) { if (mCalibration.havePressureScale) { mPressureScale = mCalibration.pressureScale; pressureMax = mPressureScale * mRawPointerAxes.pressure.maxValue; @@ -901,9 +920,9 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { mOrientedRanges.orientation.fuzz = 0; mOrientedRanges.orientation.resolution = 0; } else if (mCalibration.orientationCalibration != - Calibration::ORIENTATION_CALIBRATION_NONE) { + Calibration::OrientationCalibration::NONE) { if (mCalibration.orientationCalibration == - Calibration::ORIENTATION_CALIBRATION_INTERPOLATED) { + Calibration::OrientationCalibration::INTERPOLATED) { if (mRawPointerAxes.orientation.valid) { if (mRawPointerAxes.orientation.maxValue > 0) { mOrientationScale = M_PI_2 / mRawPointerAxes.orientation.maxValue; @@ -928,8 +947,8 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { // Distance mDistanceScale = 0; - if (mCalibration.distanceCalibration != Calibration::DISTANCE_CALIBRATION_NONE) { - if (mCalibration.distanceCalibration == Calibration::DISTANCE_CALIBRATION_SCALED) { + if (mCalibration.distanceCalibration != Calibration::DistanceCalibration::NONE) { + if (mCalibration.distanceCalibration == Calibration::DistanceCalibration::SCALED) { if (mCalibration.haveDistanceScale) { mDistanceScale = mCalibration.distanceScale; } else { @@ -991,7 +1010,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { // Location updateAffineTransformation(); - if (mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::POINTER) { // Compute pointer gesture detection parameters. float rawDiagonal = hypotf(rawWidth, rawHeight); float displayDiagonal = hypotf(mRawSurfaceWidth, mRawSurfaceHeight); @@ -1018,7 +1037,8 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { mPointerGestureMaxSwipeWidth = mConfig.pointerGestureSwipeMaxWidthRatio * rawDiagonal; // Abort current pointer usages because the state has changed. - abortPointerUsage(when, 0 /*policyFlags*/); + const nsecs_t readTime = when; // synthetic event + abortPointerUsage(when, readTime, 0 /*policyFlags*/); } // Inform the dispatcher about the changes. @@ -1112,19 +1132,19 @@ void TouchInputMapper::parseCalibration() { Calibration& out = mCalibration; // Size - out.sizeCalibration = Calibration::SIZE_CALIBRATION_DEFAULT; + out.sizeCalibration = Calibration::SizeCalibration::DEFAULT; String8 sizeCalibrationString; if (in.tryGetProperty(String8("touch.size.calibration"), sizeCalibrationString)) { if (sizeCalibrationString == "none") { - out.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; + out.sizeCalibration = Calibration::SizeCalibration::NONE; } else if (sizeCalibrationString == "geometric") { - out.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC; + out.sizeCalibration = Calibration::SizeCalibration::GEOMETRIC; } else if (sizeCalibrationString == "diameter") { - out.sizeCalibration = Calibration::SIZE_CALIBRATION_DIAMETER; + out.sizeCalibration = Calibration::SizeCalibration::DIAMETER; } else if (sizeCalibrationString == "box") { - out.sizeCalibration = Calibration::SIZE_CALIBRATION_BOX; + out.sizeCalibration = Calibration::SizeCalibration::BOX; } else if (sizeCalibrationString == "area") { - out.sizeCalibration = Calibration::SIZE_CALIBRATION_AREA; + out.sizeCalibration = Calibration::SizeCalibration::AREA; } else if (sizeCalibrationString != "default") { ALOGW("Invalid value for touch.size.calibration: '%s'", sizeCalibrationString.string()); } @@ -1135,15 +1155,15 @@ void TouchInputMapper::parseCalibration() { out.haveSizeIsSummed = in.tryGetProperty(String8("touch.size.isSummed"), out.sizeIsSummed); // Pressure - out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_DEFAULT; + out.pressureCalibration = Calibration::PressureCalibration::DEFAULT; String8 pressureCalibrationString; if (in.tryGetProperty(String8("touch.pressure.calibration"), pressureCalibrationString)) { if (pressureCalibrationString == "none") { - out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; + out.pressureCalibration = Calibration::PressureCalibration::NONE; } else if (pressureCalibrationString == "physical") { - out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL; + out.pressureCalibration = Calibration::PressureCalibration::PHYSICAL; } else if (pressureCalibrationString == "amplitude") { - out.pressureCalibration = Calibration::PRESSURE_CALIBRATION_AMPLITUDE; + out.pressureCalibration = Calibration::PressureCalibration::AMPLITUDE; } else if (pressureCalibrationString != "default") { ALOGW("Invalid value for touch.pressure.calibration: '%s'", pressureCalibrationString.string()); @@ -1153,15 +1173,15 @@ void TouchInputMapper::parseCalibration() { out.havePressureScale = in.tryGetProperty(String8("touch.pressure.scale"), out.pressureScale); // Orientation - out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_DEFAULT; + out.orientationCalibration = Calibration::OrientationCalibration::DEFAULT; String8 orientationCalibrationString; if (in.tryGetProperty(String8("touch.orientation.calibration"), orientationCalibrationString)) { if (orientationCalibrationString == "none") { - out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; + out.orientationCalibration = Calibration::OrientationCalibration::NONE; } else if (orientationCalibrationString == "interpolated") { - out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; + out.orientationCalibration = Calibration::OrientationCalibration::INTERPOLATED; } else if (orientationCalibrationString == "vector") { - out.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_VECTOR; + out.orientationCalibration = Calibration::OrientationCalibration::VECTOR; } else if (orientationCalibrationString != "default") { ALOGW("Invalid value for touch.orientation.calibration: '%s'", orientationCalibrationString.string()); @@ -1169,13 +1189,13 @@ void TouchInputMapper::parseCalibration() { } // Distance - out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_DEFAULT; + out.distanceCalibration = Calibration::DistanceCalibration::DEFAULT; String8 distanceCalibrationString; if (in.tryGetProperty(String8("touch.distance.calibration"), distanceCalibrationString)) { if (distanceCalibrationString == "none") { - out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE; + out.distanceCalibration = Calibration::DistanceCalibration::NONE; } else if (distanceCalibrationString == "scaled") { - out.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED; + out.distanceCalibration = Calibration::DistanceCalibration::SCALED; } else if (distanceCalibrationString != "default") { ALOGW("Invalid value for touch.distance.calibration: '%s'", distanceCalibrationString.string()); @@ -1184,13 +1204,13 @@ void TouchInputMapper::parseCalibration() { out.haveDistanceScale = in.tryGetProperty(String8("touch.distance.scale"), out.distanceScale); - out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_DEFAULT; + out.coverageCalibration = Calibration::CoverageCalibration::DEFAULT; String8 coverageCalibrationString; if (in.tryGetProperty(String8("touch.coverage.calibration"), coverageCalibrationString)) { if (coverageCalibrationString == "none") { - out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_NONE; + out.coverageCalibration = Calibration::CoverageCalibration::NONE; } else if (coverageCalibrationString == "box") { - out.coverageCalibration = Calibration::COVERAGE_CALIBRATION_BOX; + out.coverageCalibration = Calibration::CoverageCalibration::BOX; } else if (coverageCalibrationString != "default") { ALOGW("Invalid value for touch.coverage.calibration: '%s'", coverageCalibrationString.string()); @@ -1201,43 +1221,43 @@ void TouchInputMapper::parseCalibration() { void TouchInputMapper::resolveCalibration() { // Size if (mRawPointerAxes.touchMajor.valid || mRawPointerAxes.toolMajor.valid) { - if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DEFAULT) { - mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_GEOMETRIC; + if (mCalibration.sizeCalibration == Calibration::SizeCalibration::DEFAULT) { + mCalibration.sizeCalibration = Calibration::SizeCalibration::GEOMETRIC; } } else { - mCalibration.sizeCalibration = Calibration::SIZE_CALIBRATION_NONE; + mCalibration.sizeCalibration = Calibration::SizeCalibration::NONE; } // Pressure if (mRawPointerAxes.pressure.valid) { - if (mCalibration.pressureCalibration == Calibration::PRESSURE_CALIBRATION_DEFAULT) { - mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_PHYSICAL; + if (mCalibration.pressureCalibration == Calibration::PressureCalibration::DEFAULT) { + mCalibration.pressureCalibration = Calibration::PressureCalibration::PHYSICAL; } } else { - mCalibration.pressureCalibration = Calibration::PRESSURE_CALIBRATION_NONE; + mCalibration.pressureCalibration = Calibration::PressureCalibration::NONE; } // Orientation if (mRawPointerAxes.orientation.valid) { - if (mCalibration.orientationCalibration == Calibration::ORIENTATION_CALIBRATION_DEFAULT) { - mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_INTERPOLATED; + if (mCalibration.orientationCalibration == Calibration::OrientationCalibration::DEFAULT) { + mCalibration.orientationCalibration = Calibration::OrientationCalibration::INTERPOLATED; } } else { - mCalibration.orientationCalibration = Calibration::ORIENTATION_CALIBRATION_NONE; + mCalibration.orientationCalibration = Calibration::OrientationCalibration::NONE; } // Distance if (mRawPointerAxes.distance.valid) { - if (mCalibration.distanceCalibration == Calibration::DISTANCE_CALIBRATION_DEFAULT) { - mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_SCALED; + if (mCalibration.distanceCalibration == Calibration::DistanceCalibration::DEFAULT) { + mCalibration.distanceCalibration = Calibration::DistanceCalibration::SCALED; } } else { - mCalibration.distanceCalibration = Calibration::DISTANCE_CALIBRATION_NONE; + mCalibration.distanceCalibration = Calibration::DistanceCalibration::NONE; } // Coverage - if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_DEFAULT) { - mCalibration.coverageCalibration = Calibration::COVERAGE_CALIBRATION_NONE; + if (mCalibration.coverageCalibration == Calibration::CoverageCalibration::DEFAULT) { + mCalibration.coverageCalibration = Calibration::CoverageCalibration::NONE; } } @@ -1246,19 +1266,19 @@ void TouchInputMapper::dumpCalibration(std::string& dump) { // Size switch (mCalibration.sizeCalibration) { - case Calibration::SIZE_CALIBRATION_NONE: + case Calibration::SizeCalibration::NONE: dump += INDENT4 "touch.size.calibration: none\n"; break; - case Calibration::SIZE_CALIBRATION_GEOMETRIC: + case Calibration::SizeCalibration::GEOMETRIC: dump += INDENT4 "touch.size.calibration: geometric\n"; break; - case Calibration::SIZE_CALIBRATION_DIAMETER: + case Calibration::SizeCalibration::DIAMETER: dump += INDENT4 "touch.size.calibration: diameter\n"; break; - case Calibration::SIZE_CALIBRATION_BOX: + case Calibration::SizeCalibration::BOX: dump += INDENT4 "touch.size.calibration: box\n"; break; - case Calibration::SIZE_CALIBRATION_AREA: + case Calibration::SizeCalibration::AREA: dump += INDENT4 "touch.size.calibration: area\n"; break; default: @@ -1280,13 +1300,13 @@ void TouchInputMapper::dumpCalibration(std::string& dump) { // Pressure switch (mCalibration.pressureCalibration) { - case Calibration::PRESSURE_CALIBRATION_NONE: + case Calibration::PressureCalibration::NONE: dump += INDENT4 "touch.pressure.calibration: none\n"; break; - case Calibration::PRESSURE_CALIBRATION_PHYSICAL: + case Calibration::PressureCalibration::PHYSICAL: dump += INDENT4 "touch.pressure.calibration: physical\n"; break; - case Calibration::PRESSURE_CALIBRATION_AMPLITUDE: + case Calibration::PressureCalibration::AMPLITUDE: dump += INDENT4 "touch.pressure.calibration: amplitude\n"; break; default: @@ -1299,13 +1319,13 @@ void TouchInputMapper::dumpCalibration(std::string& dump) { // Orientation switch (mCalibration.orientationCalibration) { - case Calibration::ORIENTATION_CALIBRATION_NONE: + case Calibration::OrientationCalibration::NONE: dump += INDENT4 "touch.orientation.calibration: none\n"; break; - case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED: + case Calibration::OrientationCalibration::INTERPOLATED: dump += INDENT4 "touch.orientation.calibration: interpolated\n"; break; - case Calibration::ORIENTATION_CALIBRATION_VECTOR: + case Calibration::OrientationCalibration::VECTOR: dump += INDENT4 "touch.orientation.calibration: vector\n"; break; default: @@ -1314,10 +1334,10 @@ void TouchInputMapper::dumpCalibration(std::string& dump) { // Distance switch (mCalibration.distanceCalibration) { - case Calibration::DISTANCE_CALIBRATION_NONE: + case Calibration::DistanceCalibration::NONE: dump += INDENT4 "touch.distance.calibration: none\n"; break; - case Calibration::DISTANCE_CALIBRATION_SCALED: + case Calibration::DistanceCalibration::SCALED: dump += INDENT4 "touch.distance.calibration: scaled\n"; break; default: @@ -1329,10 +1349,10 @@ void TouchInputMapper::dumpCalibration(std::string& dump) { } switch (mCalibration.coverageCalibration) { - case Calibration::COVERAGE_CALIBRATION_NONE: + case Calibration::CoverageCalibration::NONE: dump += INDENT4 "touch.coverage.calibration: none\n"; break; - case Calibration::COVERAGE_CALIBRATION_BOX: + case Calibration::CoverageCalibration::BOX: dump += INDENT4 "touch.coverage.calibration: box\n"; break; default: @@ -1370,7 +1390,7 @@ void TouchInputMapper::reset(nsecs_t when) { mCurrentCookedState.clear(); mLastRawState.clear(); mLastCookedState.clear(); - mPointerUsage = POINTER_USAGE_NONE; + mPointerUsage = PointerUsage::NONE; mSentHoverEnter = false; mHavePointerIds = false; mCurrentMotionAborted = false; @@ -1383,7 +1403,7 @@ void TouchInputMapper::reset(nsecs_t when) { resetExternalStylus(); if (mPointerController != nullptr) { - mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); + mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); mPointerController->clearSpots(); } @@ -1408,32 +1428,34 @@ void TouchInputMapper::process(const RawEvent* rawEvent) { mTouchButtonAccumulator.process(rawEvent); if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { - sync(rawEvent->when); + sync(rawEvent->when, rawEvent->readTime); } } -void TouchInputMapper::sync(nsecs_t when) { - const RawState* last = - mRawStatesPending.empty() ? &mCurrentRawState : &mRawStatesPending.back(); - +void TouchInputMapper::sync(nsecs_t when, nsecs_t readTime) { // Push a new state. mRawStatesPending.emplace_back(); - RawState* next = &mRawStatesPending.back(); - next->clear(); - next->when = when; + RawState& next = mRawStatesPending.back(); + next.clear(); + next.when = when; + next.readTime = readTime; // Sync button state. - next->buttonState = + next.buttonState = mTouchButtonAccumulator.getButtonState() | mCursorButtonAccumulator.getButtonState(); // Sync scroll - next->rawVScroll = mCursorScrollAccumulator.getRelativeVWheel(); - next->rawHScroll = mCursorScrollAccumulator.getRelativeHWheel(); + next.rawVScroll = mCursorScrollAccumulator.getRelativeVWheel(); + next.rawHScroll = mCursorScrollAccumulator.getRelativeHWheel(); mCursorScrollAccumulator.finishSync(); // Sync touch - syncTouch(when, next); + syncTouch(when, &next); + + // The last RawState is the actually second to last, since we just added a new state + const RawState& last = + mRawStatesPending.size() == 1 ? mCurrentRawState : mRawStatesPending.rbegin()[1]; // Assign pointer ids. if (!mHavePointerIds) { @@ -1442,20 +1464,29 @@ void TouchInputMapper::sync(nsecs_t when) { #if DEBUG_RAW_EVENTS ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, " - "hovering ids 0x%08x -> 0x%08x", - last->rawPointerData.pointerCount, next->rawPointerData.pointerCount, - last->rawPointerData.touchingIdBits.value, next->rawPointerData.touchingIdBits.value, - last->rawPointerData.hoveringIdBits.value, next->rawPointerData.hoveringIdBits.value); + "hovering ids 0x%08x -> 0x%08x, canceled ids 0x%08x", + last.rawPointerData.pointerCount, next.rawPointerData.pointerCount, + last.rawPointerData.touchingIdBits.value, next.rawPointerData.touchingIdBits.value, + last.rawPointerData.hoveringIdBits.value, next.rawPointerData.hoveringIdBits.value, + next.rawPointerData.canceledIdBits.value); #endif + if (!next.rawPointerData.touchingIdBits.isEmpty() && + !next.rawPointerData.hoveringIdBits.isEmpty() && + last.rawPointerData.hoveringIdBits != next.rawPointerData.hoveringIdBits) { + ALOGI("Multi-touch contains some hovering ids 0x%08x", + next.rawPointerData.hoveringIdBits.value); + } + processRawTouches(false /*timeout*/); } void TouchInputMapper::processRawTouches(bool timeout) { - if (mDeviceMode == DEVICE_MODE_DISABLED) { + if (mDeviceMode == DeviceMode::DISABLED) { // Drop all input if the device is disabled. - mCurrentRawState.clear(); - mRawStatesPending.clear(); + cancelTouch(mCurrentRawState.when, mCurrentRawState.readTime); + mCurrentCookedState.clear(); + updateTouchSpots(); return; } @@ -1479,8 +1510,9 @@ void TouchInputMapper::processRawTouches(bool timeout) { mCurrentRawState.copyFrom(next); if (mCurrentRawState.when < mLastRawState.when) { mCurrentRawState.when = mLastRawState.when; + mCurrentRawState.readTime = mLastRawState.readTime; } - cookAndDispatch(mCurrentRawState.when); + cookAndDispatch(mCurrentRawState.when, mCurrentRawState.readTime); } if (count != 0) { mRawStatesPending.erase(mRawStatesPending.begin(), mRawStatesPending.begin() + count); @@ -1494,7 +1526,8 @@ void TouchInputMapper::processRawTouches(bool timeout) { #if DEBUG_STYLUS_FUSION ALOGD("Timeout expired, synthesizing event with new stylus data"); #endif - cookAndDispatch(when); + const nsecs_t readTime = when; // consider this synthetic event to be zero latency + cookAndDispatch(when, readTime); } else if (mExternalStylusFusionTimeout == LLONG_MAX) { mExternalStylusFusionTimeout = mExternalStylusState.when + TOUCH_DATA_TIMEOUT; getContext()->requestTimeoutAtTime(mExternalStylusFusionTimeout); @@ -1502,7 +1535,7 @@ void TouchInputMapper::processRawTouches(bool timeout) { } } -void TouchInputMapper::cookAndDispatch(nsecs_t when) { +void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { // Always start with a clean state. mCurrentCookedState.clear(); @@ -1517,7 +1550,7 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { bool buttonsPressed = mCurrentRawState.buttonState & ~mLastRawState.buttonState; if (initialDown || buttonsPressed) { // If this is a touch screen, hide the pointer on an initial down. - if (mDeviceMode == DEVICE_MODE_DIRECT) { + if (mDeviceMode == DeviceMode::DIRECT) { getContext()->fadePointer(); } @@ -1528,7 +1561,7 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { // Consume raw off-screen touches before cooking pointer data. // If touches are consumed, subsequent code will not receive any pointer data. - if (consumeRawTouches(when, policyFlags)) { + if (consumeRawTouches(when, readTime, policyFlags)) { mCurrentRawState.rawPointerData.clear(); } @@ -1541,12 +1574,12 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { applyExternalStylusTouchState(when); // Synthesize key down from raw buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource, - mViewport.displayId, policyFlags, mLastCookedState.buttonState, + synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, readTime, getDeviceId(), + mSource, mViewport.displayId, policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState); // Dispatch the touches either directly or by translation through a pointer on screen. - if (mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::POINTER) { for (BitSet32 idBits(mCurrentRawState.rawPointerData.touchingIdBits); !idBits.isEmpty();) { uint32_t id = idBits.clearFirstMarkedBit(); const RawPointerData::Pointer& pointer = @@ -1576,35 +1609,25 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { if (!mCurrentCookedState.stylusIdBits.isEmpty()) { mCurrentCookedState.mouseIdBits.clear(); mCurrentCookedState.fingerIdBits.clear(); - pointerUsage = POINTER_USAGE_STYLUS; + pointerUsage = PointerUsage::STYLUS; } else if (!mCurrentCookedState.mouseIdBits.isEmpty()) { mCurrentCookedState.fingerIdBits.clear(); - pointerUsage = POINTER_USAGE_MOUSE; + pointerUsage = PointerUsage::MOUSE; } else if (!mCurrentCookedState.fingerIdBits.isEmpty() || isPointerDown(mCurrentRawState.buttonState)) { - pointerUsage = POINTER_USAGE_GESTURES; + pointerUsage = PointerUsage::GESTURES; } - dispatchPointerUsage(when, policyFlags, pointerUsage); + dispatchPointerUsage(when, readTime, policyFlags, pointerUsage); } else { - if (mDeviceMode == DEVICE_MODE_DIRECT && mConfig.showTouches && - mPointerController != nullptr) { - mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT); - mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); - - mPointerController->setButtonState(mCurrentRawState.buttonState); - mPointerController->setSpots(mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, - mCurrentCookedState.cookedPointerData.touchingIdBits, - mViewport.displayId); - } + updateTouchSpots(); if (!mCurrentMotionAborted) { - dispatchButtonRelease(when, policyFlags); - dispatchHoverExit(when, policyFlags); - dispatchTouches(when, policyFlags); - dispatchHoverEnterAndMove(when, policyFlags); - dispatchButtonPress(when, policyFlags); + dispatchButtonRelease(when, readTime, policyFlags); + dispatchHoverExit(when, readTime, policyFlags); + dispatchTouches(when, readTime, policyFlags); + dispatchHoverEnterAndMove(when, readTime, policyFlags); + dispatchButtonPress(when, readTime, policyFlags); } if (mCurrentCookedState.cookedPointerData.pointerCount == 0) { @@ -1613,7 +1636,7 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { } // Synthesize key up from raw buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource, + synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, readTime, getDeviceId(), mSource, mViewport.displayId, policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState); @@ -1626,8 +1649,34 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) { mLastCookedState.copyFrom(mCurrentCookedState); } +void TouchInputMapper::updateTouchSpots() { + if (!mConfig.showTouches || mPointerController == nullptr) { + return; + } + + // Update touch spots when this is a touchscreen even when it's not enabled so that we can + // clear touch spots. + if (mDeviceMode != DeviceMode::DIRECT && + (mDeviceMode != DeviceMode::DISABLED || !isTouchScreen())) { + return; + } + + mPointerController->setPresentation(PointerControllerInterface::Presentation::SPOT); + mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); + + mPointerController->setButtonState(mCurrentRawState.buttonState); + setTouchSpots(mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, + mCurrentCookedState.cookedPointerData.touchingIdBits, mViewport.displayId); +} + +bool TouchInputMapper::isTouchScreen() { + return mParameters.deviceType == Parameters::DeviceType::TOUCH_SCREEN && + mParameters.hasAssociatedDisplay; +} + void TouchInputMapper::applyExternalStylusButtonState(nsecs_t when) { - if (mDeviceMode == DEVICE_MODE_DIRECT && hasExternalStylus() && mExternalStylusId != -1) { + if (mDeviceMode == DeviceMode::DIRECT && hasExternalStylus() && mExternalStylusId != -1) { mCurrentRawState.buttonState |= mExternalStylusState.buttons; } } @@ -1654,7 +1703,7 @@ void TouchInputMapper::applyExternalStylusTouchState(nsecs_t when) { } bool TouchInputMapper::assignExternalStylusId(const RawState& state, bool timeout) { - if (mDeviceMode != DEVICE_MODE_DIRECT || !hasExternalStylus()) { + if (mDeviceMode != DeviceMode::DIRECT || !hasExternalStylus()) { return false; } @@ -1697,11 +1746,13 @@ bool TouchInputMapper::assignExternalStylusId(const RawState& state, bool timeou } void TouchInputMapper::timeoutExpired(nsecs_t when) { - if (mDeviceMode == DEVICE_MODE_POINTER) { - if (mPointerUsage == POINTER_USAGE_GESTURES) { - dispatchPointerGestures(when, 0 /*policyFlags*/, true /*isTimeout*/); + if (mDeviceMode == DeviceMode::POINTER) { + if (mPointerUsage == PointerUsage::GESTURES) { + // Since this is a synthetic event, we can consider its latency to be zero + const nsecs_t readTime = when; + dispatchPointerGestures(when, readTime, 0 /*policyFlags*/, true /*isTimeout*/); } - } else if (mDeviceMode == DEVICE_MODE_DIRECT) { + } else if (mDeviceMode == DeviceMode::DIRECT) { if (mExternalStylusFusionTimeout < when) { processRawTouches(true /*timeout*/); } else if (mExternalStylusFusionTimeout != LLONG_MAX) { @@ -1721,7 +1772,7 @@ void TouchInputMapper::updateExternalStylusState(const StylusState& state) { } } -bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { +bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { // Check for release of a virtual key. if (mCurrentVirtualKey.down) { if (mCurrentRawState.rawPointerData.touchingIdBits.isEmpty()) { @@ -1732,7 +1783,7 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { ALOGD("VirtualKeys: Generating key up: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); #endif - dispatchVirtualKey(when, policyFlags, AKEY_EVENT_ACTION_UP, + dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); } return true; @@ -1759,7 +1810,7 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { ALOGD("VirtualKeys: Canceling key: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); #endif - dispatchVirtualKey(when, policyFlags, AKEY_EVENT_ACTION_UP, + dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY | AKEY_EVENT_FLAG_CANCELED); } @@ -1770,7 +1821,8 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { // Pointer just went down. Check for virtual key press or off-screen touches. uint32_t id = mCurrentRawState.rawPointerData.touchingIdBits.firstMarkedBit(); const RawPointerData::Pointer& pointer = mCurrentRawState.rawPointerData.pointerForId(id); - if (!isPointInsideSurface(pointer.x, pointer.y)) { + // Exclude unscaled device for inside surface checking. + if (!isPointInsideSurface(pointer.x, pointer.y) && mDeviceMode != DeviceMode::UNSCALED) { // If exactly one pointer went down, check for virtual key hit. // Otherwise we will drop the entire stroke. if (mCurrentRawState.rawPointerData.touchingIdBits.count() == 1) { @@ -1789,7 +1841,7 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { ALOGD("VirtualKeys: Generating key down: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); #endif - dispatchVirtualKey(when, policyFlags, AKEY_EVENT_ACTION_DOWN, + dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_DOWN, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); } @@ -1820,7 +1872,7 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, uint32_t policyFlags) { return false; } -void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags, +void TouchInputMapper::dispatchVirtualKey(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, int32_t keyEventAction, int32_t keyEventFlags) { int32_t keyCode = mCurrentVirtualKey.keyCode; int32_t scanCode = mCurrentVirtualKey.scanCode; @@ -1828,19 +1880,19 @@ void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags, int32_t metaState = getContext()->getGlobalMetaState(); policyFlags |= POLICY_FLAG_VIRTUAL; - NotifyKeyArgs args(getContext()->getNextId(), when, getDeviceId(), AINPUT_SOURCE_KEYBOARD, - mViewport.displayId, policyFlags, keyEventAction, keyEventFlags, keyCode, - scanCode, metaState, downTime); + NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), + AINPUT_SOURCE_KEYBOARD, mViewport.displayId, policyFlags, keyEventAction, + keyEventFlags, keyCode, scanCode, metaState, downTime); getListener()->notifyKey(&args); } -void TouchInputMapper::abortTouches(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::abortTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits; if (!currentIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentCookedState.buttonState; - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, + metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, -1, @@ -1849,7 +1901,7 @@ void TouchInputMapper::abortTouches(nsecs_t when, uint32_t policyFlags) { } } -void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits; BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits; int32_t metaState = getContext()->getGlobalMetaState(); @@ -1859,8 +1911,8 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { if (!currentIdBits.isEmpty()) { // No pointer id changes so this is a move event. // The listener takes care of batching moves so we don't have to deal with that here. - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, + metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, -1, @@ -1890,14 +1942,18 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { // Dispatch pointer up events. while (!upIdBits.isEmpty()) { uint32_t upId = upIdBits.clearFirstMarkedBit(); - - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, - metaState, buttonState, 0, + bool isCanceled = mCurrentCookedState.cookedPointerData.canceledIdBits.hasBit(upId); + if (isCanceled) { + ALOGI("Canceling pointer %d for the palm event was detected.", upId); + } + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, + isCanceled ? AMOTION_EVENT_FLAG_CANCELED : 0, metaState, buttonState, 0, mLastCookedState.cookedPointerData.pointerProperties, mLastCookedState.cookedPointerData.pointerCoords, mLastCookedState.cookedPointerData.idToIndex, dispatchedIdBits, upId, mOrientedXPrecision, mOrientedYPrecision, mDownTime); dispatchedIdBits.clearBit(upId); + mCurrentCookedState.cookedPointerData.canceledIdBits.clearBit(upId); } // Dispatch move events if any of the remaining pointers moved from their old locations. @@ -1905,8 +1961,9 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { // events, they do not generally handle them except when presented in a move event. if (moveNeeded && !moveIdBits.isEmpty()) { ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value); - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, - buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, + metaState, buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, dispatchedIdBits, -1, mOrientedXPrecision, mOrientedYPrecision, mDownTime); @@ -1922,8 +1979,8 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { mDownTime = when; } - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, - metaState, buttonState, 0, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, + 0, 0, metaState, buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, dispatchedIdBits, @@ -1932,13 +1989,13 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { } } -void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchHoverExit(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { if (mSentHoverEnter && (mCurrentCookedState.cookedPointerData.hoveringIdBits.isEmpty() || !mCurrentCookedState.cookedPointerData.touchingIdBits.isEmpty())) { int32_t metaState = getContext()->getGlobalMetaState(); - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, - mLastCookedState.buttonState, 0, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, + metaState, mLastCookedState.buttonState, 0, mLastCookedState.cookedPointerData.pointerProperties, mLastCookedState.cookedPointerData.pointerCoords, mLastCookedState.cookedPointerData.idToIndex, @@ -1948,13 +2005,14 @@ void TouchInputMapper::dispatchHoverExit(nsecs_t when, uint32_t policyFlags) { } } -void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { if (mCurrentCookedState.cookedPointerData.touchingIdBits.isEmpty() && !mCurrentCookedState.cookedPointerData.hoveringIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); if (!mSentHoverEnter) { - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, - metaState, mCurrentRawState.buttonState, 0, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_ENTER, + 0, 0, metaState, mCurrentRawState.buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -1963,8 +2021,8 @@ void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFl mSentHoverEnter = true; } - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, - mCurrentRawState.buttonState, 0, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, + metaState, mCurrentRawState.buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, @@ -1973,7 +2031,7 @@ void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFl } } -void TouchInputMapper::dispatchButtonRelease(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchButtonRelease(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { BitSet32 releasedButtons(mLastCookedState.buttonState & ~mCurrentCookedState.buttonState); const BitSet32& idBits = findActiveIdBits(mLastCookedState.cookedPointerData); const int32_t metaState = getContext()->getGlobalMetaState(); @@ -1981,7 +2039,7 @@ void TouchInputMapper::dispatchButtonRelease(nsecs_t when, uint32_t policyFlags) while (!releasedButtons.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(releasedButtons.clearFirstMarkedBit()); buttonState &= ~actionButton; - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_RELEASE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, metaState, buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, @@ -1990,7 +2048,7 @@ void TouchInputMapper::dispatchButtonRelease(nsecs_t when, uint32_t policyFlags) } } -void TouchInputMapper::dispatchButtonPress(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchButtonPress(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { BitSet32 pressedButtons(mCurrentCookedState.buttonState & ~mLastCookedState.buttonState); const BitSet32& idBits = findActiveIdBits(mCurrentCookedState.cookedPointerData); const int32_t metaState = getContext()->getGlobalMetaState(); @@ -1998,8 +2056,8 @@ void TouchInputMapper::dispatchButtonPress(nsecs_t when, uint32_t policyFlags) { while (!pressedButtons.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(pressedButtons.clearFirstMarkedBit()); buttonState |= actionButton; - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, - 0, metaState, buttonState, 0, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_PRESS, + actionButton, 0, metaState, buttonState, 0, mCurrentCookedState.cookedPointerData.pointerProperties, mCurrentCookedState.cookedPointerData.pointerCoords, mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, @@ -2023,6 +2081,8 @@ void TouchInputMapper::cookPointerData() { mCurrentRawState.rawPointerData.hoveringIdBits; mCurrentCookedState.cookedPointerData.touchingIdBits = mCurrentRawState.rawPointerData.touchingIdBits; + mCurrentCookedState.cookedPointerData.canceledIdBits = + mCurrentRawState.rawPointerData.canceledIdBits; if (mCurrentCookedState.cookedPointerData.pointerCount == 0) { mCurrentCookedState.buttonState = 0; @@ -2038,10 +2098,10 @@ void TouchInputMapper::cookPointerData() { // Size float touchMajor, touchMinor, toolMajor, toolMinor, size; switch (mCalibration.sizeCalibration) { - case Calibration::SIZE_CALIBRATION_GEOMETRIC: - case Calibration::SIZE_CALIBRATION_DIAMETER: - case Calibration::SIZE_CALIBRATION_BOX: - case Calibration::SIZE_CALIBRATION_AREA: + case Calibration::SizeCalibration::GEOMETRIC: + case Calibration::SizeCalibration::DIAMETER: + case Calibration::SizeCalibration::BOX: + case Calibration::SizeCalibration::AREA: if (mRawPointerAxes.touchMajor.valid && mRawPointerAxes.toolMajor.valid) { touchMajor = in.touchMajor; touchMinor = mRawPointerAxes.touchMinor.valid ? in.touchMinor : in.touchMajor; @@ -2083,17 +2143,17 @@ void TouchInputMapper::cookPointerData() { } } - if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_GEOMETRIC) { + if (mCalibration.sizeCalibration == Calibration::SizeCalibration::GEOMETRIC) { touchMajor *= mGeometricScale; touchMinor *= mGeometricScale; toolMajor *= mGeometricScale; toolMinor *= mGeometricScale; - } else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_AREA) { + } else if (mCalibration.sizeCalibration == Calibration::SizeCalibration::AREA) { touchMajor = touchMajor > 0 ? sqrtf(touchMajor) : 0; touchMinor = touchMajor; toolMajor = toolMajor > 0 ? sqrtf(toolMajor) : 0; toolMinor = toolMajor; - } else if (mCalibration.sizeCalibration == Calibration::SIZE_CALIBRATION_DIAMETER) { + } else if (mCalibration.sizeCalibration == Calibration::SizeCalibration::DIAMETER) { touchMinor = touchMajor; toolMinor = toolMajor; } @@ -2116,8 +2176,8 @@ void TouchInputMapper::cookPointerData() { // Pressure float pressure; switch (mCalibration.pressureCalibration) { - case Calibration::PRESSURE_CALIBRATION_PHYSICAL: - case Calibration::PRESSURE_CALIBRATION_AMPLITUDE: + case Calibration::PressureCalibration::PHYSICAL: + case Calibration::PressureCalibration::AMPLITUDE: pressure = in.pressure * mPressureScale; break; default: @@ -2137,10 +2197,10 @@ void TouchInputMapper::cookPointerData() { tilt = 0; switch (mCalibration.orientationCalibration) { - case Calibration::ORIENTATION_CALIBRATION_INTERPOLATED: + case Calibration::OrientationCalibration::INTERPOLATED: orientation = in.orientation * mOrientationScale; break; - case Calibration::ORIENTATION_CALIBRATION_VECTOR: { + case Calibration::OrientationCalibration::VECTOR: { int32_t c1 = signExtendNybble((in.orientation & 0xf0) >> 4); int32_t c2 = signExtendNybble(in.orientation & 0x0f); if (c1 != 0 || c2 != 0) { @@ -2164,7 +2224,7 @@ void TouchInputMapper::cookPointerData() { // Distance float distance; switch (mCalibration.distanceCalibration) { - case Calibration::DISTANCE_CALIBRATION_SCALED: + case Calibration::DistanceCalibration::SCALED: distance = in.distance * mDistanceScale; break; default: @@ -2174,7 +2234,7 @@ void TouchInputMapper::cookPointerData() { // Coverage int32_t rawLeft, rawTop, rawRight, rawBottom; switch (mCalibration.coverageCalibration) { - case Calibration::COVERAGE_CALIBRATION_BOX: + case Calibration::CoverageCalibration::BOX: rawLeft = (in.toolMinor & 0xffff0000) >> 16; rawRight = in.toolMinor & 0x0000ffff; rawBottom = in.toolMajor & 0x0000ffff; @@ -2251,7 +2311,7 @@ void TouchInputMapper::cookPointerData() { out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation); out.setAxisValue(AMOTION_EVENT_AXIS_TILT, tilt); out.setAxisValue(AMOTION_EVENT_AXIS_DISTANCE, distance); - if (mCalibration.coverageCalibration == Calibration::COVERAGE_CALIBRATION_BOX) { + if (mCalibration.coverageCalibration == Calibration::CoverageCalibration::BOX) { out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_1, left); out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_2, top); out.setAxisValue(AMOTION_EVENT_AXIS_GENERIC_3, right); @@ -2261,59 +2321,71 @@ void TouchInputMapper::cookPointerData() { out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor); } + // Write output relative fields if applicable. + uint32_t id = in.id; + if (mSource == AINPUT_SOURCE_TOUCHPAD && + mLastCookedState.cookedPointerData.hasPointerCoordsForId(id)) { + const PointerCoords& p = mLastCookedState.cookedPointerData.pointerCoordsForId(id); + float dx = xTransformed - p.getAxisValue(AMOTION_EVENT_AXIS_X); + float dy = yTransformed - p.getAxisValue(AMOTION_EVENT_AXIS_Y); + out.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, dx); + out.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy); + } + // Write output properties. PointerProperties& properties = mCurrentCookedState.cookedPointerData.pointerProperties[i]; - uint32_t id = in.id; properties.clear(); properties.id = id; properties.toolType = in.toolType; - // Write id index. + // Write id index and mark id as valid. mCurrentCookedState.cookedPointerData.idToIndex[id] = i; + mCurrentCookedState.cookedPointerData.validIdBits.markBit(id); } } -void TouchInputMapper::dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, +void TouchInputMapper::dispatchPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, PointerUsage pointerUsage) { if (pointerUsage != mPointerUsage) { - abortPointerUsage(when, policyFlags); + abortPointerUsage(when, readTime, policyFlags); mPointerUsage = pointerUsage; } switch (mPointerUsage) { - case POINTER_USAGE_GESTURES: - dispatchPointerGestures(when, policyFlags, false /*isTimeout*/); + case PointerUsage::GESTURES: + dispatchPointerGestures(when, readTime, policyFlags, false /*isTimeout*/); break; - case POINTER_USAGE_STYLUS: - dispatchPointerStylus(when, policyFlags); + case PointerUsage::STYLUS: + dispatchPointerStylus(when, readTime, policyFlags); break; - case POINTER_USAGE_MOUSE: - dispatchPointerMouse(when, policyFlags); + case PointerUsage::MOUSE: + dispatchPointerMouse(when, readTime, policyFlags); break; - default: + case PointerUsage::NONE: break; } } -void TouchInputMapper::abortPointerUsage(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::abortPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { switch (mPointerUsage) { - case POINTER_USAGE_GESTURES: - abortPointerGestures(when, policyFlags); + case PointerUsage::GESTURES: + abortPointerGestures(when, readTime, policyFlags); break; - case POINTER_USAGE_STYLUS: - abortPointerStylus(when, policyFlags); + case PointerUsage::STYLUS: + abortPointerStylus(when, readTime, policyFlags); break; - case POINTER_USAGE_MOUSE: - abortPointerMouse(when, policyFlags); + case PointerUsage::MOUSE: + abortPointerMouse(when, readTime, policyFlags); break; - default: + case PointerUsage::NONE: break; } - mPointerUsage = POINTER_USAGE_NONE; + mPointerUsage = PointerUsage::NONE; } -void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout) { +void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, + bool isTimeout) { // Update current gesture coordinates. bool cancelPreviousGesture, finishPreviousGesture; bool sendEvents = @@ -2326,49 +2398,48 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag } // Update the pointer presentation and spots. - if (mParameters.gestureMode == Parameters::GESTURE_MODE_MULTI_TOUCH) { - mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); + if (mParameters.gestureMode == Parameters::GestureMode::MULTI_TOUCH) { + mPointerController->setPresentation(PointerControllerInterface::Presentation::POINTER); if (finishPreviousGesture || cancelPreviousGesture) { mPointerController->clearSpots(); } - if (mPointerGesture.currentGestureMode == PointerGesture::FREEFORM) { - mPointerController->setSpots(mPointerGesture.currentGestureCoords, - mPointerGesture.currentGestureIdToIndex, - mPointerGesture.currentGestureIdBits, - mPointerController->getDisplayId()); + if (mPointerGesture.currentGestureMode == PointerGesture::Mode::FREEFORM) { + setTouchSpots(mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, + mPointerGesture.currentGestureIdBits, mPointerController->getDisplayId()); } } else { - mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); + mPointerController->setPresentation(PointerControllerInterface::Presentation::POINTER); } // Show or hide the pointer if needed. switch (mPointerGesture.currentGestureMode) { - case PointerGesture::NEUTRAL: - case PointerGesture::QUIET: - if (mParameters.gestureMode == Parameters::GESTURE_MODE_MULTI_TOUCH && - mPointerGesture.lastGestureMode == PointerGesture::FREEFORM) { + case PointerGesture::Mode::NEUTRAL: + case PointerGesture::Mode::QUIET: + if (mParameters.gestureMode == Parameters::GestureMode::MULTI_TOUCH && + mPointerGesture.lastGestureMode == PointerGesture::Mode::FREEFORM) { // Remind the user of where the pointer is after finishing a gesture with spots. - mPointerController->unfade(PointerControllerInterface::TRANSITION_GRADUAL); + mPointerController->unfade(PointerControllerInterface::Transition::GRADUAL); } break; - case PointerGesture::TAP: - case PointerGesture::TAP_DRAG: - case PointerGesture::BUTTON_CLICK_OR_DRAG: - case PointerGesture::HOVER: - case PointerGesture::PRESS: - case PointerGesture::SWIPE: + case PointerGesture::Mode::TAP: + case PointerGesture::Mode::TAP_DRAG: + case PointerGesture::Mode::BUTTON_CLICK_OR_DRAG: + case PointerGesture::Mode::HOVER: + case PointerGesture::Mode::PRESS: + case PointerGesture::Mode::SWIPE: // Unfade the pointer when the current gesture manipulates the // area directly under the pointer. - mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); + mPointerController->unfade(PointerControllerInterface::Transition::IMMEDIATE); break; - case PointerGesture::FREEFORM: + case PointerGesture::Mode::FREEFORM: // Fade the pointer when the current gesture manipulates a different // area and there are spots to guide the user experience. - if (mParameters.gestureMode == Parameters::GESTURE_MODE_MULTI_TOUCH) { - mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); + if (mParameters.gestureMode == Parameters::GestureMode::MULTI_TOUCH) { + mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); } else { - mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); + mPointerController->unfade(PointerControllerInterface::Transition::IMMEDIATE); } break; } @@ -2377,14 +2448,20 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentCookedState.buttonState; + uint32_t flags = 0; + + if (!PointerGesture::canGestureAffectWindowFocus(mPointerGesture.currentGestureMode)) { + flags |= AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE; + } + // Update last coordinates of pointers that have moved so that we observe the new // pointer positions at the same time as other pointers that have just gone up. - bool down = mPointerGesture.currentGestureMode == PointerGesture::TAP || - mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG || - mPointerGesture.currentGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG || - mPointerGesture.currentGestureMode == PointerGesture::PRESS || - mPointerGesture.currentGestureMode == PointerGesture::SWIPE || - mPointerGesture.currentGestureMode == PointerGesture::FREEFORM; + bool down = mPointerGesture.currentGestureMode == PointerGesture::Mode::TAP || + mPointerGesture.currentGestureMode == PointerGesture::Mode::TAP_DRAG || + mPointerGesture.currentGestureMode == PointerGesture::Mode::BUTTON_CLICK_OR_DRAG || + mPointerGesture.currentGestureMode == PointerGesture::Mode::PRESS || + mPointerGesture.currentGestureMode == PointerGesture::Mode::SWIPE || + mPointerGesture.currentGestureMode == PointerGesture::Mode::FREEFORM; bool moveNeeded = false; if (down && !cancelPreviousGesture && !finishPreviousGesture && !mPointerGesture.lastGestureIdBits.isEmpty() && @@ -2406,8 +2483,8 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits); if (!dispatchedGestureIdBits.isEmpty()) { if (cancelPreviousGesture) { - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, + flags, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, mPointerGesture.downTime); @@ -2424,9 +2501,9 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag while (!upGestureIdBits.isEmpty()) { uint32_t id = upGestureIdBits.clearFirstMarkedBit(); - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mPointerGesture.lastGestureProperties, + dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_POINTER_UP, 0, flags, metaState, buttonState, + AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, id, 0, 0, mPointerGesture.downTime); @@ -2438,8 +2515,8 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag // Send motion events for all pointers that moved. if (moveNeeded) { - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, flags, + metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.currentGestureProperties, mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, @@ -2458,8 +2535,9 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag mPointerGesture.downTime = when; } - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, - metaState, buttonState, 0, mPointerGesture.currentGestureProperties, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, + 0, flags, metaState, buttonState, 0, + mPointerGesture.currentGestureProperties, mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, id, 0, 0, mPointerGesture.downTime); @@ -2467,9 +2545,9 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag } // Send motion events for hover. - if (mPointerGesture.currentGestureMode == PointerGesture::HOVER) { - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + if (mPointerGesture.currentGestureMode == PointerGesture::Mode::HOVER) { + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, + flags, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.currentGestureProperties, mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex, @@ -2479,8 +2557,7 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag // the pointer is hovering again even if the user is not currently touching // the touch pad. This ensures that a view will receive a fresh hover enter // event after a tap. - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); PointerProperties pointerProperties; pointerProperties.clear(); @@ -2493,11 +2570,11 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); const int32_t displayId = mPointerController->getDisplayId(); - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, - buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, - 1, &pointerProperties, &pointerCoords, 0, 0, x, y, - mPointerGesture.downTime, /* videoFrames */ {}); + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, flags, + metaState, buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, + 0, 0, x, y, mPointerGesture.downTime, /* videoFrames */ {}); getListener()->notifyMotion(&args); } @@ -2519,13 +2596,13 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, uint32_t policyFlag } } -void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::abortPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { // Cancel previously dispatches pointers. if (!mPointerGesture.lastGestureIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentRawState.buttonState; - dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, - buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, + metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex, mPointerGesture.lastGestureIdBits, -1, 0, 0, mPointerGesture.downTime); @@ -2537,7 +2614,7 @@ void TouchInputMapper::abortPointerGestures(nsecs_t when, uint32_t policyFlags) // Remove any current spots. if (mPointerController != nullptr) { - mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); + mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); mPointerController->clearSpots(); } } @@ -2553,7 +2630,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi ALOGD("Gestures: Processing timeout"); #endif - if (mPointerGesture.lastGestureMode == PointerGesture::TAP) { + if (mPointerGesture.lastGestureMode == PointerGesture::Mode::TAP) { if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) { // The tap/drag timeout has not yet expired. getContext()->requestTimeoutAtTime(mPointerGesture.tapUpTime + @@ -2566,7 +2643,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi *outFinishPreviousGesture = true; mPointerGesture.activeGestureId = -1; - mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; + mPointerGesture.currentGestureMode = PointerGesture::Mode::NEUTRAL; mPointerGesture.currentGestureIdBits.clear(); mPointerVelocityControl.reset(); @@ -2583,14 +2660,14 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi // Update the velocity tracker. { - VelocityTracker::Position positions[MAX_POINTERS]; - uint32_t count = 0; - for (BitSet32 idBits(mCurrentCookedState.fingerIdBits); !idBits.isEmpty(); count++) { + std::vector<VelocityTracker::Position> positions; + for (BitSet32 idBits(mCurrentCookedState.fingerIdBits); !idBits.isEmpty();) { uint32_t id = idBits.clearFirstMarkedBit(); const RawPointerData::Pointer& pointer = mCurrentRawState.rawPointerData.pointerForId(id); - positions[count].x = pointer.x * mPointerXMovementScale; - positions[count].y = pointer.y * mPointerYMovementScale; + float x = pointer.x * mPointerXMovementScale; + float y = pointer.y * mPointerYMovementScale; + positions.push_back({x, y}); } mPointerGesture.velocityTracker.addMovement(when, mCurrentCookedState.fingerIdBits, positions); @@ -2598,9 +2675,9 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi // If the gesture ever enters a mode other than TAP, HOVER or TAP_DRAG, without first returning // to NEUTRAL, then we should not generate tap event. - if (mPointerGesture.lastGestureMode != PointerGesture::HOVER && - mPointerGesture.lastGestureMode != PointerGesture::TAP && - mPointerGesture.lastGestureMode != PointerGesture::TAP_DRAG) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::HOVER && + mPointerGesture.lastGestureMode != PointerGesture::Mode::TAP && + mPointerGesture.lastGestureMode != PointerGesture::Mode::TAP_DRAG) { mPointerGesture.resetTap(); } @@ -2633,15 +2710,16 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi } else { isQuietTime = when < mPointerGesture.quietTime + mConfig.pointerGestureQuietInterval; if (!isQuietTime) { - if ((mPointerGesture.lastGestureMode == PointerGesture::PRESS || - mPointerGesture.lastGestureMode == PointerGesture::SWIPE || - mPointerGesture.lastGestureMode == PointerGesture::FREEFORM) && + if ((mPointerGesture.lastGestureMode == PointerGesture::Mode::PRESS || + mPointerGesture.lastGestureMode == PointerGesture::Mode::SWIPE || + mPointerGesture.lastGestureMode == PointerGesture::Mode::FREEFORM) && currentFingerCount < 2) { // Enter quiet time when exiting swipe or freeform state. // This is to prevent accidentally entering the hover state and flinging the // pointer when finishing a swipe and there is still one pointer left onscreen. isQuietTime = true; - } else if (mPointerGesture.lastGestureMode == PointerGesture::BUTTON_CLICK_OR_DRAG && + } else if (mPointerGesture.lastGestureMode == + PointerGesture::Mode::BUTTON_CLICK_OR_DRAG && currentFingerCount >= 2 && !isPointerDown(mCurrentRawState.buttonState)) { // Enter quiet time when releasing the button and there are still two or more // fingers down. This may indicate that one finger was used to press the button @@ -2661,12 +2739,12 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi ALOGD("Gestures: QUIET for next %0.3fms", (mPointerGesture.quietTime + mConfig.pointerGestureQuietInterval - when) * 0.000001f); #endif - if (mPointerGesture.lastGestureMode != PointerGesture::QUIET) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::QUIET) { *outFinishPreviousGesture = true; } mPointerGesture.activeGestureId = -1; - mPointerGesture.currentGestureMode = PointerGesture::QUIET; + mPointerGesture.currentGestureMode = PointerGesture::Mode::QUIET; mPointerGesture.currentGestureIdBits.clear(); mPointerVelocityControl.reset(); @@ -2690,7 +2768,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi activeTouchId, currentFingerCount); #endif // Reset state when just starting. - if (mPointerGesture.lastGestureMode != PointerGesture::BUTTON_CLICK_OR_DRAG) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::BUTTON_CLICK_OR_DRAG) { *outFinishPreviousGesture = true; mPointerGesture.activeGestureId = 0; } @@ -2736,15 +2814,14 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi // Move the pointer using a relative motion. // When using spots, the click will occur at the position of the anchor // spot and all other spots will move there. - mPointerController->move(deltaX, deltaY); + moveMouseCursor(deltaX, deltaY); } else { mPointerVelocityControl.reset(); } - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); - mPointerGesture.currentGestureMode = PointerGesture::BUTTON_CLICK_OR_DRAG; + mPointerGesture.currentGestureMode = PointerGesture::Mode::BUTTON_CLICK_OR_DRAG; mPointerGesture.currentGestureIdBits.clear(); mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0; @@ -2757,19 +2834,18 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f); } else if (currentFingerCount == 0) { // Case 3. No fingers down and button is not pressed. (NEUTRAL) - if (mPointerGesture.lastGestureMode != PointerGesture::NEUTRAL) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::NEUTRAL) { *outFinishPreviousGesture = true; } // Watch for taps coming out of HOVER or TAP_DRAG mode. // Checking for taps after TAP_DRAG allows us to detect double-taps. bool tapped = false; - if ((mPointerGesture.lastGestureMode == PointerGesture::HOVER || - mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG) && + if ((mPointerGesture.lastGestureMode == PointerGesture::Mode::HOVER || + mPointerGesture.lastGestureMode == PointerGesture::Mode::TAP_DRAG) && lastFingerCount == 1) { if (when <= mPointerGesture.tapDownTime + mConfig.pointerGestureTapInterval) { - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop && fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) { #if DEBUG_GESTURES @@ -2781,7 +2857,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mConfig.pointerGestureTapDragInterval); mPointerGesture.activeGestureId = 0; - mPointerGesture.currentGestureMode = PointerGesture::TAP; + mPointerGesture.currentGestureMode = PointerGesture::Mode::TAP; mPointerGesture.currentGestureIdBits.clear(); mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0; @@ -2824,7 +2900,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi ALOGD("Gestures: NEUTRAL"); #endif mPointerGesture.activeGestureId = -1; - mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL; + mPointerGesture.currentGestureMode = PointerGesture::Mode::NEUTRAL; mPointerGesture.currentGestureIdBits.clear(); } } else if (currentFingerCount == 1) { @@ -2834,14 +2910,13 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi // When in TAP_DRAG, emit MOVE events at the pointer location. ALOG_ASSERT(activeTouchId >= 0); - mPointerGesture.currentGestureMode = PointerGesture::HOVER; - if (mPointerGesture.lastGestureMode == PointerGesture::TAP) { + mPointerGesture.currentGestureMode = PointerGesture::Mode::HOVER; + if (mPointerGesture.lastGestureMode == PointerGesture::Mode::TAP) { if (when <= mPointerGesture.tapUpTime + mConfig.pointerGestureTapDragInterval) { - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); if (fabs(x - mPointerGesture.tapX) <= mConfig.pointerGestureTapSlop && fabs(y - mPointerGesture.tapY) <= mConfig.pointerGestureTapSlop) { - mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG; + mPointerGesture.currentGestureMode = PointerGesture::Mode::TAP_DRAG; } else { #if DEBUG_GESTURES ALOGD("Gestures: Not a TAP_DRAG, deltaX=%f, deltaY=%f", @@ -2854,8 +2929,8 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi (when - mPointerGesture.tapUpTime) * 0.000001f); #endif } - } else if (mPointerGesture.lastGestureMode == PointerGesture::TAP_DRAG) { - mPointerGesture.currentGestureMode = PointerGesture::TAP_DRAG; + } else if (mPointerGesture.lastGestureMode == PointerGesture::Mode::TAP_DRAG) { + mPointerGesture.currentGestureMode = PointerGesture::Mode::TAP_DRAG; } float deltaX = 0, deltaY = 0; @@ -2872,13 +2947,13 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi // Move the pointer using a relative motion. // When using spots, the hover or drag will occur at the position of the anchor spot. - mPointerController->move(deltaX, deltaY); + moveMouseCursor(deltaX, deltaY); } else { mPointerVelocityControl.reset(); } bool down; - if (mPointerGesture.currentGestureMode == PointerGesture::TAP_DRAG) { + if (mPointerGesture.currentGestureMode == PointerGesture::Mode::TAP_DRAG) { #if DEBUG_GESTURES ALOGD("Gestures: TAP_DRAG"); #endif @@ -2887,15 +2962,14 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi #if DEBUG_GESTURES ALOGD("Gestures: HOVER"); #endif - if (mPointerGesture.lastGestureMode != PointerGesture::HOVER) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::HOVER) { *outFinishPreviousGesture = true; } mPointerGesture.activeGestureId = 0; down = false; } - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); mPointerGesture.currentGestureIdBits.clear(); mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId); @@ -2933,9 +3007,9 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi bool settled = when >= mPointerGesture.firstTouchTime + mConfig.pointerGestureMultitouchSettleInterval; - if (mPointerGesture.lastGestureMode != PointerGesture::PRESS && - mPointerGesture.lastGestureMode != PointerGesture::SWIPE && - mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::PRESS && + mPointerGesture.lastGestureMode != PointerGesture::Mode::SWIPE && + mPointerGesture.lastGestureMode != PointerGesture::Mode::FREEFORM) { *outFinishPreviousGesture = true; } else if (!settled && currentFingerCount > lastFingerCount) { // Additional pointers have gone down but not yet settled. @@ -2953,7 +3027,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi } if (*outFinishPreviousGesture || *outCancelPreviousGesture) { - mPointerGesture.currentGestureMode = PointerGesture::PRESS; + mPointerGesture.currentGestureMode = PointerGesture::Mode::PRESS; mPointerGesture.activeGestureId = 0; mPointerGesture.referenceIdBits.clear(); mPointerVelocityControl.reset(); @@ -2968,8 +3042,9 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mCurrentRawState.rawPointerData .getCentroidOfTouchingPointers(&mPointerGesture.referenceTouchX, &mPointerGesture.referenceTouchY); - mPointerController->getPosition(&mPointerGesture.referenceGestureX, - &mPointerGesture.referenceGestureY); + auto [x, y] = getMouseCursorPosition(); + mPointerGesture.referenceGestureX = x; + mPointerGesture.referenceGestureY = y; } // Clear the reference deltas for fingers not yet included in the reference calculation. @@ -3005,7 +3080,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi } // Consider transitions from PRESS to SWIPE or MULTITOUCH. - if (mPointerGesture.currentGestureMode == PointerGesture::PRESS) { + if (mPointerGesture.currentGestureMode == PointerGesture::Mode::PRESS) { float dist[MAX_POINTER_ID + 1]; int32_t distOverThreshold = 0; for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty();) { @@ -3027,7 +3102,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi currentFingerCount); #endif *outCancelPreviousGesture = true; - mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; + mPointerGesture.currentGestureMode = PointerGesture::Mode::FREEFORM; } else { // There are exactly two pointers. BitSet32 idBits(mCurrentCookedState.fingerIdBits); @@ -3046,7 +3121,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mutualDistance, mPointerGestureMaxSwipeWidth); #endif *outCancelPreviousGesture = true; - mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; + mPointerGesture.currentGestureMode = PointerGesture::Mode::FREEFORM; } else { // There are two pointers. Wait for both pointers to start moving // before deciding whether this is a SWIPE or FREEFORM gesture. @@ -3077,7 +3152,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mConfig.pointerGestureMultitouchMinDistance, cosine, mConfig.pointerGestureSwipeTransitionAngleCosine); #endif - mPointerGesture.currentGestureMode = PointerGesture::SWIPE; + mPointerGesture.currentGestureMode = PointerGesture::Mode::SWIPE; } else { // Pointers are moving in different directions. Switch to FREEFORM. #if DEBUG_GESTURES @@ -3089,13 +3164,13 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mConfig.pointerGestureSwipeTransitionAngleCosine); #endif *outCancelPreviousGesture = true; - mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; + mPointerGesture.currentGestureMode = PointerGesture::Mode::FREEFORM; } } } } } - } else if (mPointerGesture.currentGestureMode == PointerGesture::SWIPE) { + } else if (mPointerGesture.currentGestureMode == PointerGesture::Mode::SWIPE) { // Switch from SWIPE to FREEFORM if additional pointers go down. // Cancel previous gesture. if (currentFingerCount > 2) { @@ -3104,13 +3179,13 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi currentFingerCount); #endif *outCancelPreviousGesture = true; - mPointerGesture.currentGestureMode = PointerGesture::FREEFORM; + mPointerGesture.currentGestureMode = PointerGesture::Mode::FREEFORM; } } // Move the reference points based on the overall group motion of the fingers // except in PRESS mode while waiting for a transition to occur. - if (mPointerGesture.currentGestureMode != PointerGesture::PRESS && + if (mPointerGesture.currentGestureMode != PointerGesture::Mode::PRESS && (commonDeltaX || commonDeltaY)) { for (BitSet32 idBits(mPointerGesture.referenceIdBits); !idBits.isEmpty();) { uint32_t id = idBits.clearFirstMarkedBit(); @@ -3133,8 +3208,8 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi } // Report gestures. - if (mPointerGesture.currentGestureMode == PointerGesture::PRESS || - mPointerGesture.currentGestureMode == PointerGesture::SWIPE) { + if (mPointerGesture.currentGestureMode == PointerGesture::Mode::PRESS || + mPointerGesture.currentGestureMode == PointerGesture::Mode::SWIPE) { // PRESS or SWIPE mode. #if DEBUG_GESTURES ALOGD("Gestures: PRESS or SWIPE activeTouchId=%d," @@ -3155,7 +3230,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, mPointerGesture.referenceGestureY); mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f); - } else if (mPointerGesture.currentGestureMode == PointerGesture::FREEFORM) { + } else if (mPointerGesture.currentGestureMode == PointerGesture::Mode::FREEFORM) { // FREEFORM mode. #if DEBUG_GESTURES ALOGD("Gestures: FREEFORM activeTouchId=%d," @@ -3168,7 +3243,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi BitSet32 mappedTouchIdBits; BitSet32 usedGestureIdBits; - if (mPointerGesture.lastGestureMode != PointerGesture::FREEFORM) { + if (mPointerGesture.lastGestureMode != PointerGesture::Mode::FREEFORM) { // Initially, assign the active gesture id to the active touch point // if there is one. No other touch id bits are mapped yet. if (!*outCancelPreviousGesture) { @@ -3299,7 +3374,7 @@ bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPrevi return true; } -void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); @@ -3307,14 +3382,13 @@ void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) if (!mCurrentCookedState.stylusIdBits.isEmpty()) { uint32_t id = mCurrentCookedState.stylusIdBits.firstMarkedBit(); uint32_t index = mCurrentCookedState.cookedPointerData.idToIndex[id]; - float x = mCurrentCookedState.cookedPointerData.pointerCoords[index].getX(); - float y = mCurrentCookedState.cookedPointerData.pointerCoords[index].getY(); - mPointerController->setPosition(x, y); + setMouseCursorPosition(mCurrentCookedState.cookedPointerData.pointerCoords[index].getX(), + mCurrentCookedState.cookedPointerData.pointerCoords[index].getY()); hovering = mCurrentCookedState.cookedPointerData.hoveringIdBits.hasBit(id); down = !hovering; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); mPointerSimple.currentCoords.copyFrom( mCurrentCookedState.cookedPointerData.pointerCoords[index]); mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); @@ -3327,14 +3401,14 @@ void TouchInputMapper::dispatchPointerStylus(nsecs_t when, uint32_t policyFlags) hovering = false; } - dispatchPointerSimple(when, policyFlags, down, hovering); + dispatchPointerSimple(when, readTime, policyFlags, down, hovering); } -void TouchInputMapper::abortPointerStylus(nsecs_t when, uint32_t policyFlags) { - abortPointerSimple(when, policyFlags); +void TouchInputMapper::abortPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { + abortPointerSimple(when, readTime, policyFlags); } -void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::dispatchPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); @@ -3355,7 +3429,7 @@ void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) rotateDelta(mSurfaceOrientation, &deltaX, &deltaY); mPointerVelocityControl.move(when, &deltaX, &deltaY); - mPointerController->move(deltaX, deltaY); + moveMouseCursor(deltaX, deltaY); } else { mPointerVelocityControl.reset(); } @@ -3363,8 +3437,7 @@ void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) down = isPointerDown(mCurrentRawState.buttonState); hovering = !down; - float x, y; - mPointerController->getPosition(&x, &y); + auto [x, y] = getMouseCursorPosition(); mPointerSimple.currentCoords.copyFrom( mCurrentCookedState.cookedPointerData.pointerCoords[currentIndex]); mPointerSimple.currentCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x); @@ -3381,40 +3454,37 @@ void TouchInputMapper::dispatchPointerMouse(nsecs_t when, uint32_t policyFlags) hovering = false; } - dispatchPointerSimple(when, policyFlags, down, hovering); + dispatchPointerSimple(when, readTime, policyFlags, down, hovering); } -void TouchInputMapper::abortPointerMouse(nsecs_t when, uint32_t policyFlags) { - abortPointerSimple(when, policyFlags); +void TouchInputMapper::abortPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { + abortPointerSimple(when, readTime, policyFlags); mPointerVelocityControl.reset(); } -void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, bool down, - bool hovering) { +void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, + bool down, bool hovering) { int32_t metaState = getContext()->getGlobalMetaState(); - int32_t displayId = mViewport.displayId; if (down || hovering) { - mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); + mPointerController->setPresentation(PointerControllerInterface::Presentation::POINTER); mPointerController->clearSpots(); mPointerController->setButtonState(mCurrentRawState.buttonState); - mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); + mPointerController->unfade(PointerControllerInterface::Transition::IMMEDIATE); } else if (!down && !hovering && (mPointerSimple.down || mPointerSimple.hovering)) { - mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL); + mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); } - displayId = mPointerController->getDisplayId(); + int32_t displayId = mPointerController->getDisplayId(); - float xCursorPosition; - float yCursorPosition; - mPointerController->getPosition(&xCursorPosition, &yCursorPosition); + auto [xCursorPosition, yCursorPosition] = getMouseCursorPosition(); if (mPointerSimple.down && !down) { mPointerSimple.down = false; // Send up. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_UP, 0, 0, metaState, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_UP, 0, 0, metaState, mLastRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, @@ -3427,9 +3497,9 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, mPointerSimple.hovering = false; // Send hover exit. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, - mLastRawState.buttonState, MotionClassification::NONE, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, + metaState, mLastRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, yCursorPosition, mPointerSimple.downTime, @@ -3443,7 +3513,7 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, mPointerSimple.downTime = when; // Send down. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_DOWN, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, @@ -3454,8 +3524,8 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, } // Send move. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, mOrientedXPrecision, @@ -3469,7 +3539,7 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, mPointerSimple.hovering = true; // Send hover enter. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, @@ -3480,9 +3550,9 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, } // Send hover move. - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, - mCurrentRawState.buttonState, MotionClassification::NONE, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, + metaState, mCurrentRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, yCursorPosition, @@ -3502,8 +3572,8 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); - NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, - policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, mCurrentRawState.buttonState, MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, &pointerCoords, mOrientedXPrecision, mOrientedYPrecision, @@ -3521,17 +3591,17 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, uint32_t policyFlags, } } -void TouchInputMapper::abortPointerSimple(nsecs_t when, uint32_t policyFlags) { +void TouchInputMapper::abortPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); - dispatchPointerSimple(when, policyFlags, false, false); + dispatchPointerSimple(when, readTime, policyFlags, false, false); } -void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source, - int32_t action, int32_t actionButton, int32_t flags, - int32_t metaState, int32_t buttonState, int32_t edgeFlags, - const PointerProperties* properties, +void TouchInputMapper::dispatchMotion(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, + uint32_t source, int32_t action, int32_t actionButton, + int32_t flags, int32_t metaState, int32_t buttonState, + int32_t edgeFlags, const PointerProperties* properties, const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) { @@ -3560,7 +3630,11 @@ void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32 if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) { action = AMOTION_EVENT_ACTION_DOWN; } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) { - action = AMOTION_EVENT_ACTION_UP; + if ((flags & AMOTION_EVENT_FLAG_CANCELED) != 0) { + action = AMOTION_EVENT_ACTION_CANCEL; + } else { + action = AMOTION_EVENT_ACTION_UP; + } } else { // Can't happen. ALOG_ASSERT(false); @@ -3568,16 +3642,18 @@ void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32 } float xCursorPosition = AMOTION_EVENT_INVALID_CURSOR_POSITION; float yCursorPosition = AMOTION_EVENT_INVALID_CURSOR_POSITION; - if (mDeviceMode == DEVICE_MODE_POINTER) { - mPointerController->getPosition(&xCursorPosition, &yCursorPosition); + if (mDeviceMode == DeviceMode::POINTER) { + auto [x, y] = getMouseCursorPosition(); + xCursorPosition = x; + yCursorPosition = y; } const int32_t displayId = getAssociatedDisplayId().value_or(ADISPLAY_ID_NONE); const int32_t deviceId = getDeviceId(); std::vector<TouchVideoFrame> frames = getDeviceContext().getVideoFrames(); std::for_each(frames.begin(), frames.end(), [this](TouchVideoFrame& frame) { frame.rotate(this->mSurfaceOrientation); }); - NotifyMotionArgs args(getContext()->getNextId(), when, deviceId, source, displayId, policyFlags, - action, actionButton, flags, metaState, buttonState, + NotifyMotionArgs args(getContext()->getNextId(), when, readTime, deviceId, source, displayId, + policyFlags, action, actionButton, flags, metaState, buttonState, MotionClassification::NONE, edgeFlags, pointerCount, pointerProperties, pointerCoords, xPrecision, yPrecision, xCursorPosition, yCursorPosition, downTime, std::move(frames)); @@ -3614,9 +3690,9 @@ bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties return changed; } -void TouchInputMapper::cancelTouch(nsecs_t when) { - abortPointerUsage(when, 0 /*policyFlags*/); - abortTouches(when, 0 /* policyFlags*/); +void TouchInputMapper::cancelTouch(nsecs_t when, nsecs_t readTime) { + abortPointerUsage(when, readTime, 0 /*policyFlags*/); + abortTouches(when, readTime, 0 /* policyFlags*/); } // Transform raw coordinate to surface coordinate @@ -3625,6 +3701,9 @@ void TouchInputMapper::rotateAndScale(float& x, float& y) { const float xScaled = float(x - mRawPointerAxes.x.minValue) * mXScale; const float yScaled = float(y - mRawPointerAxes.y.minValue) * mYScale; + const float xScaledMax = float(mRawPointerAxes.x.maxValue - x) * mXScale; + const float yScaledMax = float(mRawPointerAxes.y.maxValue - y) * mYScale; + // Rotate to surface coordinate. // 0 - no swap and reverse. // 90 - swap x/y and reverse y. @@ -3636,16 +3715,16 @@ void TouchInputMapper::rotateAndScale(float& x, float& y) { y = yScaled + mYTranslate; break; case DISPLAY_ORIENTATION_90: - y = mSurfaceRight - xScaled; + y = xScaledMax - (mRawSurfaceWidth - mSurfaceRight); x = yScaled + mYTranslate; break; case DISPLAY_ORIENTATION_180: - x = mSurfaceRight - xScaled; - y = mSurfaceBottom - yScaled; + x = xScaledMax - (mRawSurfaceWidth - mSurfaceRight); + y = yScaledMax - (mRawSurfaceHeight - mSurfaceBottom); break; case DISPLAY_ORIENTATION_270: y = xScaled + mXTranslate; - x = mSurfaceBottom - yScaled; + x = yScaledMax - (mRawSurfaceHeight - mSurfaceBottom); break; default: assert(false); @@ -3679,11 +3758,11 @@ const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHit(int32_t return nullptr; } -void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) { - uint32_t currentPointerCount = current->rawPointerData.pointerCount; - uint32_t lastPointerCount = last->rawPointerData.pointerCount; +void TouchInputMapper::assignPointerIds(const RawState& last, RawState& current) { + uint32_t currentPointerCount = current.rawPointerData.pointerCount; + uint32_t lastPointerCount = last.rawPointerData.pointerCount; - current->rawPointerData.clearIdBits(); + current.rawPointerData.clearIdBits(); if (currentPointerCount == 0) { // No pointers to assign. @@ -3694,20 +3773,20 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) // All pointers are new. for (uint32_t i = 0; i < currentPointerCount; i++) { uint32_t id = i; - current->rawPointerData.pointers[i].id = id; - current->rawPointerData.idToIndex[id] = i; - current->rawPointerData.markIdBit(id, current->rawPointerData.isHovering(i)); + current.rawPointerData.pointers[i].id = id; + current.rawPointerData.idToIndex[id] = i; + current.rawPointerData.markIdBit(id, current.rawPointerData.isHovering(i)); } return; } if (currentPointerCount == 1 && lastPointerCount == 1 && - current->rawPointerData.pointers[0].toolType == last->rawPointerData.pointers[0].toolType) { + current.rawPointerData.pointers[0].toolType == last.rawPointerData.pointers[0].toolType) { // Only one pointer and no change in count so it must have the same id as before. - uint32_t id = last->rawPointerData.pointers[0].id; - current->rawPointerData.pointers[0].id = id; - current->rawPointerData.idToIndex[id] = 0; - current->rawPointerData.markIdBit(id, current->rawPointerData.isHovering(0)); + uint32_t id = last.rawPointerData.pointers[0].id; + current.rawPointerData.pointers[0].id = id; + current.rawPointerData.idToIndex[id] = 0; + current.rawPointerData.markIdBit(id, current.rawPointerData.isHovering(0)); return; } @@ -3725,9 +3804,9 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount; lastPointerIndex++) { const RawPointerData::Pointer& currentPointer = - current->rawPointerData.pointers[currentPointerIndex]; + current.rawPointerData.pointers[currentPointerIndex]; const RawPointerData::Pointer& lastPointer = - last->rawPointerData.pointers[lastPointerIndex]; + last.rawPointerData.pointers[lastPointerIndex]; if (currentPointer.toolType == lastPointer.toolType) { int64_t deltaX = currentPointer.x - lastPointer.x; int64_t deltaY = currentPointer.y - lastPointer.y; @@ -3813,9 +3892,9 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) #if DEBUG_POINTER_ASSIGNMENT ALOGD("assignPointerIds - reduced distance min-heap: size=%d", heapSize); - for (size_t i = 0; i < heapSize; i++) { - ALOGD(" heap[%zu]: cur=%" PRIu32 ", last=%" PRIu32 ", distance=%" PRIu64, i, - heap[i].currentPointerIndex, heap[i].lastPointerIndex, heap[i].distance); + for (size_t j = 0; j < heapSize; j++) { + ALOGD(" heap[%zu]: cur=%" PRIu32 ", last=%" PRIu32 ", distance=%" PRIu64, j, + heap[j].currentPointerIndex, heap[j].lastPointerIndex, heap[j].distance); } #endif } @@ -3831,12 +3910,12 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) matchedCurrentBits.markBit(currentPointerIndex); matchedLastBits.markBit(lastPointerIndex); - uint32_t id = last->rawPointerData.pointers[lastPointerIndex].id; - current->rawPointerData.pointers[currentPointerIndex].id = id; - current->rawPointerData.idToIndex[id] = currentPointerIndex; - current->rawPointerData.markIdBit(id, - current->rawPointerData.isHovering( - currentPointerIndex)); + uint32_t id = last.rawPointerData.pointers[lastPointerIndex].id; + current.rawPointerData.pointers[currentPointerIndex].id = id; + current.rawPointerData.idToIndex[id] = currentPointerIndex; + current.rawPointerData.markIdBit(id, + current.rawPointerData.isHovering( + currentPointerIndex)); usedIdBits.markBit(id); #if DEBUG_POINTER_ASSIGNMENT @@ -3853,10 +3932,10 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit(); uint32_t id = usedIdBits.markFirstUnmarkedBit(); - current->rawPointerData.pointers[currentPointerIndex].id = id; - current->rawPointerData.idToIndex[id] = currentPointerIndex; - current->rawPointerData.markIdBit(id, - current->rawPointerData.isHovering(currentPointerIndex)); + current.rawPointerData.pointers[currentPointerIndex].id = id; + current.rawPointerData.idToIndex[id] = currentPointerIndex; + current.rawPointerData.markIdBit(id, + current.rawPointerData.isHovering(currentPointerIndex)); #if DEBUG_POINTER_ASSIGNMENT ALOGD("assignPointerIds - assigned: cur=%" PRIu32 ", id=%" PRIu32, currentPointerIndex, id); @@ -3907,7 +3986,7 @@ bool TouchInputMapper::markSupportedKeyCodes(uint32_t sourceMask, size_t numCode std::optional<int32_t> TouchInputMapper::getAssociatedDisplayId() { if (mParameters.hasAssociatedDisplay) { - if (mDeviceMode == DEVICE_MODE_POINTER) { + if (mDeviceMode == DeviceMode::POINTER) { return std::make_optional(mPointerController->getDisplayId()); } else { return std::make_optional(mViewport.displayId); @@ -3916,4 +3995,63 @@ std::optional<int32_t> TouchInputMapper::getAssociatedDisplayId() { return std::nullopt; } +void TouchInputMapper::moveMouseCursor(float dx, float dy) const { + if (isPerWindowInputRotationEnabled()) { + // Convert from InputReader's un-rotated coordinate space to PointerController's coordinate + // space that is oriented with the viewport. + rotateDelta(mViewport.orientation, &dx, &dy); + } + + mPointerController->move(dx, dy); +} + +std::pair<float, float> TouchInputMapper::getMouseCursorPosition() const { + float x = 0; + float y = 0; + mPointerController->getPosition(&x, &y); + + if (!isPerWindowInputRotationEnabled()) return {x, y}; + if (!mViewport.isValid()) return {x, y}; + + // Convert from PointerController's rotated coordinate space that is oriented with the viewport + // to InputReader's un-rotated coordinate space. + const int32_t orientation = getInverseRotation(mViewport.orientation); + rotatePoint(orientation, x, y, mViewport.deviceWidth, mViewport.deviceHeight); + return {x, y}; +} + +void TouchInputMapper::setMouseCursorPosition(float x, float y) const { + if (isPerWindowInputRotationEnabled() && mViewport.isValid()) { + // Convert from InputReader's un-rotated coordinate space to PointerController's rotated + // coordinate space that is oriented with the viewport. + rotatePoint(mViewport.orientation, x, y, mRawSurfaceWidth, mRawSurfaceHeight); + } + + mPointerController->setPosition(x, y); +} + +void TouchInputMapper::setTouchSpots(const PointerCoords* spotCoords, const uint32_t* spotIdToIndex, + BitSet32 spotIdBits, int32_t displayId) { + std::array<PointerCoords, MAX_POINTERS> outSpotCoords{}; + + for (BitSet32 idBits(spotIdBits); !idBits.isEmpty();) { + const uint32_t index = spotIdToIndex[idBits.clearFirstMarkedBit()]; + float x = spotCoords[index].getX(); + float y = spotCoords[index].getY(); + float pressure = spotCoords[index].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE); + + if (isPerWindowInputRotationEnabled()) { + // Convert from InputReader's un-rotated coordinate space to PointerController's rotated + // coordinate space. + rotatePoint(mViewport.orientation, x, y, mRawSurfaceWidth, mRawSurfaceHeight); + } + + outSpotCoords[index].setAxisValue(AMOTION_EVENT_AXIS_X, x); + outSpotCoords[index].setAxisValue(AMOTION_EVENT_AXIS_Y, y); + outSpotCoords[index].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pressure); + } + + mPointerController->setSpots(outSpotCoords.data(), spotIdToIndex, spotIdBits, displayId); +} + } // namespace android |