include/android/input.h

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