2 * Copyright (C) 2010 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #ifndef _UI_INPUT_READER_H
18 #define _UI_INPUT_READER_H
21 #include "PointerControllerInterface.h"
22 #include "InputListener.h"
24 #include <input/Input.h>
25 #include <input/VelocityControl.h>
26 #include <input/VelocityTracker.h>
27 #include <ui/DisplayInfo.h>
28 #include <utils/KeyedVector.h>
29 #include <utils/threads.h>
30 #include <utils/Timers.h>
31 #include <utils/RefBase.h>
32 #include <utils/String8.h>
33 #include <utils/BitSet.h>
38 // Maximum supported size of a vibration pattern.
39 // Must be at least 2.
40 #define MAX_VIBRATE_PATTERN_SIZE 100
42 // Maximum allowable delay value in a vibration pattern before
43 // which the delay will be truncated.
44 #define MAX_VIBRATE_PATTERN_DELAY_NSECS (1000000 * 1000000000LL)
52 * Describes how coordinates are mapped on a physical display.
53 * See com.android.server.display.DisplayViewport.
55 struct DisplayViewport {
56 int32_t displayId; // -1 if invalid
61 int32_t logicalBottom;
64 int32_t physicalRight;
65 int32_t physicalBottom;
70 displayId(ADISPLAY_ID_NONE), orientation(DISPLAY_ORIENTATION_0),
71 logicalLeft(0), logicalTop(0), logicalRight(0), logicalBottom(0),
72 physicalLeft(0), physicalTop(0), physicalRight(0), physicalBottom(0),
73 deviceWidth(0), deviceHeight(0) {
76 bool operator==(const DisplayViewport& other) const {
77 return displayId == other.displayId
78 && orientation == other.orientation
79 && logicalLeft == other.logicalLeft
80 && logicalTop == other.logicalTop
81 && logicalRight == other.logicalRight
82 && logicalBottom == other.logicalBottom
83 && physicalLeft == other.physicalLeft
84 && physicalTop == other.physicalTop
85 && physicalRight == other.physicalRight
86 && physicalBottom == other.physicalBottom
87 && deviceWidth == other.deviceWidth
88 && deviceHeight == other.deviceHeight;
91 bool operator!=(const DisplayViewport& other) const {
92 return !(*this == other);
95 inline bool isValid() const {
96 return displayId >= 0;
99 void setNonDisplayViewport(int32_t width, int32_t height) {
100 displayId = ADISPLAY_ID_NONE;
101 orientation = DISPLAY_ORIENTATION_0;
104 logicalRight = width;
105 logicalBottom = height;
108 physicalRight = width;
109 physicalBottom = height;
111 deviceHeight = height;
116 * Input reader configuration.
118 * Specifies various options that modify the behavior of the input reader.
120 struct InputReaderConfiguration {
121 // Describes changes that have occurred.
123 // The pointer speed changed.
124 CHANGE_POINTER_SPEED = 1 << 0,
126 // The pointer gesture control changed.
127 CHANGE_POINTER_GESTURE_ENABLEMENT = 1 << 1,
129 // The display size or orientation changed.
130 CHANGE_DISPLAY_INFO = 1 << 2,
132 // The visible touches option changed.
133 CHANGE_SHOW_TOUCHES = 1 << 3,
135 // The keyboard layouts must be reloaded.
136 CHANGE_KEYBOARD_LAYOUTS = 1 << 4,
138 // The device name alias supplied by the may have changed for some devices.
139 CHANGE_DEVICE_ALIAS = 1 << 5,
141 // The location calibration matrix changed.
142 CHANGE_TOUCH_AFFINE_TRANSFORMATION = 1 << 6,
144 // The presence of an external stylus has changed.
145 CHANGE_EXTERNAL_STYLUS_PRESENCE = 1 << 7,
147 // All devices must be reopened.
148 CHANGE_MUST_REOPEN = 1 << 31,
151 // Gets the amount of time to disable virtual keys after the screen is touched
152 // in order to filter out accidental virtual key presses due to swiping gestures
153 // or taps near the edge of the display. May be 0 to disable the feature.
154 nsecs_t virtualKeyQuietTime;
156 // The excluded device names for the platform.
157 // Devices with these names will be ignored.
158 Vector<String8> excludedDeviceNames;
160 // Velocity control parameters for mouse pointer movements.
161 VelocityControlParameters pointerVelocityControlParameters;
163 // Velocity control parameters for mouse wheel movements.
164 VelocityControlParameters wheelVelocityControlParameters;
166 // True if pointer gestures are enabled.
167 bool pointerGesturesEnabled;
169 // Quiet time between certain pointer gesture transitions.
170 // Time to allow for all fingers or buttons to settle into a stable state before
171 // starting a new gesture.
172 nsecs_t pointerGestureQuietInterval;
174 // The minimum speed that a pointer must travel for us to consider switching the active
175 // touch pointer to it during a drag. This threshold is set to avoid switching due
176 // to noise from a finger resting on the touch pad (perhaps just pressing it down).
177 float pointerGestureDragMinSwitchSpeed; // in pixels per second
179 // Tap gesture delay time.
180 // The time between down and up must be less than this to be considered a tap.
181 nsecs_t pointerGestureTapInterval;
183 // Tap drag gesture delay time.
184 // The time between the previous tap's up and the next down must be less than
185 // this to be considered a drag. Otherwise, the previous tap is finished and a
188 // Note that the previous tap will be held down for this entire duration so this
189 // interval must be shorter than the long press timeout.
190 nsecs_t pointerGestureTapDragInterval;
192 // The distance in pixels that the pointer is allowed to move from initial down
193 // to up and still be called a tap.
194 float pointerGestureTapSlop; // in pixels
196 // Time after the first touch points go down to settle on an initial centroid.
197 // This is intended to be enough time to handle cases where the user puts down two
198 // fingers at almost but not quite exactly the same time.
199 nsecs_t pointerGestureMultitouchSettleInterval;
201 // The transition from PRESS to SWIPE or FREEFORM gesture mode is made when
202 // at least two pointers have moved at least this far from their starting place.
203 float pointerGestureMultitouchMinDistance; // in pixels
205 // The transition from PRESS to SWIPE gesture mode can only occur when the
206 // cosine of the angle between the two vectors is greater than or equal to than this value
207 // which indicates that the vectors are oriented in the same direction.
208 // When the vectors are oriented in the exactly same direction, the cosine is 1.0.
209 // (In exactly opposite directions, the cosine is -1.0.)
210 float pointerGestureSwipeTransitionAngleCosine;
212 // The transition from PRESS to SWIPE gesture mode can only occur when the
213 // fingers are no more than this far apart relative to the diagonal size of
214 // the touch pad. For example, a ratio of 0.5 means that the fingers must be
215 // no more than half the diagonal size of the touch pad apart.
216 float pointerGestureSwipeMaxWidthRatio;
218 // The gesture movement speed factor relative to the size of the display.
219 // Movement speed applies when the fingers are moving in the same direction.
220 // Without acceleration, a full swipe of the touch pad diagonal in movement mode
221 // will cover this portion of the display diagonal.
222 float pointerGestureMovementSpeedRatio;
224 // The gesture zoom speed factor relative to the size of the display.
225 // Zoom speed applies when the fingers are mostly moving relative to each other
226 // to execute a scale gesture or similar.
227 // Without acceleration, a full swipe of the touch pad diagonal in zoom mode
228 // will cover this portion of the display diagonal.
229 float pointerGestureZoomSpeedRatio;
231 // True to show the location of touches on the touch screen as spots.
234 InputReaderConfiguration() :
235 virtualKeyQuietTime(0),
236 pointerVelocityControlParameters(1.0f, 500.0f, 3000.0f, 3.0f),
237 wheelVelocityControlParameters(1.0f, 15.0f, 50.0f, 4.0f),
238 pointerGesturesEnabled(true),
239 pointerGestureQuietInterval(100 * 1000000LL), // 100 ms
240 pointerGestureDragMinSwitchSpeed(50), // 50 pixels per second
241 pointerGestureTapInterval(150 * 1000000LL), // 150 ms
242 pointerGestureTapDragInterval(150 * 1000000LL), // 150 ms
243 pointerGestureTapSlop(10.0f), // 10 pixels
244 pointerGestureMultitouchSettleInterval(100 * 1000000LL), // 100 ms
245 pointerGestureMultitouchMinDistance(15), // 15 pixels
246 pointerGestureSwipeTransitionAngleCosine(0.2588f), // cosine of 75 degrees
247 pointerGestureSwipeMaxWidthRatio(0.25f),
248 pointerGestureMovementSpeedRatio(0.8f),
249 pointerGestureZoomSpeedRatio(0.3f),
250 showTouches(false) { }
252 bool getDisplayInfo(bool external, DisplayViewport* outViewport) const;
253 void setDisplayInfo(bool external, const DisplayViewport& viewport);
256 DisplayViewport mInternalDisplay;
257 DisplayViewport mExternalDisplay;
261 struct TouchAffineTransformation {
269 TouchAffineTransformation() :
270 x_scale(1.0f), x_ymix(0.0f), x_offset(0.0f),
271 y_xmix(0.0f), y_scale(1.0f), y_offset(0.0f) {
274 TouchAffineTransformation(float xscale, float xymix, float xoffset,
275 float yxmix, float yscale, float yoffset) :
276 x_scale(xscale), x_ymix(xymix), x_offset(xoffset),
277 y_xmix(yxmix), y_scale(yscale), y_offset(yoffset) {
280 void applyTo(float& x, float& y) const;
285 * Input reader policy interface.
287 * The input reader policy is used by the input reader to interact with the Window Manager
288 * and other system components.
290 * The actual implementation is partially supported by callbacks into the DVM
291 * via JNI. This interface is also mocked in the unit tests.
293 * These methods must NOT re-enter the input reader since they may be called while
294 * holding the input reader lock.
296 class InputReaderPolicyInterface : public virtual RefBase {
298 InputReaderPolicyInterface() { }
299 virtual ~InputReaderPolicyInterface() { }
302 /* Gets the input reader configuration. */
303 virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) = 0;
305 /* Gets a pointer controller associated with the specified cursor device (ie. a mouse). */
306 virtual sp<PointerControllerInterface> obtainPointerController(int32_t deviceId) = 0;
308 /* Notifies the input reader policy that some input devices have changed
309 * and provides information about all current input devices.
311 virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) = 0;
313 /* Gets the keyboard layout for a particular input device. */
314 virtual sp<KeyCharacterMap> getKeyboardLayoutOverlay(
315 const InputDeviceIdentifier& identifier) = 0;
317 /* Gets a user-supplied alias for a particular input device, or an empty string if none. */
318 virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) = 0;
320 /* Gets the affine calibration associated with the specified device. */
321 virtual TouchAffineTransformation getTouchAffineTransformation(
322 const String8& inputDeviceDescriptor, int32_t surfaceRotation) = 0;
326 /* Processes raw input events and sends cooked event data to an input listener. */
327 class InputReaderInterface : public virtual RefBase {
329 InputReaderInterface() { }
330 virtual ~InputReaderInterface() { }
333 /* Dumps the state of the input reader.
335 * This method may be called on any thread (usually by the input manager). */
336 virtual void dump(String8& dump) = 0;
338 /* Called by the heatbeat to ensures that the reader has not deadlocked. */
339 virtual void monitor() = 0;
341 /* Runs a single iteration of the processing loop.
342 * Nominally reads and processes one incoming message from the EventHub.
344 * This method should be called on the input reader thread.
346 virtual void loopOnce() = 0;
348 /* Gets information about all input devices.
350 * This method may be called on any thread (usually by the input manager).
352 virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices) = 0;
354 /* Query current input state. */
355 virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
356 int32_t scanCode) = 0;
357 virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
358 int32_t keyCode) = 0;
359 virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
362 /* Determine whether physical keys exist for the given framework-domain key codes. */
363 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
364 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0;
366 /* Requests that a reconfiguration of all input devices.
367 * The changes flag is a bitfield that indicates what has changed and whether
368 * the input devices must all be reopened. */
369 virtual void requestRefreshConfiguration(uint32_t changes) = 0;
371 /* Controls the vibrator of a particular input device. */
372 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
373 ssize_t repeat, int32_t token) = 0;
374 virtual void cancelVibrate(int32_t deviceId, int32_t token) = 0;
378 /* Time the stylus event was received. */
380 /* Pressure as reported by the stylus, normalized to the range [0, 1.0]. */
382 /* The state of the stylus buttons as a bitfield (e.g. AMOTION_EVENT_BUTTON_SECONDARY). */
384 /* Which tool type the stylus is currently using (e.g. AMOTION_EVENT_TOOL_TYPE_ERASER). */
387 void copyFrom(const StylusState& other) {
389 pressure = other.pressure;
390 buttons = other.buttons;
391 toolType = other.toolType;
398 toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
403 /* Internal interface used by individual input devices to access global input device state
404 * and parameters maintained by the input reader.
406 class InputReaderContext {
408 InputReaderContext() { }
409 virtual ~InputReaderContext() { }
411 virtual void updateGlobalMetaState() = 0;
412 virtual int32_t getGlobalMetaState() = 0;
414 virtual void disableVirtualKeysUntil(nsecs_t time) = 0;
415 virtual bool shouldDropVirtualKey(nsecs_t now,
416 InputDevice* device, int32_t keyCode, int32_t scanCode) = 0;
418 virtual void fadePointer() = 0;
420 virtual void requestTimeoutAtTime(nsecs_t when) = 0;
421 virtual int32_t bumpGeneration() = 0;
423 virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices) = 0;
424 virtual void dispatchExternalStylusState(const StylusState& outState) = 0;
426 virtual InputReaderPolicyInterface* getPolicy() = 0;
427 virtual InputListenerInterface* getListener() = 0;
428 virtual EventHubInterface* getEventHub() = 0;
432 /* The input reader reads raw event data from the event hub and processes it into input events
433 * that it sends to the input listener. Some functions of the input reader, such as early
434 * event filtering in low power states, are controlled by a separate policy object.
436 * The InputReader owns a collection of InputMappers. Most of the work it does happens
437 * on the input reader thread but the InputReader can receive queries from other system
438 * components running on arbitrary threads. To keep things manageable, the InputReader
439 * uses a single Mutex to guard its state. The Mutex may be held while calling into the
440 * EventHub or the InputReaderPolicy but it is never held while calling into the
443 class InputReader : public InputReaderInterface {
445 InputReader(const sp<EventHubInterface>& eventHub,
446 const sp<InputReaderPolicyInterface>& policy,
447 const sp<InputListenerInterface>& listener);
448 virtual ~InputReader();
450 virtual void dump(String8& dump);
451 virtual void monitor();
453 virtual void loopOnce();
455 virtual void getInputDevices(Vector<InputDeviceInfo>& outInputDevices);
457 virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask,
459 virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask,
461 virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask,
464 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,
465 size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags);
467 virtual void requestRefreshConfiguration(uint32_t changes);
469 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
470 ssize_t repeat, int32_t token);
471 virtual void cancelVibrate(int32_t deviceId, int32_t token);
474 // These members are protected so they can be instrumented by test cases.
475 virtual InputDevice* createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
476 const InputDeviceIdentifier& identifier, uint32_t classes);
478 class ContextImpl : public InputReaderContext {
479 InputReader* mReader;
482 ContextImpl(InputReader* reader);
484 virtual void updateGlobalMetaState();
485 virtual int32_t getGlobalMetaState();
486 virtual void disableVirtualKeysUntil(nsecs_t time);
487 virtual bool shouldDropVirtualKey(nsecs_t now,
488 InputDevice* device, int32_t keyCode, int32_t scanCode);
489 virtual void fadePointer();
490 virtual void requestTimeoutAtTime(nsecs_t when);
491 virtual int32_t bumpGeneration();
492 virtual void getExternalStylusDevices(Vector<InputDeviceInfo>& outDevices);
493 virtual void dispatchExternalStylusState(const StylusState& outState);
494 virtual InputReaderPolicyInterface* getPolicy();
495 virtual InputListenerInterface* getListener();
496 virtual EventHubInterface* getEventHub();
499 friend class ContextImpl;
504 Condition mReaderIsAliveCondition;
506 sp<EventHubInterface> mEventHub;
507 sp<InputReaderPolicyInterface> mPolicy;
508 sp<QueuedInputListener> mQueuedListener;
510 InputReaderConfiguration mConfig;
513 static const int EVENT_BUFFER_SIZE = 256;
514 RawEvent mEventBuffer[EVENT_BUFFER_SIZE];
516 KeyedVector<int32_t, InputDevice*> mDevices;
518 // low-level input event decoding and device management
519 void processEventsLocked(const RawEvent* rawEvents, size_t count);
521 void addDeviceLocked(nsecs_t when, int32_t deviceId);
522 void removeDeviceLocked(nsecs_t when, int32_t deviceId);
523 void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);
524 void timeoutExpiredLocked(nsecs_t when);
526 void handleConfigurationChangedLocked(nsecs_t when);
528 int32_t mGlobalMetaState;
529 void updateGlobalMetaStateLocked();
530 int32_t getGlobalMetaStateLocked();
532 void notifyExternalStylusPresenceChanged();
533 void getExternalStylusDevicesLocked(Vector<InputDeviceInfo>& outDevices);
534 void dispatchExternalStylusState(const StylusState& state);
536 void fadePointerLocked();
539 int32_t bumpGenerationLocked();
541 void getInputDevicesLocked(Vector<InputDeviceInfo>& outInputDevices);
543 nsecs_t mDisableVirtualKeysTimeout;
544 void disableVirtualKeysUntilLocked(nsecs_t time);
545 bool shouldDropVirtualKeyLocked(nsecs_t now,
546 InputDevice* device, int32_t keyCode, int32_t scanCode);
548 nsecs_t mNextTimeout;
549 void requestTimeoutAtTimeLocked(nsecs_t when);
551 uint32_t mConfigurationChangesToRefresh;
552 void refreshConfigurationLocked(uint32_t changes);
555 typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
556 int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
557 GetStateFunc getStateFunc);
558 bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
559 const int32_t* keyCodes, uint8_t* outFlags);
563 /* Reads raw events from the event hub and processes them, endlessly. */
564 class InputReaderThread : public Thread {
566 InputReaderThread(const sp<InputReaderInterface>& reader);
567 virtual ~InputReaderThread();
570 sp<InputReaderInterface> mReader;
572 virtual bool threadLoop();
576 /* Represents the state of a single input device. */
579 InputDevice(InputReaderContext* context, int32_t id, int32_t generation, int32_t
580 controllerNumber, const InputDeviceIdentifier& identifier, uint32_t classes);
583 inline InputReaderContext* getContext() { return mContext; }
584 inline int32_t getId() const { return mId; }
585 inline int32_t getControllerNumber() const { return mControllerNumber; }
586 inline int32_t getGeneration() const { return mGeneration; }
587 inline const String8& getName() const { return mIdentifier.name; }
588 inline const String8& getDescriptor() { return mIdentifier.descriptor; }
589 inline uint32_t getClasses() const { return mClasses; }
590 inline uint32_t getSources() const { return mSources; }
592 inline bool isExternal() { return mIsExternal; }
593 inline void setExternal(bool external) { mIsExternal = external; }
595 inline void setMic(bool hasMic) { mHasMic = hasMic; }
596 inline bool hasMic() const { return mHasMic; }
598 inline bool isIgnored() { return mMappers.isEmpty(); }
600 void dump(String8& dump);
601 void addMapper(InputMapper* mapper);
602 void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
603 void reset(nsecs_t when);
604 void process(const RawEvent* rawEvents, size_t count);
605 void timeoutExpired(nsecs_t when);
606 void updateExternalStylusState(const StylusState& state);
608 void getDeviceInfo(InputDeviceInfo* outDeviceInfo);
609 int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
610 int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
611 int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
612 bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
613 const int32_t* keyCodes, uint8_t* outFlags);
614 void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat, int32_t token);
615 void cancelVibrate(int32_t token);
616 void cancelTouch(nsecs_t when);
618 int32_t getMetaState();
622 void bumpGeneration();
624 void notifyReset(nsecs_t when);
626 inline const PropertyMap& getConfiguration() { return mConfiguration; }
627 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
629 bool hasKey(int32_t code) {
630 return getEventHub()->hasScanCode(mId, code);
633 bool hasAbsoluteAxis(int32_t code) {
634 RawAbsoluteAxisInfo info;
635 getEventHub()->getAbsoluteAxisInfo(mId, code, &info);
639 bool isKeyPressed(int32_t code) {
640 return getEventHub()->getScanCodeState(mId, code) == AKEY_STATE_DOWN;
643 int32_t getAbsoluteAxisValue(int32_t code) {
645 getEventHub()->getAbsoluteAxisValue(mId, code, &value);
650 InputReaderContext* mContext;
653 int32_t mControllerNumber;
654 InputDeviceIdentifier mIdentifier;
658 Vector<InputMapper*> mMappers;
663 bool mDropUntilNextSync;
665 typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);
666 int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);
668 PropertyMap mConfiguration;
672 /* Keeps track of the state of mouse or touch pad buttons. */
673 class CursorButtonAccumulator {
675 CursorButtonAccumulator();
676 void reset(InputDevice* device);
678 void process(const RawEvent* rawEvent);
680 uint32_t getButtonState() const;
696 /* Keeps track of cursor movements. */
698 class CursorMotionAccumulator {
700 CursorMotionAccumulator();
701 void reset(InputDevice* device);
703 void process(const RawEvent* rawEvent);
706 inline int32_t getRelativeX() const { return mRelX; }
707 inline int32_t getRelativeY() const { return mRelY; }
713 void clearRelativeAxes();
717 /* Keeps track of cursor scrolling motions. */
719 class CursorScrollAccumulator {
721 CursorScrollAccumulator();
722 void configure(InputDevice* device);
723 void reset(InputDevice* device);
725 void process(const RawEvent* rawEvent);
728 inline bool haveRelativeVWheel() const { return mHaveRelWheel; }
729 inline bool haveRelativeHWheel() const { return mHaveRelHWheel; }
731 inline int32_t getRelativeX() const { return mRelX; }
732 inline int32_t getRelativeY() const { return mRelY; }
733 inline int32_t getRelativeVWheel() const { return mRelWheel; }
734 inline int32_t getRelativeHWheel() const { return mRelHWheel; }
745 void clearRelativeAxes();
749 /* Keeps track of the state of touch, stylus and tool buttons. */
750 class TouchButtonAccumulator {
752 TouchButtonAccumulator();
753 void configure(InputDevice* device);
754 void reset(InputDevice* device);
756 void process(const RawEvent* rawEvent);
758 uint32_t getButtonState() const;
759 int32_t getToolType() const;
760 bool isToolActive() const;
761 bool isHovering() const;
762 bool hasStylus() const;
776 bool mBtnToolAirbrush;
779 bool mBtnToolDoubleTap;
780 bool mBtnToolTripleTap;
781 bool mBtnToolQuadTap;
787 /* Raw axis information from the driver. */
788 struct RawPointerAxes {
789 RawAbsoluteAxisInfo x;
790 RawAbsoluteAxisInfo y;
791 RawAbsoluteAxisInfo pressure;
792 RawAbsoluteAxisInfo touchMajor;
793 RawAbsoluteAxisInfo touchMinor;
794 RawAbsoluteAxisInfo toolMajor;
795 RawAbsoluteAxisInfo toolMinor;
796 RawAbsoluteAxisInfo orientation;
797 RawAbsoluteAxisInfo distance;
798 RawAbsoluteAxisInfo tiltX;
799 RawAbsoluteAxisInfo tiltY;
800 RawAbsoluteAxisInfo trackingId;
801 RawAbsoluteAxisInfo slot;
808 /* Raw data for a collection of pointers including a pointer id mapping table. */
809 struct RawPointerData {
823 int32_t toolType; // a fully decoded AMOTION_EVENT_TOOL_TYPE constant
827 uint32_t pointerCount;
828 Pointer pointers[MAX_POINTERS];
829 BitSet32 hoveringIdBits, touchingIdBits;
830 uint32_t idToIndex[MAX_POINTER_ID + 1];
834 void copyFrom(const RawPointerData& other);
835 void getCentroidOfTouchingPointers(float* outX, float* outY) const;
837 inline void markIdBit(uint32_t id, bool isHovering) {
839 hoveringIdBits.markBit(id);
841 touchingIdBits.markBit(id);
845 inline void clearIdBits() {
846 hoveringIdBits.clear();
847 touchingIdBits.clear();
850 inline const Pointer& pointerForId(uint32_t id) const {
851 return pointers[idToIndex[id]];
854 inline bool isHovering(uint32_t pointerIndex) {
855 return pointers[pointerIndex].isHovering;
860 /* Cooked data for a collection of pointers including a pointer id mapping table. */
861 struct CookedPointerData {
862 uint32_t pointerCount;
863 PointerProperties pointerProperties[MAX_POINTERS];
864 PointerCoords pointerCoords[MAX_POINTERS];
865 BitSet32 hoveringIdBits, touchingIdBits;
866 uint32_t idToIndex[MAX_POINTER_ID + 1];
870 void copyFrom(const CookedPointerData& other);
872 inline const PointerCoords& pointerCoordsForId(uint32_t id) const {
873 return pointerCoords[idToIndex[id]];
876 inline PointerCoords& editPointerCoordsWithId(uint32_t id) {
877 return pointerCoords[idToIndex[id]];
880 inline PointerProperties& editPointerPropertiesWithId(uint32_t id) {
881 return pointerProperties[idToIndex[id]];
884 inline bool isHovering(uint32_t pointerIndex) const {
885 return hoveringIdBits.hasBit(pointerProperties[pointerIndex].id);
888 inline bool isTouching(uint32_t pointerIndex) const {
889 return touchingIdBits.hasBit(pointerProperties[pointerIndex].id);
894 /* Keeps track of the state of single-touch protocol. */
895 class SingleTouchMotionAccumulator {
897 SingleTouchMotionAccumulator();
899 void process(const RawEvent* rawEvent);
900 void reset(InputDevice* device);
902 inline int32_t getAbsoluteX() const { return mAbsX; }
903 inline int32_t getAbsoluteY() const { return mAbsY; }
904 inline int32_t getAbsolutePressure() const { return mAbsPressure; }
905 inline int32_t getAbsoluteToolWidth() const { return mAbsToolWidth; }
906 inline int32_t getAbsoluteDistance() const { return mAbsDistance; }
907 inline int32_t getAbsoluteTiltX() const { return mAbsTiltX; }
908 inline int32_t getAbsoluteTiltY() const { return mAbsTiltY; }
913 int32_t mAbsPressure;
914 int32_t mAbsToolWidth;
915 int32_t mAbsDistance;
919 void clearAbsoluteAxes();
923 /* Keeps track of the state of multi-touch protocol. */
924 class MultiTouchMotionAccumulator {
928 inline bool isInUse() const { return mInUse; }
929 inline int32_t getX() const { return mAbsMTPositionX; }
930 inline int32_t getY() const { return mAbsMTPositionY; }
931 inline int32_t getTouchMajor() const { return mAbsMTTouchMajor; }
932 inline int32_t getTouchMinor() const {
933 return mHaveAbsMTTouchMinor ? mAbsMTTouchMinor : mAbsMTTouchMajor; }
934 inline int32_t getToolMajor() const { return mAbsMTWidthMajor; }
935 inline int32_t getToolMinor() const {
936 return mHaveAbsMTWidthMinor ? mAbsMTWidthMinor : mAbsMTWidthMajor; }
937 inline int32_t getOrientation() const { return mAbsMTOrientation; }
938 inline int32_t getTrackingId() const { return mAbsMTTrackingId; }
939 inline int32_t getPressure() const { return mAbsMTPressure; }
940 inline int32_t getDistance() const { return mAbsMTDistance; }
941 inline int32_t getToolType() const;
944 friend class MultiTouchMotionAccumulator;
947 bool mHaveAbsMTTouchMinor;
948 bool mHaveAbsMTWidthMinor;
949 bool mHaveAbsMTToolType;
951 int32_t mAbsMTPositionX;
952 int32_t mAbsMTPositionY;
953 int32_t mAbsMTTouchMajor;
954 int32_t mAbsMTTouchMinor;
955 int32_t mAbsMTWidthMajor;
956 int32_t mAbsMTWidthMinor;
957 int32_t mAbsMTOrientation;
958 int32_t mAbsMTTrackingId;
959 int32_t mAbsMTPressure;
960 int32_t mAbsMTDistance;
961 int32_t mAbsMTToolType;
967 MultiTouchMotionAccumulator();
968 ~MultiTouchMotionAccumulator();
970 void configure(InputDevice* device, size_t slotCount, bool usingSlotsProtocol);
971 void reset(InputDevice* device);
972 void process(const RawEvent* rawEvent);
974 bool hasStylus() const;
976 inline size_t getSlotCount() const { return mSlotCount; }
977 inline const Slot* getSlot(size_t index) const { return &mSlots[index]; }
980 int32_t mCurrentSlot;
983 bool mUsingSlotsProtocol;
986 void clearSlots(int32_t initialSlot);
990 /* An input mapper transforms raw input events into cooked event data.
991 * A single input device can have multiple associated input mappers in order to interpret
992 * different classes of events.
994 * InputMapper lifecycle:
996 * - configure with 0 changes
998 * - process, process, process (may occasionally reconfigure with non-zero changes or reset)
1004 InputMapper(InputDevice* device);
1005 virtual ~InputMapper();
1007 inline InputDevice* getDevice() { return mDevice; }
1008 inline int32_t getDeviceId() { return mDevice->getId(); }
1009 inline const String8 getDeviceName() { return mDevice->getName(); }
1010 inline InputReaderContext* getContext() { return mContext; }
1011 inline InputReaderPolicyInterface* getPolicy() { return mContext->getPolicy(); }
1012 inline InputListenerInterface* getListener() { return mContext->getListener(); }
1013 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
1015 virtual uint32_t getSources() = 0;
1016 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1017 virtual void dump(String8& dump);
1018 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1019 virtual void reset(nsecs_t when);
1020 virtual void process(const RawEvent* rawEvent) = 0;
1021 virtual void timeoutExpired(nsecs_t when);
1023 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
1024 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1025 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
1026 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1027 const int32_t* keyCodes, uint8_t* outFlags);
1028 virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
1030 virtual void cancelVibrate(int32_t token);
1031 virtual void cancelTouch(nsecs_t when);
1033 virtual int32_t getMetaState();
1035 virtual void updateExternalStylusState(const StylusState& state);
1037 virtual void fadePointer();
1040 InputDevice* mDevice;
1041 InputReaderContext* mContext;
1043 status_t getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo);
1044 void bumpGeneration();
1046 static void dumpRawAbsoluteAxisInfo(String8& dump,
1047 const RawAbsoluteAxisInfo& axis, const char* name);
1048 static void dumpStylusState(String8& dump, const StylusState& state);
1052 class SwitchInputMapper : public InputMapper {
1054 SwitchInputMapper(InputDevice* device);
1055 virtual ~SwitchInputMapper();
1057 virtual uint32_t getSources();
1058 virtual void process(const RawEvent* rawEvent);
1060 virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
1061 virtual void dump(String8& dump);
1064 uint32_t mSwitchValues;
1065 uint32_t mUpdatedSwitchMask;
1067 void processSwitch(int32_t switchCode, int32_t switchValue);
1068 void sync(nsecs_t when);
1072 class VibratorInputMapper : public InputMapper {
1074 VibratorInputMapper(InputDevice* device);
1075 virtual ~VibratorInputMapper();
1077 virtual uint32_t getSources();
1078 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1079 virtual void process(const RawEvent* rawEvent);
1081 virtual void vibrate(const nsecs_t* pattern, size_t patternSize, ssize_t repeat,
1083 virtual void cancelVibrate(int32_t token);
1084 virtual void timeoutExpired(nsecs_t when);
1085 virtual void dump(String8& dump);
1089 nsecs_t mPattern[MAX_VIBRATE_PATTERN_SIZE];
1090 size_t mPatternSize;
1094 nsecs_t mNextStepTime;
1097 void stopVibrating();
1101 class KeyboardInputMapper : public InputMapper {
1103 KeyboardInputMapper(InputDevice* device, uint32_t source, int32_t keyboardType);
1104 virtual ~KeyboardInputMapper();
1106 virtual uint32_t getSources();
1107 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1108 virtual void dump(String8& dump);
1109 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1110 virtual void reset(nsecs_t when);
1111 virtual void process(const RawEvent* rawEvent);
1113 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
1114 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1115 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1116 const int32_t* keyCodes, uint8_t* outFlags);
1118 virtual int32_t getMetaState();
1127 int32_t mKeyboardType;
1129 int32_t mOrientation; // orientation for dpad keys
1131 Vector<KeyDown> mKeyDowns; // keys that are down
1133 nsecs_t mDownTime; // time of most recent key down
1135 int32_t mCurrentHidUsage; // most recent HID usage seen this packet, or 0 if none
1138 bool avail; // led is available
1139 bool on; // we think the led is currently on
1141 LedState mCapsLockLedState;
1142 LedState mNumLockLedState;
1143 LedState mScrollLockLedState;
1145 // Immutable configuration parameters.
1147 bool hasAssociatedDisplay;
1148 bool orientationAware;
1149 bool handlesKeyRepeat;
1152 void configureParameters();
1153 void dumpParameters(String8& dump);
1155 bool isKeyboardOrGamepadKey(int32_t scanCode);
1157 void processKey(nsecs_t when, bool down, int32_t keyCode, int32_t scanCode,
1158 uint32_t policyFlags);
1160 ssize_t findKeyDown(int32_t scanCode);
1162 void resetLedState();
1163 void initializeLedState(LedState& ledState, int32_t led);
1164 void updateLedState(bool reset);
1165 void updateLedStateForModifier(LedState& ledState, int32_t led,
1166 int32_t modifier, bool reset);
1170 class CursorInputMapper : public InputMapper {
1172 CursorInputMapper(InputDevice* device);
1173 virtual ~CursorInputMapper();
1175 virtual uint32_t getSources();
1176 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1177 virtual void dump(String8& dump);
1178 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1179 virtual void reset(nsecs_t when);
1180 virtual void process(const RawEvent* rawEvent);
1182 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1184 virtual void fadePointer();
1187 // Amount that trackball needs to move in order to generate a key event.
1188 static const int32_t TRACKBALL_MOVEMENT_THRESHOLD = 6;
1190 // Immutable configuration parameters.
1198 bool hasAssociatedDisplay;
1199 bool orientationAware;
1202 CursorButtonAccumulator mCursorButtonAccumulator;
1203 CursorMotionAccumulator mCursorMotionAccumulator;
1204 CursorScrollAccumulator mCursorScrollAccumulator;
1215 // Velocity controls for mouse pointer and wheel movements.
1216 // The controls for X and Y wheel movements are separate to keep them decoupled.
1217 VelocityControl mPointerVelocityControl;
1218 VelocityControl mWheelXVelocityControl;
1219 VelocityControl mWheelYVelocityControl;
1221 int32_t mOrientation;
1223 sp<PointerControllerInterface> mPointerController;
1225 int32_t mButtonState;
1228 void configureParameters();
1229 void dumpParameters(String8& dump);
1231 void sync(nsecs_t when);
1235 class TouchInputMapper : public InputMapper {
1237 TouchInputMapper(InputDevice* device);
1238 virtual ~TouchInputMapper();
1240 virtual uint32_t getSources();
1241 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1242 virtual void dump(String8& dump);
1243 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1244 virtual void reset(nsecs_t when);
1245 virtual void process(const RawEvent* rawEvent);
1247 virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
1248 virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
1249 virtual bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,
1250 const int32_t* keyCodes, uint8_t* outFlags);
1252 virtual void fadePointer();
1253 virtual void cancelTouch(nsecs_t when);
1254 virtual void timeoutExpired(nsecs_t when);
1255 virtual void updateExternalStylusState(const StylusState& state);
1258 CursorButtonAccumulator mCursorButtonAccumulator;
1259 CursorScrollAccumulator mCursorScrollAccumulator;
1260 TouchButtonAccumulator mTouchButtonAccumulator;
1267 // computed hit box, specified in touch screen coords based on known display size
1273 inline bool isHit(int32_t x, int32_t y) const {
1274 return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
1278 // Input sources and device mode.
1282 DEVICE_MODE_DISABLED, // input is disabled
1283 DEVICE_MODE_DIRECT, // direct mapping (touchscreen)
1284 DEVICE_MODE_UNSCALED, // unscaled mapping (touchpad)
1285 DEVICE_MODE_NAVIGATION, // unscaled mapping with assist gesture (touch navigation)
1286 DEVICE_MODE_POINTER, // pointer mapping (pointer)
1288 DeviceMode mDeviceMode;
1290 // The reader's configuration.
1291 InputReaderConfiguration mConfig;
1293 // Immutable configuration parameters.
1296 DEVICE_TYPE_TOUCH_SCREEN,
1297 DEVICE_TYPE_TOUCH_PAD,
1298 DEVICE_TYPE_TOUCH_NAVIGATION,
1299 DEVICE_TYPE_POINTER,
1302 DeviceType deviceType;
1303 bool hasAssociatedDisplay;
1304 bool associatedDisplayIsExternal;
1305 bool orientationAware;
1306 bool hasButtonUnderPad;
1309 GESTURE_MODE_POINTER,
1312 GestureMode gestureMode;
1317 // Immutable calibration parameters in parsed form.
1318 struct Calibration {
1320 enum SizeCalibration {
1321 SIZE_CALIBRATION_DEFAULT,
1322 SIZE_CALIBRATION_NONE,
1323 SIZE_CALIBRATION_GEOMETRIC,
1324 SIZE_CALIBRATION_DIAMETER,
1325 SIZE_CALIBRATION_BOX,
1326 SIZE_CALIBRATION_AREA,
1329 SizeCalibration sizeCalibration;
1335 bool haveSizeIsSummed;
1339 enum PressureCalibration {
1340 PRESSURE_CALIBRATION_DEFAULT,
1341 PRESSURE_CALIBRATION_NONE,
1342 PRESSURE_CALIBRATION_PHYSICAL,
1343 PRESSURE_CALIBRATION_AMPLITUDE,
1346 PressureCalibration pressureCalibration;
1347 bool havePressureScale;
1348 float pressureScale;
1351 enum OrientationCalibration {
1352 ORIENTATION_CALIBRATION_DEFAULT,
1353 ORIENTATION_CALIBRATION_NONE,
1354 ORIENTATION_CALIBRATION_INTERPOLATED,
1355 ORIENTATION_CALIBRATION_VECTOR,
1358 OrientationCalibration orientationCalibration;
1361 enum DistanceCalibration {
1362 DISTANCE_CALIBRATION_DEFAULT,
1363 DISTANCE_CALIBRATION_NONE,
1364 DISTANCE_CALIBRATION_SCALED,
1367 DistanceCalibration distanceCalibration;
1368 bool haveDistanceScale;
1369 float distanceScale;
1371 enum CoverageCalibration {
1372 COVERAGE_CALIBRATION_DEFAULT,
1373 COVERAGE_CALIBRATION_NONE,
1374 COVERAGE_CALIBRATION_BOX,
1377 CoverageCalibration coverageCalibration;
1379 inline void applySizeScaleAndBias(float* outSize) const {
1380 if (haveSizeScale) {
1381 *outSize *= sizeScale;
1384 *outSize += sizeBias;
1392 // Affine location transformation/calibration
1393 struct TouchAffineTransformation mAffineTransform;
1395 RawPointerAxes mRawPointerAxes;
1400 // Raw pointer sample data.
1401 RawPointerData rawPointerData;
1403 int32_t buttonState;
1409 void copyFrom(const RawState& other) {
1411 rawPointerData.copyFrom(other.rawPointerData);
1412 buttonState = other.buttonState;
1413 rawVScroll = other.rawVScroll;
1414 rawHScroll = other.rawHScroll;
1419 rawPointerData.clear();
1426 struct CookedState {
1427 // Cooked pointer sample data.
1428 CookedPointerData cookedPointerData;
1430 // Id bits used to differentiate fingers, stylus and mouse tools.
1431 BitSet32 fingerIdBits;
1432 BitSet32 stylusIdBits;
1433 BitSet32 mouseIdBits;
1435 int32_t buttonState;
1437 void copyFrom(const CookedState& other) {
1438 cookedPointerData.copyFrom(other.cookedPointerData);
1439 fingerIdBits = other.fingerIdBits;
1440 stylusIdBits = other.stylusIdBits;
1441 mouseIdBits = other.mouseIdBits;
1442 buttonState = other.buttonState;
1446 cookedPointerData.clear();
1447 fingerIdBits.clear();
1448 stylusIdBits.clear();
1449 mouseIdBits.clear();
1454 Vector<RawState> mRawStatesPending;
1455 RawState mCurrentRawState;
1456 CookedState mCurrentCookedState;
1457 RawState mLastRawState;
1458 CookedState mLastCookedState;
1460 // State provided by an external stylus
1461 StylusState mExternalStylusState;
1462 int64_t mExternalStylusId;
1463 nsecs_t mExternalStylusFusionTimeout;
1464 bool mExternalStylusDataPending;
1466 // True if we sent a HOVER_ENTER event.
1467 bool mSentHoverEnter;
1469 // Have we assigned pointer IDs for this stream
1470 bool mHavePointerIds;
1472 // Is the current stream of direct touch events aborted
1473 bool mCurrentMotionAborted;
1475 // The time the primary pointer last went down.
1478 // The pointer controller, or null if the device is not a pointer.
1479 sp<PointerControllerInterface> mPointerController;
1481 Vector<VirtualKey> mVirtualKeys;
1483 virtual void configureParameters();
1484 virtual void dumpParameters(String8& dump);
1485 virtual void configureRawPointerAxes();
1486 virtual void dumpRawPointerAxes(String8& dump);
1487 virtual void configureSurface(nsecs_t when, bool* outResetNeeded);
1488 virtual void dumpSurface(String8& dump);
1489 virtual void configureVirtualKeys();
1490 virtual void dumpVirtualKeys(String8& dump);
1491 virtual void parseCalibration();
1492 virtual void resolveCalibration();
1493 virtual void dumpCalibration(String8& dump);
1494 virtual void updateAffineTransformation();
1495 virtual void dumpAffineTransformation(String8& dump);
1496 virtual void resolveExternalStylusPresence();
1497 virtual bool hasStylus() const = 0;
1498 virtual bool hasExternalStylus() const;
1500 virtual void syncTouch(nsecs_t when, RawState* outState) = 0;
1503 // The current viewport.
1504 // The components of the viewport are specified in the display's rotated orientation.
1505 DisplayViewport mViewport;
1507 // The surface orientation, width and height set by configureSurface().
1508 // The width and height are derived from the viewport but are specified
1509 // in the natural orientation.
1510 // The surface origin specifies how the surface coordinates should be translated
1511 // to align with the logical display coordinate space.
1512 // The orientation may be different from the viewport orientation as it specifies
1513 // the rotation of the surface coordinates required to produce the viewport's
1514 // requested orientation, so it will depend on whether the device is orientation aware.
1515 int32_t mSurfaceWidth;
1516 int32_t mSurfaceHeight;
1517 int32_t mSurfaceLeft;
1518 int32_t mSurfaceTop;
1519 int32_t mSurfaceOrientation;
1521 // Translation and scaling factors, orientation-independent.
1530 float mGeometricScale;
1532 float mPressureScale;
1536 float mOrientationScale;
1538 float mDistanceScale;
1546 bool mExternalStylusConnected;
1548 // Oriented motion ranges for input device info.
1549 struct OrientedRanges {
1550 InputDeviceInfo::MotionRange x;
1551 InputDeviceInfo::MotionRange y;
1552 InputDeviceInfo::MotionRange pressure;
1555 InputDeviceInfo::MotionRange size;
1558 InputDeviceInfo::MotionRange touchMajor;
1559 InputDeviceInfo::MotionRange touchMinor;
1562 InputDeviceInfo::MotionRange toolMajor;
1563 InputDeviceInfo::MotionRange toolMinor;
1565 bool haveOrientation;
1566 InputDeviceInfo::MotionRange orientation;
1569 InputDeviceInfo::MotionRange distance;
1572 InputDeviceInfo::MotionRange tilt;
1580 haveTouchSize = false;
1581 haveToolSize = false;
1582 haveOrientation = false;
1583 haveDistance = false;
1588 // Oriented dimensions and precision.
1589 float mOrientedXPrecision;
1590 float mOrientedYPrecision;
1592 struct CurrentVirtualKeyState {
1598 } mCurrentVirtualKey;
1600 // Scale factor for gesture or mouse based pointer movements.
1601 float mPointerXMovementScale;
1602 float mPointerYMovementScale;
1604 // Scale factor for gesture based zooming and other freeform motions.
1605 float mPointerXZoomScale;
1606 float mPointerYZoomScale;
1608 // The maximum swipe width.
1609 float mPointerGestureMaxSwipeWidth;
1611 struct PointerDistanceHeapElement {
1612 uint32_t currentPointerIndex : 8;
1613 uint32_t lastPointerIndex : 8;
1614 uint64_t distance : 48; // squared distance
1619 POINTER_USAGE_GESTURES,
1620 POINTER_USAGE_STYLUS,
1621 POINTER_USAGE_MOUSE,
1623 PointerUsage mPointerUsage;
1625 struct PointerGesture {
1627 // No fingers, button is not pressed.
1628 // Nothing happening.
1631 // No fingers, button is not pressed.
1633 // Emits DOWN and UP events at the pointer location.
1636 // Exactly one finger dragging following a tap.
1637 // Pointer follows the active finger.
1638 // Emits DOWN, MOVE and UP events at the pointer location.
1640 // Detect double-taps when the finger goes up while in TAP_DRAG mode.
1643 // Button is pressed.
1644 // Pointer follows the active finger if there is one. Other fingers are ignored.
1645 // Emits DOWN, MOVE and UP events at the pointer location.
1646 BUTTON_CLICK_OR_DRAG,
1648 // Exactly one finger, button is not pressed.
1649 // Pointer follows the active finger.
1650 // Emits HOVER_MOVE events at the pointer location.
1652 // Detect taps when the finger goes up while in HOVER mode.
1655 // Exactly two fingers but neither have moved enough to clearly indicate
1656 // whether a swipe or freeform gesture was intended. We consider the
1657 // pointer to be pressed so this enables clicking or long-pressing on buttons.
1658 // Pointer does not move.
1659 // Emits DOWN, MOVE and UP events with a single stationary pointer coordinate.
1662 // Exactly two fingers moving in the same direction, button is not pressed.
1663 // Pointer does not move.
1664 // Emits DOWN, MOVE and UP events with a single pointer coordinate that
1665 // follows the midpoint between both fingers.
1668 // Two or more fingers moving in arbitrary directions, button is not pressed.
1669 // Pointer does not move.
1670 // Emits DOWN, POINTER_DOWN, MOVE, POINTER_UP and UP events that follow
1671 // each finger individually relative to the initial centroid of the finger.
1674 // Waiting for quiet time to end before starting the next gesture.
1678 // Time the first finger went down.
1679 nsecs_t firstTouchTime;
1681 // The active pointer id from the raw touch data.
1682 int32_t activeTouchId; // -1 if none
1684 // The active pointer id from the gesture last delivered to the application.
1685 int32_t activeGestureId; // -1 if none
1687 // Pointer coords and ids for the current and previous pointer gesture.
1688 Mode currentGestureMode;
1689 BitSet32 currentGestureIdBits;
1690 uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];
1691 PointerProperties currentGestureProperties[MAX_POINTERS];
1692 PointerCoords currentGestureCoords[MAX_POINTERS];
1694 Mode lastGestureMode;
1695 BitSet32 lastGestureIdBits;
1696 uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];
1697 PointerProperties lastGestureProperties[MAX_POINTERS];
1698 PointerCoords lastGestureCoords[MAX_POINTERS];
1700 // Time the pointer gesture last went down.
1703 // Time when the pointer went down for a TAP.
1704 nsecs_t tapDownTime;
1706 // Time when the pointer went up for a TAP.
1709 // Location of initial tap.
1712 // Time we started waiting for quiescence.
1715 // Reference points for multitouch gestures.
1716 float referenceTouchX; // reference touch X/Y coordinates in surface units
1717 float referenceTouchY;
1718 float referenceGestureX; // reference gesture X/Y coordinates in pixels
1719 float referenceGestureY;
1721 // Distance that each pointer has traveled which has not yet been
1722 // subsumed into the reference gesture position.
1723 BitSet32 referenceIdBits;
1727 Delta referenceDeltas[MAX_POINTER_ID + 1];
1729 // Describes how touch ids are mapped to gesture ids for freeform gestures.
1730 uint32_t freeformTouchToGestureIdMap[MAX_POINTER_ID + 1];
1732 // A velocity tracker for determining whether to switch active pointers during drags.
1733 VelocityTracker velocityTracker;
1736 firstTouchTime = LLONG_MIN;
1738 activeGestureId = -1;
1739 currentGestureMode = NEUTRAL;
1740 currentGestureIdBits.clear();
1741 lastGestureMode = NEUTRAL;
1742 lastGestureIdBits.clear();
1744 velocityTracker.clear();
1750 tapDownTime = LLONG_MIN;
1751 tapUpTime = LLONG_MIN;
1754 void resetQuietTime() {
1755 quietTime = LLONG_MIN;
1759 struct PointerSimple {
1760 PointerCoords currentCoords;
1761 PointerProperties currentProperties;
1762 PointerCoords lastCoords;
1763 PointerProperties lastProperties;
1765 // True if the pointer is down.
1768 // True if the pointer is hovering.
1771 // Time the pointer last went down.
1775 currentCoords.clear();
1776 currentProperties.clear();
1778 lastProperties.clear();
1785 // The pointer and scroll velocity controls.
1786 VelocityControl mPointerVelocityControl;
1787 VelocityControl mWheelXVelocityControl;
1788 VelocityControl mWheelYVelocityControl;
1790 void resetExternalStylus();
1791 void clearStylusDataPendingFlags();
1793 void sync(nsecs_t when);
1795 bool consumeRawTouches(nsecs_t when, uint32_t policyFlags);
1796 void processRawTouches(bool timeout);
1797 void cookAndDispatch(nsecs_t when);
1798 void dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
1799 int32_t keyEventAction, int32_t keyEventFlags);
1801 void dispatchTouches(nsecs_t when, uint32_t policyFlags);
1802 void dispatchHoverExit(nsecs_t when, uint32_t policyFlags);
1803 void dispatchHoverEnterAndMove(nsecs_t when, uint32_t policyFlags);
1804 void dispatchButtonRelease(nsecs_t when, uint32_t policyFlags);
1805 void dispatchButtonPress(nsecs_t when, uint32_t policyFlags);
1806 const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData);
1807 void cookPointerData();
1808 void abortTouches(nsecs_t when, uint32_t policyFlags);
1810 void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);
1811 void abortPointerUsage(nsecs_t when, uint32_t policyFlags);
1813 void dispatchPointerGestures(nsecs_t when, uint32_t policyFlags, bool isTimeout);
1814 void abortPointerGestures(nsecs_t when, uint32_t policyFlags);
1815 bool preparePointerGestures(nsecs_t when,
1816 bool* outCancelPreviousGesture, bool* outFinishPreviousGesture,
1819 void dispatchPointerStylus(nsecs_t when, uint32_t policyFlags);
1820 void abortPointerStylus(nsecs_t when, uint32_t policyFlags);
1822 void dispatchPointerMouse(nsecs_t when, uint32_t policyFlags);
1823 void abortPointerMouse(nsecs_t when, uint32_t policyFlags);
1825 void dispatchPointerSimple(nsecs_t when, uint32_t policyFlags,
1826 bool down, bool hovering);
1827 void abortPointerSimple(nsecs_t when, uint32_t policyFlags);
1829 bool assignExternalStylusId(const RawState& state, bool timeout);
1830 void applyExternalStylusButtonState(nsecs_t when);
1831 void applyExternalStylusTouchState(nsecs_t when);
1833 // Dispatches a motion event.
1834 // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the
1835 // method will take care of setting the index and transmuting the action to DOWN or UP
1836 // it is the first / last pointer to go down / up.
1837 void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
1838 int32_t action, int32_t actionButton,
1839 int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
1840 const PointerProperties* properties, const PointerCoords* coords,
1841 const uint32_t* idToIndex, BitSet32 idBits,
1842 int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
1844 // Updates pointer coords and properties for pointers with specified ids that have moved.
1845 // Returns true if any of them changed.
1846 bool updateMovedPointers(const PointerProperties* inProperties,
1847 const PointerCoords* inCoords, const uint32_t* inIdToIndex,
1848 PointerProperties* outProperties, PointerCoords* outCoords,
1849 const uint32_t* outIdToIndex, BitSet32 idBits) const;
1851 bool isPointInsideSurface(int32_t x, int32_t y);
1852 const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);
1854 static void assignPointerIds(const RawState* last, RawState* current);
1858 class SingleTouchInputMapper : public TouchInputMapper {
1860 SingleTouchInputMapper(InputDevice* device);
1861 virtual ~SingleTouchInputMapper();
1863 virtual void reset(nsecs_t when);
1864 virtual void process(const RawEvent* rawEvent);
1867 virtual void syncTouch(nsecs_t when, RawState* outState);
1868 virtual void configureRawPointerAxes();
1869 virtual bool hasStylus() const;
1872 SingleTouchMotionAccumulator mSingleTouchMotionAccumulator;
1876 class MultiTouchInputMapper : public TouchInputMapper {
1878 MultiTouchInputMapper(InputDevice* device);
1879 virtual ~MultiTouchInputMapper();
1881 virtual void reset(nsecs_t when);
1882 virtual void process(const RawEvent* rawEvent);
1885 virtual void syncTouch(nsecs_t when, RawState* outState);
1886 virtual void configureRawPointerAxes();
1887 virtual bool hasStylus() const;
1890 MultiTouchMotionAccumulator mMultiTouchMotionAccumulator;
1892 // Specifies the pointer id bits that are in use, and their associated tracking id.
1893 BitSet32 mPointerIdBits;
1894 int32_t mPointerTrackingIdMap[MAX_POINTER_ID + 1];
1897 class ExternalStylusInputMapper : public InputMapper {
1899 ExternalStylusInputMapper(InputDevice* device);
1900 virtual ~ExternalStylusInputMapper() = default;
1902 virtual uint32_t getSources();
1903 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1904 virtual void dump(String8& dump);
1905 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1906 virtual void reset(nsecs_t when);
1907 virtual void process(const RawEvent* rawEvent);
1908 virtual void sync(nsecs_t when);
1911 SingleTouchMotionAccumulator mSingleTouchMotionAccumulator;
1912 RawAbsoluteAxisInfo mRawPressureAxis;
1913 TouchButtonAccumulator mTouchButtonAccumulator;
1915 StylusState mStylusState;
1919 class JoystickInputMapper : public InputMapper {
1921 JoystickInputMapper(InputDevice* device);
1922 virtual ~JoystickInputMapper();
1924 virtual uint32_t getSources();
1925 virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
1926 virtual void dump(String8& dump);
1927 virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
1928 virtual void reset(nsecs_t when);
1929 virtual void process(const RawEvent* rawEvent);
1933 RawAbsoluteAxisInfo rawAxisInfo;
1936 bool explicitlyMapped; // true if the axis was explicitly assigned an axis id
1938 float scale; // scale factor from raw to normalized values
1939 float offset; // offset to add after scaling for normalization
1940 float highScale; // scale factor from raw to normalized values of high split
1941 float highOffset; // offset to add after scaling for normalization of high split
1943 float min; // normalized inclusive minimum
1944 float max; // normalized inclusive maximum
1945 float flat; // normalized flat region size
1946 float fuzz; // normalized error tolerance
1947 float resolution; // normalized resolution in units/mm
1949 float filter; // filter out small variations of this size
1950 float currentValue; // current value
1951 float newValue; // most recent value
1952 float highCurrentValue; // current value of high split
1953 float highNewValue; // most recent value of high split
1955 void initialize(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo,
1956 bool explicitlyMapped, float scale, float offset,
1957 float highScale, float highOffset,
1958 float min, float max, float flat, float fuzz, float resolution) {
1959 this->rawAxisInfo = rawAxisInfo;
1960 this->axisInfo = axisInfo;
1961 this->explicitlyMapped = explicitlyMapped;
1962 this->scale = scale;
1963 this->offset = offset;
1964 this->highScale = highScale;
1965 this->highOffset = highOffset;
1970 this->resolution = resolution;
1976 this->currentValue = 0;
1978 this->highCurrentValue = 0;
1979 this->highNewValue = 0;
1983 // Axes indexed by raw ABS_* axis index.
1984 KeyedVector<int32_t, Axis> mAxes;
1986 void sync(nsecs_t when, bool force);
1988 bool haveAxis(int32_t axisId);
1989 void pruneAxes(bool ignoreExplicitlyMappedAxes);
1990 bool filterAxes(bool force);
1992 static bool hasValueChangedSignificantly(float filter,
1993 float newValue, float currentValue, float min, float max);
1994 static bool hasMovedNearerToValueWithinFilteredRange(float filter,
1995 float newValue, float currentValue, float thresholdValue);
1997 static bool isCenteredAxis(int32_t axis);
1998 static int32_t getCompatAxis(int32_t axis);
2000 static void addMotionRange(int32_t axisId, const Axis& axis, InputDeviceInfo* info);
2001 static void setPointerCoordsAxisValue(PointerCoords* pointerCoords, int32_t axis,
2005 } // namespace android
2007 #endif // _UI_INPUT_READER_H