Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Prabir Pradhan | 9244aea | 2020-02-05 20:31:40 -0800 | [diff] [blame] | 17 | #include "../Macros.h" |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 18 | |
| 19 | #include "CursorInputMapper.h" |
| 20 | |
| 21 | #include "CursorButtonAccumulator.h" |
| 22 | #include "CursorScrollAccumulator.h" |
| 23 | #include "TouchCursorInputMapperCommon.h" |
| 24 | |
| 25 | namespace android { |
| 26 | |
| 27 | // --- CursorMotionAccumulator --- |
| 28 | |
| 29 | CursorMotionAccumulator::CursorMotionAccumulator() { |
| 30 | clearRelativeAxes(); |
| 31 | } |
| 32 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 33 | void CursorMotionAccumulator::reset(InputDeviceContext& deviceContext) { |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 34 | clearRelativeAxes(); |
| 35 | } |
| 36 | |
| 37 | void CursorMotionAccumulator::clearRelativeAxes() { |
| 38 | mRelX = 0; |
| 39 | mRelY = 0; |
| 40 | } |
| 41 | |
| 42 | void CursorMotionAccumulator::process(const RawEvent* rawEvent) { |
| 43 | if (rawEvent->type == EV_REL) { |
| 44 | switch (rawEvent->code) { |
| 45 | case REL_X: |
| 46 | mRelX = rawEvent->value; |
| 47 | break; |
| 48 | case REL_Y: |
| 49 | mRelY = rawEvent->value; |
| 50 | break; |
| 51 | } |
| 52 | } |
| 53 | } |
| 54 | |
| 55 | void CursorMotionAccumulator::finishSync() { |
| 56 | clearRelativeAxes(); |
| 57 | } |
| 58 | |
| 59 | // --- CursorInputMapper --- |
| 60 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 61 | CursorInputMapper::CursorInputMapper(InputDeviceContext& deviceContext) |
| 62 | : InputMapper(deviceContext) {} |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 63 | |
| 64 | CursorInputMapper::~CursorInputMapper() {} |
| 65 | |
| 66 | uint32_t CursorInputMapper::getSources() { |
| 67 | return mSource; |
| 68 | } |
| 69 | |
| 70 | void CursorInputMapper::populateDeviceInfo(InputDeviceInfo* info) { |
| 71 | InputMapper::populateDeviceInfo(info); |
| 72 | |
| 73 | if (mParameters.mode == Parameters::MODE_POINTER) { |
| 74 | float minX, minY, maxX, maxY; |
| 75 | if (mPointerController->getBounds(&minX, &minY, &maxX, &maxY)) { |
| 76 | info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, minX, maxX, 0.0f, 0.0f, 0.0f); |
| 77 | info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, minY, maxY, 0.0f, 0.0f, 0.0f); |
| 78 | } |
| 79 | } else { |
| 80 | info->addMotionRange(AMOTION_EVENT_AXIS_X, mSource, -1.0f, 1.0f, 0.0f, mXScale, 0.0f); |
| 81 | info->addMotionRange(AMOTION_EVENT_AXIS_Y, mSource, -1.0f, 1.0f, 0.0f, mYScale, 0.0f); |
| 82 | } |
| 83 | info->addMotionRange(AMOTION_EVENT_AXIS_PRESSURE, mSource, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f); |
| 84 | |
| 85 | if (mCursorScrollAccumulator.haveRelativeVWheel()) { |
| 86 | info->addMotionRange(AMOTION_EVENT_AXIS_VSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f); |
| 87 | } |
| 88 | if (mCursorScrollAccumulator.haveRelativeHWheel()) { |
| 89 | info->addMotionRange(AMOTION_EVENT_AXIS_HSCROLL, mSource, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f); |
| 90 | } |
| 91 | } |
| 92 | |
| 93 | void CursorInputMapper::dump(std::string& dump) { |
| 94 | dump += INDENT2 "Cursor Input Mapper:\n"; |
| 95 | dumpParameters(dump); |
| 96 | dump += StringPrintf(INDENT3 "XScale: %0.3f\n", mXScale); |
| 97 | dump += StringPrintf(INDENT3 "YScale: %0.3f\n", mYScale); |
| 98 | dump += StringPrintf(INDENT3 "XPrecision: %0.3f\n", mXPrecision); |
| 99 | dump += StringPrintf(INDENT3 "YPrecision: %0.3f\n", mYPrecision); |
| 100 | dump += StringPrintf(INDENT3 "HaveVWheel: %s\n", |
| 101 | toString(mCursorScrollAccumulator.haveRelativeVWheel())); |
| 102 | dump += StringPrintf(INDENT3 "HaveHWheel: %s\n", |
| 103 | toString(mCursorScrollAccumulator.haveRelativeHWheel())); |
| 104 | dump += StringPrintf(INDENT3 "VWheelScale: %0.3f\n", mVWheelScale); |
| 105 | dump += StringPrintf(INDENT3 "HWheelScale: %0.3f\n", mHWheelScale); |
| 106 | dump += StringPrintf(INDENT3 "Orientation: %d\n", mOrientation); |
| 107 | dump += StringPrintf(INDENT3 "ButtonState: 0x%08x\n", mButtonState); |
| 108 | dump += StringPrintf(INDENT3 "Down: %s\n", toString(isPointerDown(mButtonState))); |
| 109 | dump += StringPrintf(INDENT3 "DownTime: %" PRId64 "\n", mDownTime); |
| 110 | } |
| 111 | |
| 112 | void CursorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, |
| 113 | uint32_t changes) { |
| 114 | InputMapper::configure(when, config, changes); |
| 115 | |
| 116 | if (!changes) { // first time only |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 117 | mCursorScrollAccumulator.configure(getDeviceContext()); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 118 | |
| 119 | // Configure basic parameters. |
| 120 | configureParameters(); |
| 121 | |
| 122 | // Configure device mode. |
| 123 | switch (mParameters.mode) { |
| 124 | case Parameters::MODE_POINTER_RELATIVE: |
| 125 | // Should not happen during first time configuration. |
| 126 | ALOGE("Cannot start a device in MODE_POINTER_RELATIVE, starting in MODE_POINTER"); |
| 127 | mParameters.mode = Parameters::MODE_POINTER; |
| 128 | [[fallthrough]]; |
| 129 | case Parameters::MODE_POINTER: |
| 130 | mSource = AINPUT_SOURCE_MOUSE; |
| 131 | mXPrecision = 1.0f; |
| 132 | mYPrecision = 1.0f; |
| 133 | mXScale = 1.0f; |
| 134 | mYScale = 1.0f; |
Prabir Pradhan | c7ef27e | 2020-02-03 19:19:15 -0800 | [diff] [blame] | 135 | mPointerController = getContext()->getPointerController(getDeviceId()); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 136 | break; |
| 137 | case Parameters::MODE_NAVIGATION: |
| 138 | mSource = AINPUT_SOURCE_TRACKBALL; |
| 139 | mXPrecision = TRACKBALL_MOVEMENT_THRESHOLD; |
| 140 | mYPrecision = TRACKBALL_MOVEMENT_THRESHOLD; |
| 141 | mXScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; |
| 142 | mYScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; |
| 143 | break; |
| 144 | } |
| 145 | |
| 146 | mVWheelScale = 1.0f; |
| 147 | mHWheelScale = 1.0f; |
| 148 | } |
| 149 | |
| 150 | if ((!changes && config->pointerCapture) || |
| 151 | (changes & InputReaderConfiguration::CHANGE_POINTER_CAPTURE)) { |
| 152 | if (config->pointerCapture) { |
| 153 | if (mParameters.mode == Parameters::MODE_POINTER) { |
| 154 | mParameters.mode = Parameters::MODE_POINTER_RELATIVE; |
| 155 | mSource = AINPUT_SOURCE_MOUSE_RELATIVE; |
| 156 | // Keep PointerController around in order to preserve the pointer position. |
| 157 | mPointerController->fade(PointerControllerInterface::TRANSITION_IMMEDIATE); |
| 158 | } else { |
| 159 | ALOGE("Cannot request pointer capture, device is not in MODE_POINTER"); |
| 160 | } |
| 161 | } else { |
| 162 | if (mParameters.mode == Parameters::MODE_POINTER_RELATIVE) { |
| 163 | mParameters.mode = Parameters::MODE_POINTER; |
| 164 | mSource = AINPUT_SOURCE_MOUSE; |
| 165 | } else { |
| 166 | ALOGE("Cannot release pointer capture, device is not in MODE_POINTER_RELATIVE"); |
| 167 | } |
| 168 | } |
| 169 | bumpGeneration(); |
| 170 | if (changes) { |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 171 | NotifyDeviceResetArgs args(getContext()->getNextId(), when, getDeviceId()); |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 172 | getListener()->notifyDeviceReset(&args); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 173 | } |
| 174 | } |
| 175 | |
| 176 | if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED)) { |
| 177 | mPointerVelocityControl.setParameters(config->pointerVelocityControlParameters); |
| 178 | mWheelXVelocityControl.setParameters(config->wheelVelocityControlParameters); |
| 179 | mWheelYVelocityControl.setParameters(config->wheelVelocityControlParameters); |
| 180 | } |
| 181 | |
| 182 | if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { |
| 183 | mOrientation = DISPLAY_ORIENTATION_0; |
| 184 | if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) { |
| 185 | std::optional<DisplayViewport> internalViewport = |
| 186 | config->getDisplayViewportByType(ViewportType::VIEWPORT_INTERNAL); |
| 187 | if (internalViewport) { |
| 188 | mOrientation = internalViewport->orientation; |
| 189 | } |
| 190 | } |
| 191 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 192 | bumpGeneration(); |
| 193 | } |
| 194 | } |
| 195 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 196 | void CursorInputMapper::configureParameters() { |
| 197 | mParameters.mode = Parameters::MODE_POINTER; |
| 198 | String8 cursorModeString; |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 199 | if (getDeviceContext().getConfiguration().tryGetProperty(String8("cursor.mode"), |
| 200 | cursorModeString)) { |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 201 | if (cursorModeString == "navigation") { |
| 202 | mParameters.mode = Parameters::MODE_NAVIGATION; |
| 203 | } else if (cursorModeString != "pointer" && cursorModeString != "default") { |
| 204 | ALOGW("Invalid value for cursor.mode: '%s'", cursorModeString.string()); |
| 205 | } |
| 206 | } |
| 207 | |
| 208 | mParameters.orientationAware = false; |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 209 | getDeviceContext().getConfiguration().tryGetProperty(String8("cursor.orientationAware"), |
| 210 | mParameters.orientationAware); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 211 | |
| 212 | mParameters.hasAssociatedDisplay = false; |
| 213 | if (mParameters.mode == Parameters::MODE_POINTER || mParameters.orientationAware) { |
| 214 | mParameters.hasAssociatedDisplay = true; |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | void CursorInputMapper::dumpParameters(std::string& dump) { |
| 219 | dump += INDENT3 "Parameters:\n"; |
| 220 | dump += StringPrintf(INDENT4 "HasAssociatedDisplay: %s\n", |
| 221 | toString(mParameters.hasAssociatedDisplay)); |
| 222 | |
| 223 | switch (mParameters.mode) { |
| 224 | case Parameters::MODE_POINTER: |
| 225 | dump += INDENT4 "Mode: pointer\n"; |
| 226 | break; |
| 227 | case Parameters::MODE_POINTER_RELATIVE: |
| 228 | dump += INDENT4 "Mode: relative pointer\n"; |
| 229 | break; |
| 230 | case Parameters::MODE_NAVIGATION: |
| 231 | dump += INDENT4 "Mode: navigation\n"; |
| 232 | break; |
| 233 | default: |
| 234 | ALOG_ASSERT(false); |
| 235 | } |
| 236 | |
| 237 | dump += StringPrintf(INDENT4 "OrientationAware: %s\n", toString(mParameters.orientationAware)); |
| 238 | } |
| 239 | |
| 240 | void CursorInputMapper::reset(nsecs_t when) { |
| 241 | mButtonState = 0; |
| 242 | mDownTime = 0; |
| 243 | |
| 244 | mPointerVelocityControl.reset(); |
| 245 | mWheelXVelocityControl.reset(); |
| 246 | mWheelYVelocityControl.reset(); |
| 247 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 248 | mCursorButtonAccumulator.reset(getDeviceContext()); |
| 249 | mCursorMotionAccumulator.reset(getDeviceContext()); |
| 250 | mCursorScrollAccumulator.reset(getDeviceContext()); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 251 | |
| 252 | InputMapper::reset(when); |
| 253 | } |
| 254 | |
| 255 | void CursorInputMapper::process(const RawEvent* rawEvent) { |
| 256 | mCursorButtonAccumulator.process(rawEvent); |
| 257 | mCursorMotionAccumulator.process(rawEvent); |
| 258 | mCursorScrollAccumulator.process(rawEvent); |
| 259 | |
| 260 | if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { |
| 261 | sync(rawEvent->when); |
| 262 | } |
| 263 | } |
| 264 | |
| 265 | void CursorInputMapper::sync(nsecs_t when) { |
| 266 | int32_t lastButtonState = mButtonState; |
| 267 | int32_t currentButtonState = mCursorButtonAccumulator.getButtonState(); |
| 268 | mButtonState = currentButtonState; |
| 269 | |
| 270 | bool wasDown = isPointerDown(lastButtonState); |
| 271 | bool down = isPointerDown(currentButtonState); |
| 272 | bool downChanged; |
| 273 | if (!wasDown && down) { |
| 274 | mDownTime = when; |
| 275 | downChanged = true; |
| 276 | } else if (wasDown && !down) { |
| 277 | downChanged = true; |
| 278 | } else { |
| 279 | downChanged = false; |
| 280 | } |
| 281 | nsecs_t downTime = mDownTime; |
| 282 | bool buttonsChanged = currentButtonState != lastButtonState; |
| 283 | int32_t buttonsPressed = currentButtonState & ~lastButtonState; |
| 284 | int32_t buttonsReleased = lastButtonState & ~currentButtonState; |
| 285 | |
| 286 | float deltaX = mCursorMotionAccumulator.getRelativeX() * mXScale; |
| 287 | float deltaY = mCursorMotionAccumulator.getRelativeY() * mYScale; |
| 288 | bool moved = deltaX != 0 || deltaY != 0; |
| 289 | |
| 290 | // Rotate delta according to orientation if needed. |
| 291 | if (mParameters.orientationAware && mParameters.hasAssociatedDisplay && |
| 292 | (deltaX != 0.0f || deltaY != 0.0f)) { |
| 293 | rotateDelta(mOrientation, &deltaX, &deltaY); |
| 294 | } |
| 295 | |
| 296 | // Move the pointer. |
| 297 | PointerProperties pointerProperties; |
| 298 | pointerProperties.clear(); |
| 299 | pointerProperties.id = 0; |
| 300 | pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE; |
| 301 | |
| 302 | PointerCoords pointerCoords; |
| 303 | pointerCoords.clear(); |
| 304 | |
| 305 | float vscroll = mCursorScrollAccumulator.getRelativeVWheel(); |
| 306 | float hscroll = mCursorScrollAccumulator.getRelativeHWheel(); |
| 307 | bool scrolled = vscroll != 0 || hscroll != 0; |
| 308 | |
| 309 | mWheelYVelocityControl.move(when, nullptr, &vscroll); |
| 310 | mWheelXVelocityControl.move(when, &hscroll, nullptr); |
| 311 | |
| 312 | mPointerVelocityControl.move(when, &deltaX, &deltaY); |
| 313 | |
| 314 | int32_t displayId; |
| 315 | float xCursorPosition = AMOTION_EVENT_INVALID_CURSOR_POSITION; |
| 316 | float yCursorPosition = AMOTION_EVENT_INVALID_CURSOR_POSITION; |
| 317 | if (mSource == AINPUT_SOURCE_MOUSE) { |
| 318 | if (moved || scrolled || buttonsChanged) { |
| 319 | mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_POINTER); |
| 320 | |
| 321 | if (moved) { |
| 322 | mPointerController->move(deltaX, deltaY); |
| 323 | } |
| 324 | |
| 325 | if (buttonsChanged) { |
| 326 | mPointerController->setButtonState(currentButtonState); |
| 327 | } |
| 328 | |
| 329 | mPointerController->unfade(PointerControllerInterface::TRANSITION_IMMEDIATE); |
| 330 | } |
| 331 | |
| 332 | mPointerController->getPosition(&xCursorPosition, &yCursorPosition); |
| 333 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, xCursorPosition); |
| 334 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition); |
| 335 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, deltaX); |
| 336 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, deltaY); |
| 337 | displayId = mPointerController->getDisplayId(); |
| 338 | } else { |
| 339 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, deltaX); |
| 340 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, deltaY); |
| 341 | displayId = ADISPLAY_ID_NONE; |
| 342 | } |
| 343 | |
| 344 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, down ? 1.0f : 0.0f); |
| 345 | |
| 346 | // Moving an external trackball or mouse should wake the device. |
| 347 | // We don't do this for internal cursor devices to prevent them from waking up |
| 348 | // the device in your pocket. |
| 349 | // TODO: Use the input device configuration to control this behavior more finely. |
| 350 | uint32_t policyFlags = 0; |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 351 | if ((buttonsPressed || moved || scrolled) && getDeviceContext().isExternal()) { |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 352 | policyFlags |= POLICY_FLAG_WAKE; |
| 353 | } |
| 354 | |
| 355 | // Synthesize key down from buttons if needed. |
| 356 | synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource, |
| 357 | displayId, policyFlags, lastButtonState, currentButtonState); |
| 358 | |
| 359 | // Send motion event. |
| 360 | if (downChanged || moved || scrolled || buttonsChanged) { |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 361 | int32_t metaState = getContext()->getGlobalMetaState(); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 362 | int32_t buttonState = lastButtonState; |
| 363 | int32_t motionEventAction; |
| 364 | if (downChanged) { |
| 365 | motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP; |
| 366 | } else if (down || (mSource != AINPUT_SOURCE_MOUSE)) { |
| 367 | motionEventAction = AMOTION_EVENT_ACTION_MOVE; |
| 368 | } else { |
| 369 | motionEventAction = AMOTION_EVENT_ACTION_HOVER_MOVE; |
| 370 | } |
| 371 | |
| 372 | if (buttonsReleased) { |
| 373 | BitSet32 released(buttonsReleased); |
| 374 | while (!released.isEmpty()) { |
| 375 | int32_t actionButton = BitSet32::valueForBit(released.clearFirstMarkedBit()); |
| 376 | buttonState &= ~actionButton; |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 377 | NotifyMotionArgs releaseArgs(getContext()->getNextId(), when, getDeviceId(), |
| 378 | mSource, displayId, policyFlags, |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 379 | AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, |
| 380 | metaState, buttonState, MotionClassification::NONE, |
| 381 | AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, |
| 382 | &pointerCoords, mXPrecision, mYPrecision, |
| 383 | xCursorPosition, yCursorPosition, downTime, |
| 384 | /* videoFrames */ {}); |
| 385 | getListener()->notifyMotion(&releaseArgs); |
| 386 | } |
| 387 | } |
| 388 | |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 389 | NotifyMotionArgs args(getContext()->getNextId(), when, getDeviceId(), mSource, displayId, |
| 390 | policyFlags, motionEventAction, 0, 0, metaState, currentButtonState, |
| 391 | MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, |
| 392 | &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, |
| 393 | xCursorPosition, yCursorPosition, downTime, |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 394 | /* videoFrames */ {}); |
| 395 | getListener()->notifyMotion(&args); |
| 396 | |
| 397 | if (buttonsPressed) { |
| 398 | BitSet32 pressed(buttonsPressed); |
| 399 | while (!pressed.isEmpty()) { |
| 400 | int32_t actionButton = BitSet32::valueForBit(pressed.clearFirstMarkedBit()); |
| 401 | buttonState |= actionButton; |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 402 | NotifyMotionArgs pressArgs(getContext()->getNextId(), when, getDeviceId(), mSource, |
| 403 | displayId, policyFlags, |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 404 | AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, |
| 405 | metaState, buttonState, MotionClassification::NONE, |
| 406 | AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, |
| 407 | &pointerCoords, mXPrecision, mYPrecision, |
| 408 | xCursorPosition, yCursorPosition, downTime, |
| 409 | /* videoFrames */ {}); |
| 410 | getListener()->notifyMotion(&pressArgs); |
| 411 | } |
| 412 | } |
| 413 | |
| 414 | ALOG_ASSERT(buttonState == currentButtonState); |
| 415 | |
| 416 | // Send hover move after UP to tell the application that the mouse is hovering now. |
| 417 | if (motionEventAction == AMOTION_EVENT_ACTION_UP && (mSource == AINPUT_SOURCE_MOUSE)) { |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 418 | NotifyMotionArgs hoverArgs(getContext()->getNextId(), when, getDeviceId(), mSource, |
| 419 | displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, |
| 420 | 0, metaState, currentButtonState, MotionClassification::NONE, |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 421 | AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, |
| 422 | &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, |
| 423 | yCursorPosition, downTime, /* videoFrames */ {}); |
| 424 | getListener()->notifyMotion(&hoverArgs); |
| 425 | } |
| 426 | |
| 427 | // Send scroll events. |
| 428 | if (scrolled) { |
| 429 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); |
| 430 | pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); |
| 431 | |
Garfield Tan | 6a5a14e | 2020-01-28 13:24:04 -0800 | [diff] [blame^] | 432 | NotifyMotionArgs scrollArgs(getContext()->getNextId(), when, getDeviceId(), mSource, |
| 433 | displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, |
| 434 | metaState, currentButtonState, MotionClassification::NONE, |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 435 | AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, |
| 436 | &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, |
| 437 | yCursorPosition, downTime, /* videoFrames */ {}); |
| 438 | getListener()->notifyMotion(&scrollArgs); |
| 439 | } |
| 440 | } |
| 441 | |
| 442 | // Synthesize key up from buttons if needed. |
| 443 | synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource, |
| 444 | displayId, policyFlags, lastButtonState, currentButtonState); |
| 445 | |
| 446 | mCursorMotionAccumulator.finishSync(); |
| 447 | mCursorScrollAccumulator.finishSync(); |
| 448 | } |
| 449 | |
| 450 | int32_t CursorInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { |
| 451 | if (scanCode >= BTN_MOUSE && scanCode < BTN_JOYSTICK) { |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 452 | return getDeviceContext().getScanCodeState(scanCode); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 453 | } else { |
| 454 | return AKEY_STATE_UNKNOWN; |
| 455 | } |
| 456 | } |
| 457 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 458 | std::optional<int32_t> CursorInputMapper::getAssociatedDisplayId() { |
| 459 | if (mParameters.hasAssociatedDisplay) { |
| 460 | if (mParameters.mode == Parameters::MODE_POINTER) { |
| 461 | return std::make_optional(mPointerController->getDisplayId()); |
| 462 | } else { |
| 463 | // If the device is orientationAware and not a mouse, |
| 464 | // it expects to dispatch events to any display |
| 465 | return std::make_optional(ADISPLAY_ID_NONE); |
| 466 | } |
| 467 | } |
| 468 | return std::nullopt; |
| 469 | } |
| 470 | |
| 471 | } // namespace android |