1 /* 2 * Copyright (C) 2010 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 17 /** 18 * @addtogroup Input 19 * @{ 20 */ 21 22 /** 23 * @file input.h 24 */ 25 26 #ifndef _ANDROID_INPUT_H 27 #define _ANDROID_INPUT_H 28 29 #include <sys/cdefs.h> 30 31 /****************************************************************** 32 * 33 * IMPORTANT NOTICE: 34 * 35 * This file is part of Android's set of stable system headers 36 * exposed by the Android NDK (Native Development Kit). 37 * 38 * Third-party source AND binary code relies on the definitions 39 * here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES. 40 * 41 * - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES) 42 * - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS 43 * - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY 44 * - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES 45 */ 46 47 /* 48 * Structures and functions to receive and process input events in 49 * native code. 50 * 51 * NOTE: These functions MUST be implemented by /system/lib/libui.so 52 */ 53 54 #include <stdint.h> 55 #include <sys/types.h> 56 #include <android/keycodes.h> 57 58 // This file is included by modules that have host support but android/looper.h is not supported 59 // on host. __REMOVED_IN needs to be defined in order for android/looper.h to be compiled. 60 #ifndef __BIONIC__ 61 #define __REMOVED_IN(x) __attribute__((deprecated)) 62 #endif 63 #include <android/looper.h> 64 65 #include <jni.h> 66 67 #if !defined(__INTRODUCED_IN) 68 #define __INTRODUCED_IN(__api_level) /* nothing */ 69 #endif 70 71 #ifdef __cplusplus 72 extern "C" { 73 #endif 74 75 /** 76 * Key states (may be returned by queries about the current state of a 77 * particular key code, scan code or switch). 78 */ 79 enum { 80 /** The key state is unknown or the requested key itself is not supported. */ 81 AKEY_STATE_UNKNOWN = -1, 82 83 /** The key is up. */ 84 AKEY_STATE_UP = 0, 85 86 /** The key is down. */ 87 AKEY_STATE_DOWN = 1, 88 89 /** The key is down but is a virtual key press that is being emulated by the system. */ 90 AKEY_STATE_VIRTUAL = 2 91 }; 92 93 /** 94 * Meta key / modifier state. 95 */ 96 enum { 97 /** No meta keys are pressed. */ 98 AMETA_NONE = 0, 99 100 /** This mask is used to check whether one of the ALT meta keys is pressed. */ 101 AMETA_ALT_ON = 0x02, 102 103 /** This mask is used to check whether the left ALT meta key is pressed. */ 104 AMETA_ALT_LEFT_ON = 0x10, 105 106 /** This mask is used to check whether the right ALT meta key is pressed. */ 107 AMETA_ALT_RIGHT_ON = 0x20, 108 109 /** This mask is used to check whether one of the SHIFT meta keys is pressed. */ 110 AMETA_SHIFT_ON = 0x01, 111 112 /** This mask is used to check whether the left SHIFT meta key is pressed. */ 113 AMETA_SHIFT_LEFT_ON = 0x40, 114 115 /** This mask is used to check whether the right SHIFT meta key is pressed. */ 116 AMETA_SHIFT_RIGHT_ON = 0x80, 117 118 /** This mask is used to check whether the SYM meta key is pressed. */ 119 AMETA_SYM_ON = 0x04, 120 121 /** This mask is used to check whether the FUNCTION meta key is pressed. */ 122 AMETA_FUNCTION_ON = 0x08, 123 124 /** This mask is used to check whether one of the CTRL meta keys is pressed. */ 125 AMETA_CTRL_ON = 0x1000, 126 127 /** This mask is used to check whether the left CTRL meta key is pressed. */ 128 AMETA_CTRL_LEFT_ON = 0x2000, 129 130 /** This mask is used to check whether the right CTRL meta key is pressed. */ 131 AMETA_CTRL_RIGHT_ON = 0x4000, 132 133 /** This mask is used to check whether one of the META meta keys is pressed. */ 134 AMETA_META_ON = 0x10000, 135 136 /** This mask is used to check whether the left META meta key is pressed. */ 137 AMETA_META_LEFT_ON = 0x20000, 138 139 /** This mask is used to check whether the right META meta key is pressed. */ 140 AMETA_META_RIGHT_ON = 0x40000, 141 142 /** This mask is used to check whether the CAPS LOCK meta key is on. */ 143 AMETA_CAPS_LOCK_ON = 0x100000, 144 145 /** This mask is used to check whether the NUM LOCK meta key is on. */ 146 AMETA_NUM_LOCK_ON = 0x200000, 147 148 /** This mask is used to check whether the SCROLL LOCK meta key is on. */ 149 AMETA_SCROLL_LOCK_ON = 0x400000, 150 }; 151 152 struct AInputEvent; 153 /** 154 * Input events. 155 * 156 * Input events are opaque structures. Use the provided accessors functions to 157 * read their properties. 158 */ 159 typedef struct AInputEvent AInputEvent; 160 161 /** 162 * Input event types. 163 */ 164 enum { 165 /** Indicates that the input event is a key event. */ 166 AINPUT_EVENT_TYPE_KEY = 1, 167 168 /** Indicates that the input event is a motion event. */ 169 AINPUT_EVENT_TYPE_MOTION = 2, 170 171 /** Focus event */ 172 AINPUT_EVENT_TYPE_FOCUS = 3, 173 174 /** Capture event */ 175 AINPUT_EVENT_TYPE_CAPTURE = 4, 176 177 /** Drag event */ 178 AINPUT_EVENT_TYPE_DRAG = 5, 179 180 /** TouchMode event */ 181 AINPUT_EVENT_TYPE_TOUCH_MODE = 6, 182 }; 183 184 /** 185 * Key event actions. 186 */ 187 enum { 188 /** The key has been pressed down. */ 189 AKEY_EVENT_ACTION_DOWN = 0, 190 191 /** The key has been released. */ 192 AKEY_EVENT_ACTION_UP = 1, 193 194 /** 195 * Multiple duplicate key events have occurred in a row, or a 196 * complex string is being delivered. The repeat_count property 197 * of the key event contains the number of times the given key 198 * code should be executed. 199 */ 200 AKEY_EVENT_ACTION_MULTIPLE = 2 201 }; 202 203 /** 204 * Key event flags. 205 */ 206 enum { 207 /** This mask is set if the device woke because of this key event. */ 208 AKEY_EVENT_FLAG_WOKE_HERE = 0x1, 209 210 /** This mask is set if the key event was generated by a software keyboard. */ 211 AKEY_EVENT_FLAG_SOFT_KEYBOARD = 0x2, 212 213 /** This mask is set if we don't want the key event to cause us to leave touch mode. */ 214 AKEY_EVENT_FLAG_KEEP_TOUCH_MODE = 0x4, 215 216 /** 217 * This mask is set if an event was known to come from a trusted 218 * part of the system. That is, the event is known to come from 219 * the user, and could not have been spoofed by a third party 220 * component. 221 */ 222 AKEY_EVENT_FLAG_FROM_SYSTEM = 0x8, 223 224 /** 225 * This mask is used for compatibility, to identify enter keys that are 226 * coming from an IME whose enter key has been auto-labelled "next" or 227 * "done". This allows TextView to dispatch these as normal enter keys 228 * for old applications, but still do the appropriate action when 229 * receiving them. 230 */ 231 AKEY_EVENT_FLAG_EDITOR_ACTION = 0x10, 232 233 /** 234 * When associated with up key events, this indicates that the key press 235 * has been canceled. Typically this is used with virtual touch screen 236 * keys, where the user can slide from the virtual key area on to the 237 * display: in that case, the application will receive a canceled up 238 * event and should not perform the action normally associated with the 239 * key. Note that for this to work, the application can not perform an 240 * action for a key until it receives an up or the long press timeout has 241 * expired. 242 */ 243 AKEY_EVENT_FLAG_CANCELED = 0x20, 244 245 /** 246 * This key event was generated by a virtual (on-screen) hard key area. 247 * Typically this is an area of the touchscreen, outside of the regular 248 * display, dedicated to "hardware" buttons. 249 */ 250 AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY = 0x40, 251 252 /** 253 * This flag is set for the first key repeat that occurs after the 254 * long press timeout. 255 */ 256 AKEY_EVENT_FLAG_LONG_PRESS = 0x80, 257 258 /** 259 * Set when a key event has #AKEY_EVENT_FLAG_CANCELED set because a long 260 * press action was executed while it was down. 261 */ 262 AKEY_EVENT_FLAG_CANCELED_LONG_PRESS = 0x100, 263 264 /** 265 * Set for #AKEY_EVENT_ACTION_UP when this event's key code is still being 266 * tracked from its initial down. That is, somebody requested that tracking 267 * started on the key down and a long press has not caused 268 * the tracking to be canceled. 269 */ 270 AKEY_EVENT_FLAG_TRACKING = 0x200, 271 272 /** 273 * Set when a key event has been synthesized to implement default behavior 274 * for an event that the application did not handle. 275 * Fallback key events are generated by unhandled trackball motions 276 * (to emulate a directional keypad) and by certain unhandled key presses 277 * that are declared in the key map (such as special function numeric keypad 278 * keys when numlock is off). 279 */ 280 AKEY_EVENT_FLAG_FALLBACK = 0x400, 281 }; 282 283 /** 284 * Bit shift for the action bits holding the pointer index as 285 * defined by #AMOTION_EVENT_ACTION_POINTER_INDEX_MASK. 286 */ 287 #define AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT 8 288 289 /** Motion event actions */ 290 enum { 291 /** Bit mask of the parts of the action code that are the action itself. */ 292 AMOTION_EVENT_ACTION_MASK = 0xff, 293 294 /** 295 * Bits in the action code that represent a pointer index, used with 296 * #AMOTION_EVENT_ACTION_POINTER_DOWN and AMOTION_EVENT_ACTION_POINTER_UP. Shifting 297 * down by #AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT provides the actual pointer 298 * index where the data for the pointer going up or down can be found. 299 */ 300 AMOTION_EVENT_ACTION_POINTER_INDEX_MASK = 0xff00, 301 302 /** A pressed gesture has started, the motion contains the initial starting location. */ 303 AMOTION_EVENT_ACTION_DOWN = 0, 304 305 /** 306 * A pressed gesture has finished, the motion contains the final release location 307 * as well as any intermediate points since the last down or move event. 308 */ 309 AMOTION_EVENT_ACTION_UP = 1, 310 311 /** 312 * A change has happened during a press gesture (between #AMOTION_EVENT_ACTION_DOWN and 313 * #AMOTION_EVENT_ACTION_UP). The motion contains the most recent point, as well as 314 * any intermediate points since the last down or move event. 315 */ 316 AMOTION_EVENT_ACTION_MOVE = 2, 317 318 /** 319 * The current gesture has been aborted. 320 * You will not receive any more points in it. You should treat this as 321 * an up event, but not perform any action that you normally would. 322 */ 323 AMOTION_EVENT_ACTION_CANCEL = 3, 324 325 /** 326 * A movement has happened outside of the normal bounds of the UI element. 327 * This does not provide a full gesture, but only the initial location of the movement/touch. 328 */ 329 AMOTION_EVENT_ACTION_OUTSIDE = 4, 330 331 /** 332 * A non-primary pointer has gone down. 333 * The bits in #AMOTION_EVENT_ACTION_POINTER_INDEX_MASK indicate which pointer changed. 334 */ 335 AMOTION_EVENT_ACTION_POINTER_DOWN = 5, 336 337 /** 338 * A non-primary pointer has gone up. 339 * The bits in #AMOTION_EVENT_ACTION_POINTER_INDEX_MASK indicate which pointer changed. 340 */ 341 AMOTION_EVENT_ACTION_POINTER_UP = 6, 342 343 /** 344 * A change happened but the pointer is not down (unlike #AMOTION_EVENT_ACTION_MOVE). 345 * The motion contains the most recent point, as well as any intermediate points since 346 * the last hover move event. 347 */ 348 AMOTION_EVENT_ACTION_HOVER_MOVE = 7, 349 350 /** 351 * The motion event contains relative vertical and/or horizontal scroll offsets. 352 * Use {@link AMotionEvent_getAxisValue} to retrieve the information from 353 * #AMOTION_EVENT_AXIS_VSCROLL and #AMOTION_EVENT_AXIS_HSCROLL. 354 * The pointer may or may not be down when this event is dispatched. 355 * This action is always delivered to the winder under the pointer, which 356 * may not be the window currently touched. 357 */ 358 AMOTION_EVENT_ACTION_SCROLL = 8, 359 360 /** The pointer is not down but has entered the boundaries of a window or view. */ 361 AMOTION_EVENT_ACTION_HOVER_ENTER = 9, 362 363 /** The pointer is not down but has exited the boundaries of a window or view. */ 364 AMOTION_EVENT_ACTION_HOVER_EXIT = 10, 365 366 /* One or more buttons have been pressed. */ 367 AMOTION_EVENT_ACTION_BUTTON_PRESS = 11, 368 369 /* One or more buttons have been released. */ 370 AMOTION_EVENT_ACTION_BUTTON_RELEASE = 12, 371 }; 372 373 /** 374 * Motion event flags. 375 */ 376 enum { 377 /** 378 * This flag indicates that the window that received this motion event is partly 379 * or wholly obscured by another visible window above it. This flag is set to true 380 * even if the event did not directly pass through the obscured area. 381 * A security sensitive application can check this flag to identify situations in which 382 * a malicious application may have covered up part of its content for the purpose 383 * of misleading the user or hijacking touches. An appropriate response might be 384 * to drop the suspect touches or to take additional precautions to confirm the user's 385 * actual intent. 386 */ 387 AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED = 0x1, 388 }; 389 390 /** 391 * Motion event edge touch flags. 392 */ 393 enum { 394 /** No edges intersected. */ 395 AMOTION_EVENT_EDGE_FLAG_NONE = 0, 396 397 /** Flag indicating the motion event intersected the top edge of the screen. */ 398 AMOTION_EVENT_EDGE_FLAG_TOP = 0x01, 399 400 /** Flag indicating the motion event intersected the bottom edge of the screen. */ 401 AMOTION_EVENT_EDGE_FLAG_BOTTOM = 0x02, 402 403 /** Flag indicating the motion event intersected the left edge of the screen. */ 404 AMOTION_EVENT_EDGE_FLAG_LEFT = 0x04, 405 406 /** Flag indicating the motion event intersected the right edge of the screen. */ 407 AMOTION_EVENT_EDGE_FLAG_RIGHT = 0x08 408 }; 409 410 /** 411 * Constants that identify each individual axis of a motion event. 412 * @anchor AMOTION_EVENT_AXIS 413 */ 414 enum { 415 /** 416 * Axis constant: X axis of a motion event. 417 * 418 * - For a touch screen, reports the absolute X screen position of the center of 419 * the touch contact area. The units are display pixels. 420 * - For a touch pad, reports the absolute X surface position of the center of the touch 421 * contact area. The units are device-dependent. 422 * - For a mouse, reports the absolute X screen position of the mouse pointer. 423 * The units are display pixels. 424 * - For a trackball, reports the relative horizontal displacement of the trackball. 425 * The value is normalized to a range from -1.0 (left) to 1.0 (right). 426 * - For a joystick, reports the absolute X position of the joystick. 427 * The value is normalized to a range from -1.0 (left) to 1.0 (right). 428 */ 429 AMOTION_EVENT_AXIS_X = 0, 430 /** 431 * Axis constant: Y axis of a motion event. 432 * 433 * - For a touch screen, reports the absolute Y screen position of the center of 434 * the touch contact area. The units are display pixels. 435 * - For a touch pad, reports the absolute Y surface position of the center of the touch 436 * contact area. The units are device-dependent. 437 * - For a mouse, reports the absolute Y screen position of the mouse pointer. 438 * The units are display pixels. 439 * - For a trackball, reports the relative vertical displacement of the trackball. 440 * The value is normalized to a range from -1.0 (up) to 1.0 (down). 441 * - For a joystick, reports the absolute Y position of the joystick. 442 * The value is normalized to a range from -1.0 (up or far) to 1.0 (down or near). 443 */ 444 AMOTION_EVENT_AXIS_Y = 1, 445 /** 446 * Axis constant: Pressure axis of a motion event. 447 * 448 * - For a touch screen or touch pad, reports the approximate pressure applied to the surface 449 * by a finger or other tool. The value is normalized to a range from 450 * 0 (no pressure at all) to 1 (normal pressure), although values higher than 1 451 * may be generated depending on the calibration of the input device. 452 * - For a trackball, the value is set to 1 if the trackball button is pressed 453 * or 0 otherwise. 454 * - For a mouse, the value is set to 1 if the primary mouse button is pressed 455 * or 0 otherwise. 456 */ 457 AMOTION_EVENT_AXIS_PRESSURE = 2, 458 /** 459 * Axis constant: Size axis of a motion event. 460 * 461 * - For a touch screen or touch pad, reports the approximate size of the contact area in 462 * relation to the maximum detectable size for the device. The value is normalized 463 * to a range from 0 (smallest detectable size) to 1 (largest detectable size), 464 * although it is not a linear scale. This value is of limited use. 465 * To obtain calibrated size information, see 466 * {@link AMOTION_EVENT_AXIS_TOUCH_MAJOR} or {@link AMOTION_EVENT_AXIS_TOOL_MAJOR}. 467 */ 468 AMOTION_EVENT_AXIS_SIZE = 3, 469 /** 470 * Axis constant: TouchMajor axis of a motion event. 471 * 472 * - For a touch screen, reports the length of the major axis of an ellipse that 473 * represents the touch area at the point of contact. 474 * The units are display pixels. 475 * - For a touch pad, reports the length of the major axis of an ellipse that 476 * represents the touch area at the point of contact. 477 * The units are device-dependent. 478 */ 479 AMOTION_EVENT_AXIS_TOUCH_MAJOR = 4, 480 /** 481 * Axis constant: TouchMinor axis of a motion event. 482 * 483 * - For a touch screen, reports the length of the minor axis of an ellipse that 484 * represents the touch area at the point of contact. 485 * The units are display pixels. 486 * - For a touch pad, reports the length of the minor axis of an ellipse that 487 * represents the touch area at the point of contact. 488 * The units are device-dependent. 489 * 490 * When the touch is circular, the major and minor axis lengths will be equal to one another. 491 */ 492 AMOTION_EVENT_AXIS_TOUCH_MINOR = 5, 493 /** 494 * Axis constant: ToolMajor axis of a motion event. 495 * 496 * - For a touch screen, reports the length of the major axis of an ellipse that 497 * represents the size of the approaching finger or tool used to make contact. 498 * - For a touch pad, reports the length of the major axis of an ellipse that 499 * represents the size of the approaching finger or tool used to make contact. 500 * The units are device-dependent. 501 * 502 * When the touch is circular, the major and minor axis lengths will be equal to one another. 503 * 504 * The tool size may be larger than the touch size since the tool may not be fully 505 * in contact with the touch sensor. 506 */ 507 AMOTION_EVENT_AXIS_TOOL_MAJOR = 6, 508 /** 509 * Axis constant: ToolMinor axis of a motion event. 510 * 511 * - For a touch screen, reports the length of the minor axis of an ellipse that 512 * represents the size of the approaching finger or tool used to make contact. 513 * - For a touch pad, reports the length of the minor axis of an ellipse that 514 * represents the size of the approaching finger or tool used to make contact. 515 * The units are device-dependent. 516 * 517 * When the touch is circular, the major and minor axis lengths will be equal to one another. 518 * 519 * The tool size may be larger than the touch size since the tool may not be fully 520 * in contact with the touch sensor. 521 */ 522 AMOTION_EVENT_AXIS_TOOL_MINOR = 7, 523 /** 524 * Axis constant: Orientation axis of a motion event. 525 * 526 * - For a touch screen or touch pad, reports the orientation of the finger 527 * or tool in radians relative to the vertical plane of the device. 528 * An angle of 0 radians indicates that the major axis of contact is oriented 529 * upwards, is perfectly circular or is of unknown orientation. A positive angle 530 * indicates that the major axis of contact is oriented to the right. A negative angle 531 * indicates that the major axis of contact is oriented to the left. 532 * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians 533 * (finger pointing fully right). 534 * - For a stylus, the orientation indicates the direction in which the stylus 535 * is pointing in relation to the vertical axis of the current orientation of the screen. 536 * The range is from -PI radians to PI radians, where 0 is pointing up, 537 * -PI/2 radians is pointing left, -PI or PI radians is pointing down, and PI/2 radians 538 * is pointing right. See also #AMOTION_EVENT_AXIS_TILT. 539 */ 540 AMOTION_EVENT_AXIS_ORIENTATION = 8, 541 /** 542 * Axis constant: Vertical Scroll axis of a motion event. 543 * 544 * - For a mouse, reports the relative movement of the vertical scroll wheel. 545 * The value is normalized to a range from -1.0 (down) to 1.0 (up). 546 * 547 * This axis should be used to scroll views vertically. 548 */ 549 AMOTION_EVENT_AXIS_VSCROLL = 9, 550 /** 551 * Axis constant: Horizontal Scroll axis of a motion event. 552 * 553 * - For a mouse, reports the relative movement of the horizontal scroll wheel. 554 * The value is normalized to a range from -1.0 (left) to 1.0 (right). 555 * 556 * This axis should be used to scroll views horizontally. 557 */ 558 AMOTION_EVENT_AXIS_HSCROLL = 10, 559 /** 560 * Axis constant: Z axis of a motion event. 561 * 562 * - For a joystick, reports the absolute Z position of the joystick. 563 * The value is normalized to a range from -1.0 (high) to 1.0 (low). 564 * <em>On game pads with two analog joysticks, this axis is often reinterpreted 565 * to report the absolute X position of the second joystick instead.</em> 566 */ 567 AMOTION_EVENT_AXIS_Z = 11, 568 /** 569 * Axis constant: X Rotation axis of a motion event. 570 * 571 * - For a joystick, reports the absolute rotation angle about the X axis. 572 * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise). 573 */ 574 AMOTION_EVENT_AXIS_RX = 12, 575 /** 576 * Axis constant: Y Rotation axis of a motion event. 577 * 578 * - For a joystick, reports the absolute rotation angle about the Y axis. 579 * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise). 580 */ 581 AMOTION_EVENT_AXIS_RY = 13, 582 /** 583 * Axis constant: Z Rotation axis of a motion event. 584 * 585 * - For a joystick, reports the absolute rotation angle about the Z axis. 586 * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise). 587 * On game pads with two analog joysticks, this axis is often reinterpreted 588 * to report the absolute Y position of the second joystick instead. 589 */ 590 AMOTION_EVENT_AXIS_RZ = 14, 591 /** 592 * Axis constant: Hat X axis of a motion event. 593 * 594 * - For a joystick, reports the absolute X position of the directional hat control. 595 * The value is normalized to a range from -1.0 (left) to 1.0 (right). 596 */ 597 AMOTION_EVENT_AXIS_HAT_X = 15, 598 /** 599 * Axis constant: Hat Y axis of a motion event. 600 * 601 * - For a joystick, reports the absolute Y position of the directional hat control. 602 * The value is normalized to a range from -1.0 (up) to 1.0 (down). 603 */ 604 AMOTION_EVENT_AXIS_HAT_Y = 16, 605 /** 606 * Axis constant: Left Trigger axis of a motion event. 607 * 608 * - For a joystick, reports the absolute position of the left trigger control. 609 * The value is normalized to a range from 0.0 (released) to 1.0 (fully pressed). 610 */ 611 AMOTION_EVENT_AXIS_LTRIGGER = 17, 612 /** 613 * Axis constant: Right Trigger axis of a motion event. 614 * 615 * - For a joystick, reports the absolute position of the right trigger control. 616 * The value is normalized to a range from 0.0 (released) to 1.0 (fully pressed). 617 */ 618 AMOTION_EVENT_AXIS_RTRIGGER = 18, 619 /** 620 * Axis constant: Throttle axis of a motion event. 621 * 622 * - For a joystick, reports the absolute position of the throttle control. 623 * The value is normalized to a range from 0.0 (fully open) to 1.0 (fully closed). 624 */ 625 AMOTION_EVENT_AXIS_THROTTLE = 19, 626 /** 627 * Axis constant: Rudder axis of a motion event. 628 * 629 * - For a joystick, reports the absolute position of the rudder control. 630 * The value is normalized to a range from -1.0 (turn left) to 1.0 (turn right). 631 */ 632 AMOTION_EVENT_AXIS_RUDDER = 20, 633 /** 634 * Axis constant: Wheel axis of a motion event. 635 * 636 * - For a joystick, reports the absolute position of the steering wheel control. 637 * The value is normalized to a range from -1.0 (turn left) to 1.0 (turn right). 638 */ 639 AMOTION_EVENT_AXIS_WHEEL = 21, 640 /** 641 * Axis constant: Gas axis of a motion event. 642 * 643 * - For a joystick, reports the absolute position of the gas (accelerator) control. 644 * The value is normalized to a range from 0.0 (no acceleration) 645 * to 1.0 (maximum acceleration). 646 */ 647 AMOTION_EVENT_AXIS_GAS = 22, 648 /** 649 * Axis constant: Brake axis of a motion event. 650 * 651 * - For a joystick, reports the absolute position of the brake control. 652 * The value is normalized to a range from 0.0 (no braking) to 1.0 (maximum braking). 653 */ 654 AMOTION_EVENT_AXIS_BRAKE = 23, 655 /** 656 * Axis constant: Distance axis of a motion event. 657 * 658 * - For a stylus, reports the distance of the stylus from the screen. 659 * A value of 0.0 indicates direct contact and larger values indicate increasing 660 * distance from the surface. 661 */ 662 AMOTION_EVENT_AXIS_DISTANCE = 24, 663 /** 664 * Axis constant: Tilt axis of a motion event. 665 * 666 * - For a stylus, reports the tilt angle of the stylus in radians where 667 * 0 radians indicates that the stylus is being held perpendicular to the 668 * surface, and PI/2 radians indicates that the stylus is being held flat 669 * against the surface. 670 */ 671 AMOTION_EVENT_AXIS_TILT = 25, 672 /** 673 * Axis constant: Generic scroll axis of a motion event. 674 * 675 * - This is used for scroll axis motion events that can't be classified as strictly 676 * vertical or horizontal. The movement of a rotating scroller is an example of this. 677 */ 678 AMOTION_EVENT_AXIS_SCROLL = 26, 679 /** 680 * Axis constant: The movement of x position of a motion event. 681 * 682 * - For a mouse, reports a difference of x position between the previous position. 683 * This is useful when pointer is captured, in that case the mouse pointer doesn't 684 * change the location but this axis reports the difference which allows the app 685 * to see how the mouse is moved. 686 */ 687 AMOTION_EVENT_AXIS_RELATIVE_X = 27, 688 /** 689 * Axis constant: The movement of y position of a motion event. 690 * 691 * Same as #AMOTION_EVENT_AXIS_RELATIVE_X, but for y position. 692 */ 693 AMOTION_EVENT_AXIS_RELATIVE_Y = 28, 694 /** 695 * Axis constant: Generic 1 axis of a motion event. 696 * The interpretation of a generic axis is device-specific. 697 */ 698 AMOTION_EVENT_AXIS_GENERIC_1 = 32, 699 /** 700 * Axis constant: Generic 2 axis of a motion event. 701 * The interpretation of a generic axis is device-specific. 702 */ 703 AMOTION_EVENT_AXIS_GENERIC_2 = 33, 704 /** 705 * Axis constant: Generic 3 axis of a motion event. 706 * The interpretation of a generic axis is device-specific. 707 */ 708 AMOTION_EVENT_AXIS_GENERIC_3 = 34, 709 /** 710 * Axis constant: Generic 4 axis of a motion event. 711 * The interpretation of a generic axis is device-specific. 712 */ 713 AMOTION_EVENT_AXIS_GENERIC_4 = 35, 714 /** 715 * Axis constant: Generic 5 axis of a motion event. 716 * The interpretation of a generic axis is device-specific. 717 */ 718 AMOTION_EVENT_AXIS_GENERIC_5 = 36, 719 /** 720 * Axis constant: Generic 6 axis of a motion event. 721 * The interpretation of a generic axis is device-specific. 722 */ 723 AMOTION_EVENT_AXIS_GENERIC_6 = 37, 724 /** 725 * Axis constant: Generic 7 axis of a motion event. 726 * The interpretation of a generic axis is device-specific. 727 */ 728 AMOTION_EVENT_AXIS_GENERIC_7 = 38, 729 /** 730 * Axis constant: Generic 8 axis of a motion event. 731 * The interpretation of a generic axis is device-specific. 732 */ 733 AMOTION_EVENT_AXIS_GENERIC_8 = 39, 734 /** 735 * Axis constant: Generic 9 axis of a motion event. 736 * The interpretation of a generic axis is device-specific. 737 */ 738 AMOTION_EVENT_AXIS_GENERIC_9 = 40, 739 /** 740 * Axis constant: Generic 10 axis of a motion event. 741 * The interpretation of a generic axis is device-specific. 742 */ 743 AMOTION_EVENT_AXIS_GENERIC_10 = 41, 744 /** 745 * Axis constant: Generic 11 axis of a motion event. 746 * The interpretation of a generic axis is device-specific. 747 */ 748 AMOTION_EVENT_AXIS_GENERIC_11 = 42, 749 /** 750 * Axis constant: Generic 12 axis of a motion event. 751 * The interpretation of a generic axis is device-specific. 752 */ 753 AMOTION_EVENT_AXIS_GENERIC_12 = 43, 754 /** 755 * Axis constant: Generic 13 axis of a motion event. 756 * The interpretation of a generic axis is device-specific. 757 */ 758 AMOTION_EVENT_AXIS_GENERIC_13 = 44, 759 /** 760 * Axis constant: Generic 14 axis of a motion event. 761 * The interpretation of a generic axis is device-specific. 762 */ 763 AMOTION_EVENT_AXIS_GENERIC_14 = 45, 764 /** 765 * Axis constant: Generic 15 axis of a motion event. 766 * The interpretation of a generic axis is device-specific. 767 */ 768 AMOTION_EVENT_AXIS_GENERIC_15 = 46, 769 /** 770 * Axis constant: Generic 16 axis of a motion event. 771 * The interpretation of a generic axis is device-specific. 772 */ 773 AMOTION_EVENT_AXIS_GENERIC_16 = 47, 774 /** 775 * Axis constant: X gesture offset axis of a motion event. 776 * 777 * - For a touch pad, reports the distance that a swipe gesture has moved in the X axis, as a 778 * proportion of the touch pad's size. For example, if a touch pad is 1000 units wide, and a 779 * swipe gesture starts at X = 500 then moves to X = 400, this axis would have a value of 780 * -0.1. 781 * 782 * These values are relative to the state from the last event, not accumulated, so developers 783 * should make sure to process this axis value for all batched historical events. 784 * 785 * This axis is only set on the first pointer in a motion event. 786 */ 787 AMOTION_EVENT_AXIS_GESTURE_X_OFFSET = 48, 788 /** 789 * Axis constant: Y gesture offset axis of a motion event. 790 * 791 * The same as {@link AMOTION_EVENT_AXIS_GESTURE_X_OFFSET}, but for the Y axis. 792 */ 793 AMOTION_EVENT_AXIS_GESTURE_Y_OFFSET = 49, 794 /** 795 * Axis constant: X scroll distance axis of a motion event. 796 * 797 * - For a touch pad, reports the distance that should be scrolled in the X axis as a result of 798 * the user's two-finger scroll gesture, in display pixels. 799 * 800 * These values are relative to the state from the last event, not accumulated, so developers 801 * should make sure to process this axis value for all batched historical events. 802 * 803 * This axis is only set on the first pointer in a motion event. 804 */ 805 AMOTION_EVENT_AXIS_GESTURE_SCROLL_X_DISTANCE = 50, 806 /** 807 * Axis constant: Y scroll distance axis of a motion event. 808 * 809 * The same as {@link AMOTION_EVENT_AXIS_GESTURE_SCROLL_X_DISTANCE}, but for the Y axis. 810 */ 811 AMOTION_EVENT_AXIS_GESTURE_SCROLL_Y_DISTANCE = 51, 812 /** 813 * Axis constant: pinch scale factor of a motion event. 814 * 815 * - For a touch pad, reports the change in distance between the fingers when the user is making 816 * a pinch gesture, as a proportion of that distance when the gesture was last reported. For 817 * example, if the fingers were 50 units apart and are now 52 units apart, the scale factor 818 * would be 1.04. 819 * 820 * These values are relative to the state from the last event, not accumulated, so developers 821 * should make sure to process this axis value for all batched historical events. 822 * 823 * This axis is only set on the first pointer in a motion event. 824 */ 825 AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR = 52, 826 827 /** 828 * Axis constant: the number of fingers being used in a multi-finger swipe gesture. 829 * 830 * - For a touch pad, reports the number of fingers being used in a multi-finger swipe gesture 831 * (with CLASSIFICATION_MULTI_FINGER_SWIPE). 832 * 833 * Since CLASSIFICATION_MULTI_FINGER_SWIPE is a hidden API, so is this axis. It is only set on 834 * the first pointer in a motion event. 835 */ 836 AMOTION_EVENT_AXIS_GESTURE_SWIPE_FINGER_COUNT = 53, 837 838 /** 839 * Note: This is not an "Axis constant". It does not represent any axis, nor should it be used 840 * to represent any axis. It is a constant holding the value of the largest defined axis value, 841 * to make some computations (like iterating through all possible axes) cleaner. 842 * Please update the value accordingly if you add a new axis. 843 */ 844 AMOTION_EVENT_MAXIMUM_VALID_AXIS_VALUE = AMOTION_EVENT_AXIS_GESTURE_SWIPE_FINGER_COUNT, 845 846 // NOTE: If you add a new axis here you must also add it to several other files. 847 // Refer to frameworks/base/core/java/android/view/MotionEvent.java for the full list. 848 // Update AMOTION_EVENT_MAXIMUM_VALID_AXIS_VALUE accordingly as well. 849 }; 850 851 /** 852 * Constants that identify buttons that are associated with motion events. 853 * Refer to the documentation on the MotionEvent class for descriptions of each button. 854 */ 855 enum { 856 /** primary */ 857 AMOTION_EVENT_BUTTON_PRIMARY = 1 << 0, 858 /** secondary */ 859 AMOTION_EVENT_BUTTON_SECONDARY = 1 << 1, 860 /** tertiary */ 861 AMOTION_EVENT_BUTTON_TERTIARY = 1 << 2, 862 /** back */ 863 AMOTION_EVENT_BUTTON_BACK = 1 << 3, 864 /** forward */ 865 AMOTION_EVENT_BUTTON_FORWARD = 1 << 4, 866 AMOTION_EVENT_BUTTON_STYLUS_PRIMARY = 1 << 5, 867 AMOTION_EVENT_BUTTON_STYLUS_SECONDARY = 1 << 6, 868 }; 869 870 /** 871 * Constants that identify tool types. 872 * Refer to the documentation on the MotionEvent class for descriptions of each tool type. 873 */ 874 enum { 875 /** unknown */ 876 AMOTION_EVENT_TOOL_TYPE_UNKNOWN = 0, 877 /** finger */ 878 AMOTION_EVENT_TOOL_TYPE_FINGER = 1, 879 /** stylus */ 880 AMOTION_EVENT_TOOL_TYPE_STYLUS = 2, 881 /** mouse */ 882 AMOTION_EVENT_TOOL_TYPE_MOUSE = 3, 883 /** eraser */ 884 AMOTION_EVENT_TOOL_TYPE_ERASER = 4, 885 /** palm */ 886 AMOTION_EVENT_TOOL_TYPE_PALM = 5, 887 }; 888 889 /** 890 * Constants that identify different gesture classification types. 891 */ 892 enum AMotionClassification : uint32_t { 893 /** 894 * Classification constant: None. 895 * 896 * No additional information is available about the current motion event stream. 897 */ 898 AMOTION_EVENT_CLASSIFICATION_NONE = 0, 899 /** 900 * Classification constant: Ambiguous gesture. 901 * 902 * The user's intent with respect to the current event stream is not yet determined. Events 903 * starting in #AMOTION_EVENT_CLASSIFICATION_AMBIGUOUS_GESTURE will eventually resolve into 904 * either #AMOTION_EVENT_CLASSIFICATION_DEEP_PRESS or #AMOTION_EVENT_CLASSIFICATION_NONE. 905 * Gestural actions, such as scrolling, should be inhibited until the classification resolves 906 * to another value or the event stream ends. 907 */ 908 AMOTION_EVENT_CLASSIFICATION_AMBIGUOUS_GESTURE = 1, 909 /** 910 * Classification constant: Deep press. 911 * 912 * The current event stream represents the user intentionally pressing harder on the screen. 913 * This classification type should be used to accelerate the long press behaviour. 914 */ 915 AMOTION_EVENT_CLASSIFICATION_DEEP_PRESS = 2, 916 /** 917 * Classification constant: touchpad two-finger swipe. 918 * 919 * The current event stream represents the user swiping with two fingers on a touchpad. 920 */ 921 AMOTION_EVENT_CLASSIFICATION_TWO_FINGER_SWIPE = 3, 922 /** 923 * Classification constant: multi-finger swipe. 924 * 925 * The current event stream represents the user swiping with three or more fingers on a 926 * touchpad. Unlike two-finger swipes, these are only to be handled by the system UI, which is 927 * why they have a separate constant from two-finger swipes. 928 */ 929 AMOTION_EVENT_CLASSIFICATION_MULTI_FINGER_SWIPE = 4, 930 /** 931 * Classification constant: pinch. 932 * 933 * The current event stream represents the user pinching with two fingers on a touchpad. The 934 * gesture is centered around the current cursor position. 935 */ 936 AMOTION_EVENT_CLASSIFICATION_PINCH = 5, 937 }; 938 939 /** 940 * Input source masks. 941 * 942 * Refer to the documentation on android.view.InputDevice for more details about input sources 943 * and their correct interpretation. 944 */ 945 enum { 946 /** mask */ 947 AINPUT_SOURCE_CLASS_MASK = 0x000000ff, 948 949 /** none */ 950 AINPUT_SOURCE_CLASS_NONE = 0x00000000, 951 /** button */ 952 AINPUT_SOURCE_CLASS_BUTTON = 0x00000001, 953 /** pointer */ 954 AINPUT_SOURCE_CLASS_POINTER = 0x00000002, 955 /** navigation */ 956 AINPUT_SOURCE_CLASS_NAVIGATION = 0x00000004, 957 /** position */ 958 AINPUT_SOURCE_CLASS_POSITION = 0x00000008, 959 /** joystick */ 960 AINPUT_SOURCE_CLASS_JOYSTICK = 0x00000010, 961 }; 962 963 /** 964 * Input sources. 965 */ 966 enum { 967 /** unknown */ 968 AINPUT_SOURCE_UNKNOWN = 0x00000000, 969 970 /** keyboard */ 971 AINPUT_SOURCE_KEYBOARD = 0x00000100 | AINPUT_SOURCE_CLASS_BUTTON, 972 /** dpad */ 973 AINPUT_SOURCE_DPAD = 0x00000200 | AINPUT_SOURCE_CLASS_BUTTON, 974 /** gamepad */ 975 AINPUT_SOURCE_GAMEPAD = 0x00000400 | AINPUT_SOURCE_CLASS_BUTTON, 976 /** touchscreen */ 977 AINPUT_SOURCE_TOUCHSCREEN = 0x00001000 | AINPUT_SOURCE_CLASS_POINTER, 978 /** mouse */ 979 AINPUT_SOURCE_MOUSE = 0x00002000 | AINPUT_SOURCE_CLASS_POINTER, 980 /** stylus */ 981 AINPUT_SOURCE_STYLUS = 0x00004000 | AINPUT_SOURCE_CLASS_POINTER, 982 /** bluetooth stylus */ 983 AINPUT_SOURCE_BLUETOOTH_STYLUS = 0x00008000 | AINPUT_SOURCE_STYLUS, 984 /** trackball */ 985 AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION, 986 /** mouse relative */ 987 AINPUT_SOURCE_MOUSE_RELATIVE = 0x00020000 | AINPUT_SOURCE_CLASS_NAVIGATION, 988 /** touchpad */ 989 AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION, 990 /** navigation */ 991 AINPUT_SOURCE_TOUCH_NAVIGATION = 0x00200000 | AINPUT_SOURCE_CLASS_NONE, 992 /** joystick */ 993 AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK, 994 /** HDMI */ 995 AINPUT_SOURCE_HDMI = 0x02000000 | AINPUT_SOURCE_CLASS_BUTTON, 996 /** sensor */ 997 AINPUT_SOURCE_SENSOR = 0x04000000 | AINPUT_SOURCE_CLASS_NONE, 998 /** rotary encoder */ 999 AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 | AINPUT_SOURCE_CLASS_NONE, 1000 1001 /** any */ 1002 AINPUT_SOURCE_ANY = 0xffffff00, 1003 }; 1004 1005 /** 1006 * Keyboard types. 1007 * 1008 * Refer to the documentation on android.view.InputDevice for more details. 1009 * Note: When adding a new keyboard type here InputDeviceInfo::setKeyboardType needs to be updated. 1010 */ 1011 enum { 1012 /** none */ 1013 AINPUT_KEYBOARD_TYPE_NONE = 0, 1014 /** non alphabetic */ 1015 AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC = 1, 1016 /** alphabetic */ 1017 AINPUT_KEYBOARD_TYPE_ALPHABETIC = 2, 1018 }; 1019 1020 /** 1021 * Constants used to retrieve information about the range of motion for a particular 1022 * coordinate of a motion event. 1023 * 1024 * Refer to the documentation on android.view.InputDevice for more details about input sources 1025 * and their correct interpretation. 1026 * 1027 * @deprecated These constants are deprecated. Use {@link AMOTION_EVENT_AXIS AMOTION_EVENT_AXIS_*} 1028 * constants instead. 1029 */ 1030 enum { 1031 /** x */ 1032 AINPUT_MOTION_RANGE_X = AMOTION_EVENT_AXIS_X, 1033 /** y */ 1034 AINPUT_MOTION_RANGE_Y = AMOTION_EVENT_AXIS_Y, 1035 /** pressure */ 1036 AINPUT_MOTION_RANGE_PRESSURE = AMOTION_EVENT_AXIS_PRESSURE, 1037 /** size */ 1038 AINPUT_MOTION_RANGE_SIZE = AMOTION_EVENT_AXIS_SIZE, 1039 /** touch major */ 1040 AINPUT_MOTION_RANGE_TOUCH_MAJOR = AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1041 /** touch minor */ 1042 AINPUT_MOTION_RANGE_TOUCH_MINOR = AMOTION_EVENT_AXIS_TOUCH_MINOR, 1043 /** tool major */ 1044 AINPUT_MOTION_RANGE_TOOL_MAJOR = AMOTION_EVENT_AXIS_TOOL_MAJOR, 1045 /** tool minor */ 1046 AINPUT_MOTION_RANGE_TOOL_MINOR = AMOTION_EVENT_AXIS_TOOL_MINOR, 1047 /** orientation */ 1048 AINPUT_MOTION_RANGE_ORIENTATION = AMOTION_EVENT_AXIS_ORIENTATION, 1049 }; 1050 1051 1052 /** 1053 * Input event accessors. 1054 * 1055 * Note that most functions can only be used on input events that are of a given type. 1056 * Calling these functions on input events of other types will yield undefined behavior. 1057 */ 1058 1059 /*** Accessors for all input events. ***/ 1060 1061 /** Get the input event type. */ 1062 int32_t AInputEvent_getType(const AInputEvent* event); 1063 1064 /** Get the id for the device that an input event came from. 1065 * 1066 * Input events can be generated by multiple different input devices. 1067 * Use the input device id to obtain information about the input 1068 * device that was responsible for generating a particular event. 1069 * 1070 * An input device id of 0 indicates that the event didn't come from a physical device; 1071 * other numbers are arbitrary and you shouldn't depend on the values. 1072 * Use the provided input device query API to obtain information about input devices. 1073 */ 1074 int32_t AInputEvent_getDeviceId(const AInputEvent* event); 1075 1076 /** Get the input event source. */ 1077 int32_t AInputEvent_getSource(const AInputEvent* event); 1078 1079 /** 1080 * Releases interface objects created by {@link AKeyEvent_fromJava()} 1081 * and {@link AMotionEvent_fromJava()}. 1082 * After returning, the specified {@link AInputEvent}* object becomes invalid and should no longer 1083 * be used. The underlying Java object remains valid and does not change its state. 1084 * 1085 * Available since API level 31. 1086 */ 1087 void AInputEvent_release(const AInputEvent* event) __INTRODUCED_IN(31); 1088 1089 /*** Accessors for key events only. ***/ 1090 1091 /** Get the key event action. */ 1092 int32_t AKeyEvent_getAction(const AInputEvent* key_event); 1093 1094 /** Get the key event flags. */ 1095 int32_t AKeyEvent_getFlags(const AInputEvent* key_event); 1096 1097 /** 1098 * Get the key code of the key event. 1099 * This is the physical key that was pressed, not the Unicode character. 1100 */ 1101 int32_t AKeyEvent_getKeyCode(const AInputEvent* key_event); 1102 1103 /** 1104 * Get the hardware key id of this key event. 1105 * These values are not reliable and vary from device to device. 1106 */ 1107 int32_t AKeyEvent_getScanCode(const AInputEvent* key_event); 1108 1109 /** Get the meta key state. */ 1110 int32_t AKeyEvent_getMetaState(const AInputEvent* key_event); 1111 1112 /** 1113 * Get the repeat count of the event. 1114 * For both key up an key down events, this is the number of times the key has 1115 * repeated with the first down starting at 0 and counting up from there. For 1116 * multiple key events, this is the number of down/up pairs that have occurred. 1117 */ 1118 int32_t AKeyEvent_getRepeatCount(const AInputEvent* key_event); 1119 1120 /** 1121 * Get the time of the most recent key down event, in the 1122 * java.lang.System.nanoTime() time base. If this is a down event, 1123 * this will be the same as eventTime. 1124 * Note that when chording keys, this value is the down time of the most recently 1125 * pressed key, which may not be the same physical key of this event. 1126 */ 1127 int64_t AKeyEvent_getDownTime(const AInputEvent* key_event); 1128 1129 /** 1130 * Get the time this event occurred, in the 1131 * java.lang.System.nanoTime() time base. 1132 */ 1133 int64_t AKeyEvent_getEventTime(const AInputEvent* key_event); 1134 1135 /** 1136 * Creates a native {@link AInputEvent}* object that is a copy of the specified Java 1137 * android.view.KeyEvent. The result may be used with generic and KeyEvent-specific AInputEvent_* 1138 * functions. The object returned by this function must be disposed using 1139 * {@link AInputEvent_release()}. 1140 * 1141 * Available since API level 31. 1142 */ 1143 const AInputEvent* AKeyEvent_fromJava(JNIEnv* env, jobject keyEvent) __INTRODUCED_IN(31); 1144 1145 /*** Accessors for motion events only. ***/ 1146 1147 /** Get the combined motion event action code and pointer index. */ 1148 int32_t AMotionEvent_getAction(const AInputEvent* motion_event); 1149 1150 /** Get the motion event flags. */ 1151 int32_t AMotionEvent_getFlags(const AInputEvent* motion_event); 1152 1153 /** 1154 * Get the state of any meta / modifier keys that were in effect when the 1155 * event was generated. 1156 */ 1157 int32_t AMotionEvent_getMetaState(const AInputEvent* motion_event); 1158 1159 /** Get the button state of all buttons that are pressed. */ 1160 int32_t AMotionEvent_getButtonState(const AInputEvent* motion_event); 1161 1162 /** 1163 * Get a bitfield indicating which edges, if any, were touched by this motion event. 1164 * For touch events, clients can use this to determine if the user's finger was 1165 * touching the edge of the display. 1166 */ 1167 int32_t AMotionEvent_getEdgeFlags(const AInputEvent* motion_event); 1168 1169 /** 1170 * Get the time when the user originally pressed down to start a stream of 1171 * position events, in the java.lang.System.nanoTime() time base. 1172 */ 1173 int64_t AMotionEvent_getDownTime(const AInputEvent* motion_event); 1174 1175 /** 1176 * Get the time when this specific event was generated, 1177 * in the java.lang.System.nanoTime() time base. 1178 */ 1179 int64_t AMotionEvent_getEventTime(const AInputEvent* motion_event); 1180 1181 /** 1182 * Get the X coordinate offset. 1183 * For touch events on the screen, this is the delta that was added to the raw 1184 * screen coordinates to adjust for the absolute position of the containing windows 1185 * and views. 1186 */ 1187 float AMotionEvent_getXOffset(const AInputEvent* motion_event); 1188 1189 /** 1190 * Get the Y coordinate offset. 1191 * For touch events on the screen, this is the delta that was added to the raw 1192 * screen coordinates to adjust for the absolute position of the containing windows 1193 * and views. 1194 */ 1195 float AMotionEvent_getYOffset(const AInputEvent* motion_event); 1196 1197 /** 1198 * Get the precision of the X coordinates being reported. 1199 * You can multiply this number with an X coordinate sample to find the 1200 * actual hardware value of the X coordinate. 1201 */ 1202 float AMotionEvent_getXPrecision(const AInputEvent* motion_event); 1203 1204 /** 1205 * Get the precision of the Y coordinates being reported. 1206 * You can multiply this number with a Y coordinate sample to find the 1207 * actual hardware value of the Y coordinate. 1208 */ 1209 float AMotionEvent_getYPrecision(const AInputEvent* motion_event); 1210 1211 /** 1212 * Get the number of pointers of data contained in this event. 1213 * Always >= 1. 1214 */ 1215 size_t AMotionEvent_getPointerCount(const AInputEvent* motion_event); 1216 1217 /** 1218 * Get the pointer identifier associated with a particular pointer 1219 * data index in this event. The identifier tells you the actual pointer 1220 * number associated with the data, accounting for individual pointers 1221 * going up and down since the start of the current gesture. 1222 */ 1223 int32_t AMotionEvent_getPointerId(const AInputEvent* motion_event, size_t pointer_index); 1224 1225 /** 1226 * Get the tool type of a pointer for the given pointer index. 1227 * The tool type indicates the type of tool used to make contact such as a 1228 * finger or stylus, if known. 1229 */ 1230 int32_t AMotionEvent_getToolType(const AInputEvent* motion_event, size_t pointer_index); 1231 1232 /** 1233 * Get the original raw X coordinate of this event. 1234 * For touch events on the screen, this is the original location of the event 1235 * on the screen, before it had been adjusted for the containing window 1236 * and views. 1237 */ 1238 float AMotionEvent_getRawX(const AInputEvent* motion_event, size_t pointer_index); 1239 1240 /** 1241 * Get the original raw X coordinate of this event. 1242 * For touch events on the screen, this is the original location of the event 1243 * on the screen, before it had been adjusted for the containing window 1244 * and views. 1245 */ 1246 float AMotionEvent_getRawY(const AInputEvent* motion_event, size_t pointer_index); 1247 1248 /** 1249 * Get the current X coordinate of this event for the given pointer index. 1250 * Whole numbers are pixels; the value may have a fraction for input devices 1251 * that are sub-pixel precise. 1252 */ 1253 float AMotionEvent_getX(const AInputEvent* motion_event, size_t pointer_index); 1254 1255 /** 1256 * Get the current Y coordinate of this event for the given pointer index. 1257 * Whole numbers are pixels; the value may have a fraction for input devices 1258 * that are sub-pixel precise. 1259 */ 1260 float AMotionEvent_getY(const AInputEvent* motion_event, size_t pointer_index); 1261 1262 /** 1263 * Get the current pressure of this event for the given pointer index. 1264 * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure), 1265 * although values higher than 1 may be generated depending on the calibration of 1266 * the input device. 1267 */ 1268 float AMotionEvent_getPressure(const AInputEvent* motion_event, size_t pointer_index); 1269 1270 /** 1271 * Get the current scaled value of the approximate size for the given pointer index. 1272 * This represents some approximation of the area of the screen being 1273 * pressed; the actual value in pixels corresponding to the 1274 * touch is normalized with the device specific range of values 1275 * and scaled to a value between 0 and 1. The value of size can be used to 1276 * determine fat touch events. 1277 */ 1278 float AMotionEvent_getSize(const AInputEvent* motion_event, size_t pointer_index); 1279 1280 /** 1281 * Get the current length of the major axis of an ellipse that describes the touch area 1282 * at the point of contact for the given pointer index. 1283 */ 1284 float AMotionEvent_getTouchMajor(const AInputEvent* motion_event, size_t pointer_index); 1285 1286 /** 1287 * Get the current length of the minor axis of an ellipse that describes the touch area 1288 * at the point of contact for the given pointer index. 1289 */ 1290 float AMotionEvent_getTouchMinor(const AInputEvent* motion_event, size_t pointer_index); 1291 1292 /** 1293 * Get the current length of the major axis of an ellipse that describes the size 1294 * of the approaching tool for the given pointer index. 1295 * The tool area represents the estimated size of the finger or pen that is 1296 * touching the device independent of its actual touch area at the point of contact. 1297 */ 1298 float AMotionEvent_getToolMajor(const AInputEvent* motion_event, size_t pointer_index); 1299 1300 /** 1301 * Get the current length of the minor axis of an ellipse that describes the size 1302 * of the approaching tool for the given pointer index. 1303 * The tool area represents the estimated size of the finger or pen that is 1304 * touching the device independent of its actual touch area at the point of contact. 1305 */ 1306 float AMotionEvent_getToolMinor(const AInputEvent* motion_event, size_t pointer_index); 1307 1308 /** 1309 * Get the current orientation of the touch area and tool area in radians clockwise from 1310 * vertical for the given pointer index. 1311 * An angle of 0 degrees indicates that the major axis of contact is oriented 1312 * upwards, is perfectly circular or is of unknown orientation. A positive angle 1313 * indicates that the major axis of contact is oriented to the right. A negative angle 1314 * indicates that the major axis of contact is oriented to the left. 1315 * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians 1316 * (finger pointing fully right). 1317 */ 1318 float AMotionEvent_getOrientation(const AInputEvent* motion_event, size_t pointer_index); 1319 1320 /** Get the value of the request axis for the given pointer index. */ 1321 float AMotionEvent_getAxisValue(const AInputEvent* motion_event, 1322 int32_t axis, size_t pointer_index); 1323 1324 /** 1325 * Get the number of historical points in this event. These are movements that 1326 * have occurred between this event and the previous event. This only applies 1327 * to #AMOTION_EVENT_ACTION_MOVE events -- all other actions will have a size of 0. 1328 * Historical samples are indexed from oldest to newest. 1329 */ 1330 size_t AMotionEvent_getHistorySize(const AInputEvent* motion_event); 1331 1332 /** 1333 * Get the time that a historical movement occurred between this event and 1334 * the previous event, in the java.lang.System.nanoTime() time base. 1335 */ 1336 int64_t AMotionEvent_getHistoricalEventTime(const AInputEvent* motion_event, 1337 size_t history_index); 1338 1339 /** 1340 * Get the historical raw X coordinate of this event for the given pointer index that 1341 * occurred between this event and the previous motion event. 1342 * For touch events on the screen, this is the original location of the event 1343 * on the screen, before it had been adjusted for the containing window 1344 * and views. 1345 * Whole numbers are pixels; the value may have a fraction for input devices 1346 * that are sub-pixel precise. 1347 */ 1348 float AMotionEvent_getHistoricalRawX(const AInputEvent* motion_event, size_t pointer_index, 1349 size_t history_index); 1350 1351 /** 1352 * Get the historical raw Y coordinate of this event for the given pointer index that 1353 * occurred between this event and the previous motion event. 1354 * For touch events on the screen, this is the original location of the event 1355 * on the screen, before it had been adjusted for the containing window 1356 * and views. 1357 * Whole numbers are pixels; the value may have a fraction for input devices 1358 * that are sub-pixel precise. 1359 */ 1360 float AMotionEvent_getHistoricalRawY(const AInputEvent* motion_event, size_t pointer_index, 1361 size_t history_index); 1362 1363 /** 1364 * Get the historical X coordinate of this event for the given pointer index that 1365 * occurred between this event and the previous motion event. 1366 * Whole numbers are pixels; the value may have a fraction for input devices 1367 * that are sub-pixel precise. 1368 */ 1369 float AMotionEvent_getHistoricalX(const AInputEvent* motion_event, size_t pointer_index, 1370 size_t history_index); 1371 1372 /** 1373 * Get the historical Y coordinate of this event for the given pointer index that 1374 * occurred between this event and the previous motion event. 1375 * Whole numbers are pixels; the value may have a fraction for input devices 1376 * that are sub-pixel precise. 1377 */ 1378 float AMotionEvent_getHistoricalY(const AInputEvent* motion_event, size_t pointer_index, 1379 size_t history_index); 1380 1381 /** 1382 * Get the historical pressure of this event for the given pointer index that 1383 * occurred between this event and the previous motion event. 1384 * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure), 1385 * although values higher than 1 may be generated depending on the calibration of 1386 * the input device. 1387 */ 1388 float AMotionEvent_getHistoricalPressure(const AInputEvent* motion_event, size_t pointer_index, 1389 size_t history_index); 1390 1391 /** 1392 * Get the current scaled value of the approximate size for the given pointer index that 1393 * occurred between this event and the previous motion event. 1394 * This represents some approximation of the area of the screen being 1395 * pressed; the actual value in pixels corresponding to the 1396 * touch is normalized with the device specific range of values 1397 * and scaled to a value between 0 and 1. The value of size can be used to 1398 * determine fat touch events. 1399 */ 1400 float AMotionEvent_getHistoricalSize(const AInputEvent* motion_event, size_t pointer_index, 1401 size_t history_index); 1402 1403 /** 1404 * Get the historical length of the major axis of an ellipse that describes the touch area 1405 * at the point of contact for the given pointer index that 1406 * occurred between this event and the previous motion event. 1407 */ 1408 float AMotionEvent_getHistoricalTouchMajor(const AInputEvent* motion_event, size_t pointer_index, 1409 size_t history_index); 1410 1411 /** 1412 * Get the historical length of the minor axis of an ellipse that describes the touch area 1413 * at the point of contact for the given pointer index that 1414 * occurred between this event and the previous motion event. 1415 */ 1416 float AMotionEvent_getHistoricalTouchMinor(const AInputEvent* motion_event, size_t pointer_index, 1417 size_t history_index); 1418 1419 /** 1420 * Get the historical length of the major axis of an ellipse that describes the size 1421 * of the approaching tool for the given pointer index that 1422 * occurred between this event and the previous motion event. 1423 * The tool area represents the estimated size of the finger or pen that is 1424 * touching the device independent of its actual touch area at the point of contact. 1425 */ 1426 float AMotionEvent_getHistoricalToolMajor(const AInputEvent* motion_event, size_t pointer_index, 1427 size_t history_index); 1428 1429 /** 1430 * Get the historical length of the minor axis of an ellipse that describes the size 1431 * of the approaching tool for the given pointer index that 1432 * occurred between this event and the previous motion event. 1433 * The tool area represents the estimated size of the finger or pen that is 1434 * touching the device independent of its actual touch area at the point of contact. 1435 */ 1436 float AMotionEvent_getHistoricalToolMinor(const AInputEvent* motion_event, size_t pointer_index, 1437 size_t history_index); 1438 1439 /** 1440 * Get the historical orientation of the touch area and tool area in radians clockwise from 1441 * vertical for the given pointer index that 1442 * occurred between this event and the previous motion event. 1443 * An angle of 0 degrees indicates that the major axis of contact is oriented 1444 * upwards, is perfectly circular or is of unknown orientation. A positive angle 1445 * indicates that the major axis of contact is oriented to the right. A negative angle 1446 * indicates that the major axis of contact is oriented to the left. 1447 * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians 1448 * (finger pointing fully right). 1449 */ 1450 float AMotionEvent_getHistoricalOrientation(const AInputEvent* motion_event, size_t pointer_index, 1451 size_t history_index); 1452 1453 /** 1454 * Get the historical value of the request axis for the given pointer index 1455 * that occurred between this event and the previous motion event. 1456 */ 1457 float AMotionEvent_getHistoricalAxisValue(const AInputEvent* motion_event, 1458 int32_t axis, size_t pointer_index, size_t history_index); 1459 1460 /** 1461 * Get the action button for the motion event. Returns a valid action button when the 1462 * event is associated with a button press or button release action. For other actions 1463 * the return value is undefined. 1464 * 1465 * @see #AMOTION_EVENT_BUTTON_PRIMARY 1466 * @see #AMOTION_EVENT_BUTTON_SECONDARY 1467 * @see #AMOTION_EVENT_BUTTON_TERTIARY 1468 * @see #AMOTION_EVENT_BUTTON_BACK 1469 * @see #AMOTION_EVENT_BUTTON_FORWARD 1470 * @see #AMOTION_EVENT_BUTTON_STYLUS_PRIMARY 1471 * @see #AMOTION_EVENT_BUTTON_STYLUS_SECONDARY 1472 */ 1473 int32_t AMotionEvent_getActionButton(const AInputEvent* motion_event) 1474 __INTRODUCED_IN(__ANDROID_API_T__); 1475 1476 /** 1477 * Returns the classification for the current gesture. 1478 * The classification may change as more events become available for the same gesture. 1479 * 1480 * @see #AMOTION_EVENT_CLASSIFICATION_NONE 1481 * @see #AMOTION_EVENT_CLASSIFICATION_AMBIGUOUS_GESTURE 1482 * @see #AMOTION_EVENT_CLASSIFICATION_DEEP_PRESS 1483 */ 1484 int32_t AMotionEvent_getClassification(const AInputEvent* motion_event) 1485 __INTRODUCED_IN(__ANDROID_API_T__); 1486 1487 /** 1488 * Creates a native {@link AInputEvent}* object that is a copy of the specified Java 1489 * android.view.MotionEvent. The result may be used with generic and MotionEvent-specific 1490 * AInputEvent_* functions. The object returned by this function must be disposed using 1491 * {@link AInputEvent_release()}. 1492 * 1493 * Available since API level 31. 1494 */ 1495 const AInputEvent* AMotionEvent_fromJava(JNIEnv* env, jobject motionEvent) __INTRODUCED_IN(31); 1496 1497 struct AInputQueue; 1498 /** 1499 * Input queue 1500 * 1501 * An input queue is the facility through which you retrieve input 1502 * events. 1503 */ 1504 typedef struct AInputQueue AInputQueue; 1505 1506 /** 1507 * Add this input queue to a looper for processing. See 1508 * {@link ALooper_addFd()} for information on the ident, callback, and data params. 1509 */ 1510 void AInputQueue_attachLooper(AInputQueue* queue, ALooper* looper, 1511 int ident, ALooper_callbackFunc callback, void* data); 1512 1513 /** 1514 * Remove the input queue from the looper it is currently attached to. 1515 */ 1516 void AInputQueue_detachLooper(AInputQueue* queue); 1517 1518 /** 1519 * Returns true if there are one or more events available in the 1520 * input queue. Returns 1 if the queue has events; 0 if 1521 * it does not have events; and a negative value if there is an error. 1522 */ 1523 int32_t AInputQueue_hasEvents(AInputQueue* queue); 1524 1525 /** 1526 * Returns the next available event from the queue. Returns a negative 1527 * value if no events are available or an error has occurred. 1528 */ 1529 int32_t AInputQueue_getEvent(AInputQueue* queue, AInputEvent** outEvent); 1530 1531 /** 1532 * Sends the key for standard pre-dispatching -- that is, possibly deliver 1533 * it to the current IME to be consumed before the app. Returns 0 if it 1534 * was not pre-dispatched, meaning you can process it right now. If non-zero 1535 * is returned, you must abandon the current event processing and allow the 1536 * event to appear again in the event queue (if it does not get consumed during 1537 * pre-dispatching). 1538 */ 1539 int32_t AInputQueue_preDispatchEvent(AInputQueue* queue, AInputEvent* event); 1540 1541 /** 1542 * Report that dispatching has finished with the given event. 1543 * This must be called after receiving an event with {@link AInputQueue_getEvent()}. 1544 */ 1545 void AInputQueue_finishEvent(AInputQueue* queue, AInputEvent* event, int handled); 1546 1547 /** 1548 * Returns the {@link AInputQueue}* object associated with the supplied Java InputQueue 1549 * object. The returned native object holds a weak reference to the Java object, 1550 * and is only valid as long as the Java object has not yet been disposed. You 1551 * should ensure that there is a strong reference to the Java object and that it 1552 * has not been disposed before using the returned object. 1553 * 1554 * Available since API level 33. 1555 */ 1556 AInputQueue* AInputQueue_fromJava(JNIEnv* env, jobject inputQueue) __INTRODUCED_IN(33); 1557 1558 #ifdef __cplusplus 1559 } 1560 #endif 1561 1562 #endif // _ANDROID_INPUT_H 1563 1564 /** @} */ 1565