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 #define LOG_TAG "Input"
18 //#define LOG_NDEBUG 0
19
20 #include <math.h>
21 #include <limits.h>
22
23 #include <input/Input.h>
24 #include <input/InputEventLabels.h>
25
26 #ifdef HAVE_ANDROID_OS
27 #include <binder/Parcel.h>
28 #endif
29
30 namespace android {
31
32 // --- InputEvent ---
33
initialize(int32_t deviceId,int32_t source)34 void InputEvent::initialize(int32_t deviceId, int32_t source) {
35 mDeviceId = deviceId;
36 mSource = source;
37 }
38
initialize(const InputEvent & from)39 void InputEvent::initialize(const InputEvent& from) {
40 mDeviceId = from.mDeviceId;
41 mSource = from.mSource;
42 }
43
44 // --- KeyEvent ---
45
getLabel(int32_t keyCode)46 const char* KeyEvent::getLabel(int32_t keyCode) {
47 return getLabelByKeyCode(keyCode);
48 }
49
getKeyCodeFromLabel(const char * label)50 int32_t KeyEvent::getKeyCodeFromLabel(const char* label) {
51 return getKeyCodeByLabel(label);
52 }
53
initialize(int32_t deviceId,int32_t source,int32_t action,int32_t flags,int32_t keyCode,int32_t scanCode,int32_t metaState,int32_t repeatCount,nsecs_t downTime,nsecs_t eventTime)54 void KeyEvent::initialize(
55 int32_t deviceId,
56 int32_t source,
57 int32_t action,
58 int32_t flags,
59 int32_t keyCode,
60 int32_t scanCode,
61 int32_t metaState,
62 int32_t repeatCount,
63 nsecs_t downTime,
64 nsecs_t eventTime) {
65 InputEvent::initialize(deviceId, source);
66 mAction = action;
67 mFlags = flags;
68 mKeyCode = keyCode;
69 mScanCode = scanCode;
70 mMetaState = metaState;
71 mRepeatCount = repeatCount;
72 mDownTime = downTime;
73 mEventTime = eventTime;
74 }
75
initialize(const KeyEvent & from)76 void KeyEvent::initialize(const KeyEvent& from) {
77 InputEvent::initialize(from);
78 mAction = from.mAction;
79 mFlags = from.mFlags;
80 mKeyCode = from.mKeyCode;
81 mScanCode = from.mScanCode;
82 mMetaState = from.mMetaState;
83 mRepeatCount = from.mRepeatCount;
84 mDownTime = from.mDownTime;
85 mEventTime = from.mEventTime;
86 }
87
88
89 // --- PointerCoords ---
90
getAxisValue(int32_t axis) const91 float PointerCoords::getAxisValue(int32_t axis) const {
92 if (axis < 0 || axis > 63 || !BitSet64::hasBit(bits, axis)){
93 return 0;
94 }
95 return values[BitSet64::getIndexOfBit(bits, axis)];
96 }
97
setAxisValue(int32_t axis,float value)98 status_t PointerCoords::setAxisValue(int32_t axis, float value) {
99 if (axis < 0 || axis > 63) {
100 return NAME_NOT_FOUND;
101 }
102
103 uint32_t index = BitSet64::getIndexOfBit(bits, axis);
104 if (!BitSet64::hasBit(bits, axis)) {
105 if (value == 0) {
106 return OK; // axes with value 0 do not need to be stored
107 }
108
109 uint32_t count = BitSet64::count(bits);
110 if (count >= MAX_AXES) {
111 tooManyAxes(axis);
112 return NO_MEMORY;
113 }
114 BitSet64::markBit(bits, axis);
115 for (uint32_t i = count; i > index; i--) {
116 values[i] = values[i - 1];
117 }
118 }
119
120 values[index] = value;
121 return OK;
122 }
123
scaleAxisValue(PointerCoords & c,int axis,float scaleFactor)124 static inline void scaleAxisValue(PointerCoords& c, int axis, float scaleFactor) {
125 float value = c.getAxisValue(axis);
126 if (value != 0) {
127 c.setAxisValue(axis, value * scaleFactor);
128 }
129 }
130
scale(float scaleFactor)131 void PointerCoords::scale(float scaleFactor) {
132 // No need to scale pressure or size since they are normalized.
133 // No need to scale orientation since it is meaningless to do so.
134 scaleAxisValue(*this, AMOTION_EVENT_AXIS_X, scaleFactor);
135 scaleAxisValue(*this, AMOTION_EVENT_AXIS_Y, scaleFactor);
136 scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MAJOR, scaleFactor);
137 scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MINOR, scaleFactor);
138 scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MAJOR, scaleFactor);
139 scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MINOR, scaleFactor);
140 }
141
applyOffset(float xOffset,float yOffset)142 void PointerCoords::applyOffset(float xOffset, float yOffset) {
143 setAxisValue(AMOTION_EVENT_AXIS_X, getX() + xOffset);
144 setAxisValue(AMOTION_EVENT_AXIS_Y, getY() + yOffset);
145 }
146
147 #ifdef HAVE_ANDROID_OS
readFromParcel(Parcel * parcel)148 status_t PointerCoords::readFromParcel(Parcel* parcel) {
149 bits = parcel->readInt64();
150
151 uint32_t count = BitSet64::count(bits);
152 if (count > MAX_AXES) {
153 return BAD_VALUE;
154 }
155
156 for (uint32_t i = 0; i < count; i++) {
157 values[i] = parcel->readFloat();
158 }
159 return OK;
160 }
161
writeToParcel(Parcel * parcel) const162 status_t PointerCoords::writeToParcel(Parcel* parcel) const {
163 parcel->writeInt64(bits);
164
165 uint32_t count = BitSet64::count(bits);
166 for (uint32_t i = 0; i < count; i++) {
167 parcel->writeFloat(values[i]);
168 }
169 return OK;
170 }
171 #endif
172
tooManyAxes(int axis)173 void PointerCoords::tooManyAxes(int axis) {
174 ALOGW("Could not set value for axis %d because the PointerCoords structure is full and "
175 "cannot contain more than %d axis values.", axis, int(MAX_AXES));
176 }
177
operator ==(const PointerCoords & other) const178 bool PointerCoords::operator==(const PointerCoords& other) const {
179 if (bits != other.bits) {
180 return false;
181 }
182 uint32_t count = BitSet64::count(bits);
183 for (uint32_t i = 0; i < count; i++) {
184 if (values[i] != other.values[i]) {
185 return false;
186 }
187 }
188 return true;
189 }
190
copyFrom(const PointerCoords & other)191 void PointerCoords::copyFrom(const PointerCoords& other) {
192 bits = other.bits;
193 uint32_t count = BitSet64::count(bits);
194 for (uint32_t i = 0; i < count; i++) {
195 values[i] = other.values[i];
196 }
197 }
198
199
200 // --- PointerProperties ---
201
operator ==(const PointerProperties & other) const202 bool PointerProperties::operator==(const PointerProperties& other) const {
203 return id == other.id
204 && toolType == other.toolType;
205 }
206
copyFrom(const PointerProperties & other)207 void PointerProperties::copyFrom(const PointerProperties& other) {
208 id = other.id;
209 toolType = other.toolType;
210 }
211
212
213 // --- MotionEvent ---
214
initialize(int32_t deviceId,int32_t source,int32_t action,int32_t flags,int32_t edgeFlags,int32_t metaState,int32_t buttonState,float xOffset,float yOffset,float xPrecision,float yPrecision,nsecs_t downTime,nsecs_t eventTime,size_t pointerCount,const PointerProperties * pointerProperties,const PointerCoords * pointerCoords)215 void MotionEvent::initialize(
216 int32_t deviceId,
217 int32_t source,
218 int32_t action,
219 int32_t flags,
220 int32_t edgeFlags,
221 int32_t metaState,
222 int32_t buttonState,
223 float xOffset,
224 float yOffset,
225 float xPrecision,
226 float yPrecision,
227 nsecs_t downTime,
228 nsecs_t eventTime,
229 size_t pointerCount,
230 const PointerProperties* pointerProperties,
231 const PointerCoords* pointerCoords) {
232 InputEvent::initialize(deviceId, source);
233 mAction = action;
234 mFlags = flags;
235 mEdgeFlags = edgeFlags;
236 mMetaState = metaState;
237 mButtonState = buttonState;
238 mXOffset = xOffset;
239 mYOffset = yOffset;
240 mXPrecision = xPrecision;
241 mYPrecision = yPrecision;
242 mDownTime = downTime;
243 mPointerProperties.clear();
244 mPointerProperties.appendArray(pointerProperties, pointerCount);
245 mSampleEventTimes.clear();
246 mSamplePointerCoords.clear();
247 addSample(eventTime, pointerCoords);
248 }
249
copyFrom(const MotionEvent * other,bool keepHistory)250 void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {
251 InputEvent::initialize(other->mDeviceId, other->mSource);
252 mAction = other->mAction;
253 mFlags = other->mFlags;
254 mEdgeFlags = other->mEdgeFlags;
255 mMetaState = other->mMetaState;
256 mButtonState = other->mButtonState;
257 mXOffset = other->mXOffset;
258 mYOffset = other->mYOffset;
259 mXPrecision = other->mXPrecision;
260 mYPrecision = other->mYPrecision;
261 mDownTime = other->mDownTime;
262 mPointerProperties = other->mPointerProperties;
263
264 if (keepHistory) {
265 mSampleEventTimes = other->mSampleEventTimes;
266 mSamplePointerCoords = other->mSamplePointerCoords;
267 } else {
268 mSampleEventTimes.clear();
269 mSampleEventTimes.push(other->getEventTime());
270 mSamplePointerCoords.clear();
271 size_t pointerCount = other->getPointerCount();
272 size_t historySize = other->getHistorySize();
273 mSamplePointerCoords.appendArray(other->mSamplePointerCoords.array()
274 + (historySize * pointerCount), pointerCount);
275 }
276 }
277
addSample(int64_t eventTime,const PointerCoords * pointerCoords)278 void MotionEvent::addSample(
279 int64_t eventTime,
280 const PointerCoords* pointerCoords) {
281 mSampleEventTimes.push(eventTime);
282 mSamplePointerCoords.appendArray(pointerCoords, getPointerCount());
283 }
284
getRawPointerCoords(size_t pointerIndex) const285 const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {
286 return &mSamplePointerCoords[getHistorySize() * getPointerCount() + pointerIndex];
287 }
288
getRawAxisValue(int32_t axis,size_t pointerIndex) const289 float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
290 return getRawPointerCoords(pointerIndex)->getAxisValue(axis);
291 }
292
getAxisValue(int32_t axis,size_t pointerIndex) const293 float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
294 float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);
295 switch (axis) {
296 case AMOTION_EVENT_AXIS_X:
297 return value + mXOffset;
298 case AMOTION_EVENT_AXIS_Y:
299 return value + mYOffset;
300 }
301 return value;
302 }
303
getHistoricalRawPointerCoords(size_t pointerIndex,size_t historicalIndex) const304 const PointerCoords* MotionEvent::getHistoricalRawPointerCoords(
305 size_t pointerIndex, size_t historicalIndex) const {
306 return &mSamplePointerCoords[historicalIndex * getPointerCount() + pointerIndex];
307 }
308
getHistoricalRawAxisValue(int32_t axis,size_t pointerIndex,size_t historicalIndex) const309 float MotionEvent::getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,
310 size_t historicalIndex) const {
311 return getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
312 }
313
getHistoricalAxisValue(int32_t axis,size_t pointerIndex,size_t historicalIndex) const314 float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,
315 size_t historicalIndex) const {
316 float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
317 switch (axis) {
318 case AMOTION_EVENT_AXIS_X:
319 return value + mXOffset;
320 case AMOTION_EVENT_AXIS_Y:
321 return value + mYOffset;
322 }
323 return value;
324 }
325
findPointerIndex(int32_t pointerId) const326 ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {
327 size_t pointerCount = mPointerProperties.size();
328 for (size_t i = 0; i < pointerCount; i++) {
329 if (mPointerProperties.itemAt(i).id == pointerId) {
330 return i;
331 }
332 }
333 return -1;
334 }
335
offsetLocation(float xOffset,float yOffset)336 void MotionEvent::offsetLocation(float xOffset, float yOffset) {
337 mXOffset += xOffset;
338 mYOffset += yOffset;
339 }
340
scale(float scaleFactor)341 void MotionEvent::scale(float scaleFactor) {
342 mXOffset *= scaleFactor;
343 mYOffset *= scaleFactor;
344 mXPrecision *= scaleFactor;
345 mYPrecision *= scaleFactor;
346
347 size_t numSamples = mSamplePointerCoords.size();
348 for (size_t i = 0; i < numSamples; i++) {
349 mSamplePointerCoords.editItemAt(i).scale(scaleFactor);
350 }
351 }
352
transformPoint(const float matrix[9],float x,float y,float * outX,float * outY)353 static void transformPoint(const float matrix[9], float x, float y, float *outX, float *outY) {
354 // Apply perspective transform like Skia.
355 float newX = matrix[0] * x + matrix[1] * y + matrix[2];
356 float newY = matrix[3] * x + matrix[4] * y + matrix[5];
357 float newZ = matrix[6] * x + matrix[7] * y + matrix[8];
358 if (newZ) {
359 newZ = 1.0f / newZ;
360 }
361 *outX = newX * newZ;
362 *outY = newY * newZ;
363 }
364
transformAngle(const float matrix[9],float angleRadians,float originX,float originY)365 static float transformAngle(const float matrix[9], float angleRadians,
366 float originX, float originY) {
367 // Construct and transform a vector oriented at the specified clockwise angle from vertical.
368 // Coordinate system: down is increasing Y, right is increasing X.
369 float x = sinf(angleRadians);
370 float y = -cosf(angleRadians);
371 transformPoint(matrix, x, y, &x, &y);
372 x -= originX;
373 y -= originY;
374
375 // Derive the transformed vector's clockwise angle from vertical.
376 float result = atan2f(x, -y);
377 if (result < - M_PI_2) {
378 result += M_PI;
379 } else if (result > M_PI_2) {
380 result -= M_PI;
381 }
382 return result;
383 }
384
transform(const float matrix[9])385 void MotionEvent::transform(const float matrix[9]) {
386 // The tricky part of this implementation is to preserve the value of
387 // rawX and rawY. So we apply the transformation to the first point
388 // then derive an appropriate new X/Y offset that will preserve rawX
389 // and rawY for that point.
390 float oldXOffset = mXOffset;
391 float oldYOffset = mYOffset;
392 float newX, newY;
393 float rawX = getRawX(0);
394 float rawY = getRawY(0);
395 transformPoint(matrix, rawX + oldXOffset, rawY + oldYOffset, &newX, &newY);
396 mXOffset = newX - rawX;
397 mYOffset = newY - rawY;
398
399 // Determine how the origin is transformed by the matrix so that we
400 // can transform orientation vectors.
401 float originX, originY;
402 transformPoint(matrix, 0, 0, &originX, &originY);
403
404 // Apply the transformation to all samples.
405 size_t numSamples = mSamplePointerCoords.size();
406 for (size_t i = 0; i < numSamples; i++) {
407 PointerCoords& c = mSamplePointerCoords.editItemAt(i);
408 float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) + oldXOffset;
409 float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) + oldYOffset;
410 transformPoint(matrix, x, y, &x, &y);
411 c.setAxisValue(AMOTION_EVENT_AXIS_X, x - mXOffset);
412 c.setAxisValue(AMOTION_EVENT_AXIS_Y, y - mYOffset);
413
414 float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
415 c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,
416 transformAngle(matrix, orientation, originX, originY));
417 }
418 }
419
420 #ifdef HAVE_ANDROID_OS
readFromParcel(Parcel * parcel)421 status_t MotionEvent::readFromParcel(Parcel* parcel) {
422 size_t pointerCount = parcel->readInt32();
423 size_t sampleCount = parcel->readInt32();
424 if (pointerCount == 0 || pointerCount > MAX_POINTERS || sampleCount == 0) {
425 return BAD_VALUE;
426 }
427
428 mDeviceId = parcel->readInt32();
429 mSource = parcel->readInt32();
430 mAction = parcel->readInt32();
431 mFlags = parcel->readInt32();
432 mEdgeFlags = parcel->readInt32();
433 mMetaState = parcel->readInt32();
434 mButtonState = parcel->readInt32();
435 mXOffset = parcel->readFloat();
436 mYOffset = parcel->readFloat();
437 mXPrecision = parcel->readFloat();
438 mYPrecision = parcel->readFloat();
439 mDownTime = parcel->readInt64();
440
441 mPointerProperties.clear();
442 mPointerProperties.setCapacity(pointerCount);
443 mSampleEventTimes.clear();
444 mSampleEventTimes.setCapacity(sampleCount);
445 mSamplePointerCoords.clear();
446 mSamplePointerCoords.setCapacity(sampleCount * pointerCount);
447
448 for (size_t i = 0; i < pointerCount; i++) {
449 mPointerProperties.push();
450 PointerProperties& properties = mPointerProperties.editTop();
451 properties.id = parcel->readInt32();
452 properties.toolType = parcel->readInt32();
453 }
454
455 while (sampleCount-- > 0) {
456 mSampleEventTimes.push(parcel->readInt64());
457 for (size_t i = 0; i < pointerCount; i++) {
458 mSamplePointerCoords.push();
459 status_t status = mSamplePointerCoords.editTop().readFromParcel(parcel);
460 if (status) {
461 return status;
462 }
463 }
464 }
465 return OK;
466 }
467
writeToParcel(Parcel * parcel) const468 status_t MotionEvent::writeToParcel(Parcel* parcel) const {
469 size_t pointerCount = mPointerProperties.size();
470 size_t sampleCount = mSampleEventTimes.size();
471
472 parcel->writeInt32(pointerCount);
473 parcel->writeInt32(sampleCount);
474
475 parcel->writeInt32(mDeviceId);
476 parcel->writeInt32(mSource);
477 parcel->writeInt32(mAction);
478 parcel->writeInt32(mFlags);
479 parcel->writeInt32(mEdgeFlags);
480 parcel->writeInt32(mMetaState);
481 parcel->writeInt32(mButtonState);
482 parcel->writeFloat(mXOffset);
483 parcel->writeFloat(mYOffset);
484 parcel->writeFloat(mXPrecision);
485 parcel->writeFloat(mYPrecision);
486 parcel->writeInt64(mDownTime);
487
488 for (size_t i = 0; i < pointerCount; i++) {
489 const PointerProperties& properties = mPointerProperties.itemAt(i);
490 parcel->writeInt32(properties.id);
491 parcel->writeInt32(properties.toolType);
492 }
493
494 const PointerCoords* pc = mSamplePointerCoords.array();
495 for (size_t h = 0; h < sampleCount; h++) {
496 parcel->writeInt64(mSampleEventTimes.itemAt(h));
497 for (size_t i = 0; i < pointerCount; i++) {
498 status_t status = (pc++)->writeToParcel(parcel);
499 if (status) {
500 return status;
501 }
502 }
503 }
504 return OK;
505 }
506 #endif
507
isTouchEvent(int32_t source,int32_t action)508 bool MotionEvent::isTouchEvent(int32_t source, int32_t action) {
509 if (source & AINPUT_SOURCE_CLASS_POINTER) {
510 // Specifically excludes HOVER_MOVE and SCROLL.
511 switch (action & AMOTION_EVENT_ACTION_MASK) {
512 case AMOTION_EVENT_ACTION_DOWN:
513 case AMOTION_EVENT_ACTION_MOVE:
514 case AMOTION_EVENT_ACTION_UP:
515 case AMOTION_EVENT_ACTION_POINTER_DOWN:
516 case AMOTION_EVENT_ACTION_POINTER_UP:
517 case AMOTION_EVENT_ACTION_CANCEL:
518 case AMOTION_EVENT_ACTION_OUTSIDE:
519 return true;
520 }
521 }
522 return false;
523 }
524
getLabel(int32_t axis)525 const char* MotionEvent::getLabel(int32_t axis) {
526 return getAxisLabel(axis);
527 }
528
getAxisFromLabel(const char * label)529 int32_t MotionEvent::getAxisFromLabel(const char* label) {
530 return getAxisByLabel(label);
531 }
532
533
534 // --- PooledInputEventFactory ---
535
PooledInputEventFactory(size_t maxPoolSize)536 PooledInputEventFactory::PooledInputEventFactory(size_t maxPoolSize) :
537 mMaxPoolSize(maxPoolSize) {
538 }
539
~PooledInputEventFactory()540 PooledInputEventFactory::~PooledInputEventFactory() {
541 for (size_t i = 0; i < mKeyEventPool.size(); i++) {
542 delete mKeyEventPool.itemAt(i);
543 }
544 for (size_t i = 0; i < mMotionEventPool.size(); i++) {
545 delete mMotionEventPool.itemAt(i);
546 }
547 }
548
createKeyEvent()549 KeyEvent* PooledInputEventFactory::createKeyEvent() {
550 if (!mKeyEventPool.isEmpty()) {
551 KeyEvent* event = mKeyEventPool.top();
552 mKeyEventPool.pop();
553 return event;
554 }
555 return new KeyEvent();
556 }
557
createMotionEvent()558 MotionEvent* PooledInputEventFactory::createMotionEvent() {
559 if (!mMotionEventPool.isEmpty()) {
560 MotionEvent* event = mMotionEventPool.top();
561 mMotionEventPool.pop();
562 return event;
563 }
564 return new MotionEvent();
565 }
566
recycle(InputEvent * event)567 void PooledInputEventFactory::recycle(InputEvent* event) {
568 switch (event->getType()) {
569 case AINPUT_EVENT_TYPE_KEY:
570 if (mKeyEventPool.size() < mMaxPoolSize) {
571 mKeyEventPool.push(static_cast<KeyEvent*>(event));
572 return;
573 }
574 break;
575 case AINPUT_EVENT_TYPE_MOTION:
576 if (mMotionEventPool.size() < mMaxPoolSize) {
577 mMotionEventPool.push(static_cast<MotionEvent*>(event));
578 return;
579 }
580 break;
581 }
582 delete event;
583 }
584
585 } // namespace android
586