The Tor Browser / file revision

 /*

  * Copyright (C) 2010 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 #define LOG_TAG "Input"

 //#define LOG_NDEBUG 0

 #include "cutils_log.h"

 #include <math.h>

 #include <limits.h>

 #include "Input.h"

 #ifdef HAVE_ANDROID_OS

 #include <binder/Parcel.h>

 #include "SkPoint.h"

 #include "SkMatrix.h"

 #include "SkScalar.h"

 #endif

 namespace android {

 // --- InputEvent ---

 void InputEvent::initialize(int32_t deviceId, int32_t source) {

     mDeviceId = deviceId;

     mSource = source;

 }

 void InputEvent::initialize(const InputEvent& from) {

     mDeviceId = from.mDeviceId;

     mSource = from.mSource;

 }

 // --- KeyEvent ---

 bool KeyEvent::hasDefaultAction(int32_t keyCode) {

     switch (keyCode) {

         case AKEYCODE_HOME:

         case AKEYCODE_BACK:

         case AKEYCODE_CALL:

         case AKEYCODE_ENDCALL:

         case AKEYCODE_VOLUME_UP:

         case AKEYCODE_VOLUME_DOWN:

         case AKEYCODE_VOLUME_MUTE:

         case AKEYCODE_POWER:

         case AKEYCODE_CAMERA:

         case AKEYCODE_HEADSETHOOK:

         case AKEYCODE_MENU:

         case AKEYCODE_NOTIFICATION:

         case AKEYCODE_FOCUS:

         case AKEYCODE_SEARCH:

         case AKEYCODE_MEDIA_PLAY:

         case AKEYCODE_MEDIA_PAUSE:

         case AKEYCODE_MEDIA_PLAY_PAUSE:

         case AKEYCODE_MEDIA_STOP:

         case AKEYCODE_MEDIA_NEXT:

         case AKEYCODE_MEDIA_PREVIOUS:

         case AKEYCODE_MEDIA_REWIND:

         case AKEYCODE_MEDIA_RECORD:

         case AKEYCODE_MEDIA_FAST_FORWARD:

         case AKEYCODE_MUTE:

         case AKEYCODE_BRIGHTNESS_DOWN:

         case AKEYCODE_BRIGHTNESS_UP:

             return true;

     }

     return false;

 }

 bool KeyEvent::hasDefaultAction() const {

     return hasDefaultAction(getKeyCode());

 }

 bool KeyEvent::isSystemKey(int32_t keyCode) {

     switch (keyCode) {

         case AKEYCODE_MENU:

         case AKEYCODE_SOFT_RIGHT:

         case AKEYCODE_HOME:

         case AKEYCODE_BACK:

         case AKEYCODE_CALL:

         case AKEYCODE_ENDCALL:

         case AKEYCODE_VOLUME_UP:

         case AKEYCODE_VOLUME_DOWN:

         case AKEYCODE_VOLUME_MUTE:

         case AKEYCODE_MUTE:

         case AKEYCODE_POWER:

         case AKEYCODE_HEADSETHOOK:

         case AKEYCODE_MEDIA_PLAY:

         case AKEYCODE_MEDIA_PAUSE:

         case AKEYCODE_MEDIA_PLAY_PAUSE:

         case AKEYCODE_MEDIA_STOP:

         case AKEYCODE_MEDIA_NEXT:

         case AKEYCODE_MEDIA_PREVIOUS:

         case AKEYCODE_MEDIA_REWIND:

         case AKEYCODE_MEDIA_RECORD:

         case AKEYCODE_MEDIA_FAST_FORWARD:

         case AKEYCODE_CAMERA:

         case AKEYCODE_FOCUS:

         case AKEYCODE_SEARCH:

         case AKEYCODE_BRIGHTNESS_DOWN:

         case AKEYCODE_BRIGHTNESS_UP:

             return true;

     }

     return false;

 }

 bool KeyEvent::isSystemKey() const {

     return isSystemKey(getKeyCode());

 }

 void KeyEvent::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) {

     InputEvent::initialize(deviceId, source);

     mAction = action;

     mFlags = flags;

     mKeyCode = keyCode;

     mScanCode = scanCode;

     mMetaState = metaState;

     mRepeatCount = repeatCount;

     mDownTime = downTime;

     mEventTime = eventTime;

 }

 void KeyEvent::initialize(const KeyEvent& from) {

     InputEvent::initialize(from);

     mAction = from.mAction;

     mFlags = from.mFlags;

     mKeyCode = from.mKeyCode;

     mScanCode = from.mScanCode;

     mMetaState = from.mMetaState;

     mRepeatCount = from.mRepeatCount;

     mDownTime = from.mDownTime;

     mEventTime = from.mEventTime;

 }

 // --- PointerCoords ---

 float PointerCoords::getAxisValue(int32_t axis) const {

     if (axis < 0 || axis > 63) {

         return 0;

     }

     uint64_t axisBit = 1LL << axis;

     if (!(bits & axisBit)) {

         return 0;

     }

     uint32_t index = __builtin_popcountll(bits & (axisBit - 1LL));

     return values[index];

 }

 status_t PointerCoords::setAxisValue(int32_t axis, float value) {

     if (axis < 0 || axis > 63) {

         return NAME_NOT_FOUND;

     }

     uint64_t axisBit = 1LL << axis;

     uint32_t index = __builtin_popcountll(bits & (axisBit - 1LL));

     if (!(bits & axisBit)) {

         if (value == 0) {

             return OK; // axes with value 0 do not need to be stored

         }

         uint32_t count = __builtin_popcountll(bits);

         if (count >= MAX_AXES) {

             tooManyAxes(axis);

             return NO_MEMORY;

         }

         bits |= axisBit;

         for (uint32_t i = count; i > index; i--) {

             values[i] = values[i - 1];

         }

     }

     values[index] = value;

     return OK;

 }

 static inline void scaleAxisValue(PointerCoords& c, int axis, float scaleFactor) {

     float value = c.getAxisValue(axis);

     if (value != 0) {

         c.setAxisValue(axis, value * scaleFactor);

     }

 }

 void PointerCoords::scale(float scaleFactor) {

     // No need to scale pressure or size since they are normalized.

     // No need to scale orientation since it is meaningless to do so.

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_X, scaleFactor);

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_Y, scaleFactor);

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MAJOR, scaleFactor);

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOUCH_MINOR, scaleFactor);

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MAJOR, scaleFactor);

     scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MINOR, scaleFactor);

 }

 #ifdef HAVE_ANDROID_OS

 status_t PointerCoords::readFromParcel(Parcel* parcel) {

     bits = parcel->readInt64();

     uint32_t count = __builtin_popcountll(bits);

     if (count > MAX_AXES) {

         return BAD_VALUE;

     }

     for (uint32_t i = 0; i < count; i++) {

         values[i] = parcel->readFloat();

     }

     return OK;

 }

 status_t PointerCoords::writeToParcel(Parcel* parcel) const {

     parcel->writeInt64(bits);

     uint32_t count = __builtin_popcountll(bits);

     for (uint32_t i = 0; i < count; i++) {

         parcel->writeFloat(values[i]);

     }

     return OK;

 }

 #endif

 void PointerCoords::tooManyAxes(int axis) {

     ALOGW("Could not set value for axis %d because the PointerCoords structure is full and "

             "cannot contain more than %d axis values.", axis, int(MAX_AXES));

 }

 bool PointerCoords::operator==(const PointerCoords& other) const {

     if (bits != other.bits) {

         return false;

     }

     uint32_t count = __builtin_popcountll(bits);

     for (uint32_t i = 0; i < count; i++) {

         if (values[i] != other.values[i]) {

             return false;

         }

     }

     return true;

 }

 void PointerCoords::copyFrom(const PointerCoords& other) {

     bits = other.bits;

     uint32_t count = __builtin_popcountll(bits);

     for (uint32_t i = 0; i < count; i++) {

         values[i] = other.values[i];

     }

 }

 // --- PointerProperties ---

 bool PointerProperties::operator==(const PointerProperties& other) const {

     return id == other.id

             && toolType == other.toolType;

 }

 void PointerProperties::copyFrom(const PointerProperties& other) {

     id = other.id;

     toolType = other.toolType;

 }

 // --- MotionEvent ---

 void MotionEvent::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) {

     InputEvent::initialize(deviceId, source);

     mAction = action;

     mFlags = flags;

     mEdgeFlags = edgeFlags;

     mMetaState = metaState;

     mButtonState = buttonState;

     mXOffset = xOffset;

     mYOffset = yOffset;

     mXPrecision = xPrecision;

     mYPrecision = yPrecision;

     mDownTime = downTime;

     mPointerProperties.clear();

     mPointerProperties.appendArray(pointerProperties, pointerCount);

     mSampleEventTimes.clear();

     mSamplePointerCoords.clear();

     addSample(eventTime, pointerCoords);

 }

 void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {

     InputEvent::initialize(other->mDeviceId, other->mSource);

     mAction = other->mAction;

     mFlags = other->mFlags;

     mEdgeFlags = other->mEdgeFlags;

     mMetaState = other->mMetaState;

     mButtonState = other->mButtonState;

     mXOffset = other->mXOffset;

     mYOffset = other->mYOffset;

     mXPrecision = other->mXPrecision;

     mYPrecision = other->mYPrecision;

     mDownTime = other->mDownTime;

     mPointerProperties = other->mPointerProperties;

     if (keepHistory) {

         mSampleEventTimes = other->mSampleEventTimes;

         mSamplePointerCoords = other->mSamplePointerCoords;

     } else {

         mSampleEventTimes.clear();

         mSampleEventTimes.push(other->getEventTime());

         mSamplePointerCoords.clear();

         size_t pointerCount = other->getPointerCount();

         size_t historySize = other->getHistorySize();

         mSamplePointerCoords.appendArray(other->mSamplePointerCoords.array()

                 + (historySize * pointerCount), pointerCount);

     }

 }

 void MotionEvent::addSample(

         int64_t eventTime,

         const PointerCoords* pointerCoords) {

     mSampleEventTimes.push(eventTime);

     mSamplePointerCoords.appendArray(pointerCoords, getPointerCount());

 }

 const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {

     return &mSamplePointerCoords[getHistorySize() * getPointerCount() + pointerIndex];

 }

 float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {

     return getRawPointerCoords(pointerIndex)->getAxisValue(axis);

 }

 float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {

     float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);

     switch (axis) {

     case AMOTION_EVENT_AXIS_X:

         return value + mXOffset;

     case AMOTION_EVENT_AXIS_Y:

         return value + mYOffset;

     }

     return value;

 }

 const PointerCoords* MotionEvent::getHistoricalRawPointerCoords(

         size_t pointerIndex, size_t historicalIndex) const {

     return &mSamplePointerCoords[historicalIndex * getPointerCount() + pointerIndex];

 }

 float MotionEvent::getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,

         size_t historicalIndex) const {

     return getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);

 }

 float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,

         size_t historicalIndex) const {

     float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);

     switch (axis) {

     case AMOTION_EVENT_AXIS_X:

         return value + mXOffset;

     case AMOTION_EVENT_AXIS_Y:

         return value + mYOffset;

     }

     return value;

 }

 ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {

     size_t pointerCount = mPointerProperties.size();

     for (size_t i = 0; i < pointerCount; i++) {

         if (mPointerProperties.itemAt(i).id == pointerId) {

             return i;

         }

     }

     return -1;

 }

 void MotionEvent::offsetLocation(float xOffset, float yOffset) {

     mXOffset += xOffset;

     mYOffset += yOffset;

 }

 void MotionEvent::scale(float scaleFactor) {

     mXOffset *= scaleFactor;

     mYOffset *= scaleFactor;

     mXPrecision *= scaleFactor;

     mYPrecision *= scaleFactor;

     size_t numSamples = mSamplePointerCoords.size();

     for (size_t i = 0; i < numSamples; i++) {

         mSamplePointerCoords.editItemAt(i).scale(scaleFactor);

     }

 }

 #ifdef HAVE_ANDROID_OS

 static inline float transformAngle(const SkMatrix* matrix, float angleRadians) {

     // Construct and transform a vector oriented at the specified clockwise angle from vertical.

     // Coordinate system: down is increasing Y, right is increasing X.

     SkPoint vector;

     vector.fX = SkFloatToScalar(sinf(angleRadians));

     vector.fY = SkFloatToScalar(-cosf(angleRadians));

     matrix->mapVectors(& vector, 1);

     // Derive the transformed vector's clockwise angle from vertical.

     float result = atan2f(SkScalarToFloat(vector.fX), SkScalarToFloat(-vector.fY));

     if (result < - M_PI_2) {

         result += M_PI;

     } else if (result > M_PI_2) {

         result -= M_PI;

     }

     return result;

 }

 void MotionEvent::transform(const SkMatrix* matrix) {

     float oldXOffset = mXOffset;

     float oldYOffset = mYOffset;

     // The tricky part of this implementation is to preserve the value of

     // rawX and rawY.  So we apply the transformation to the first point

     // then derive an appropriate new X/Y offset that will preserve rawX and rawY.

     SkPoint point;

     float rawX = getRawX(0);

     float rawY = getRawY(0);

     matrix->mapXY(SkFloatToScalar(rawX + oldXOffset), SkFloatToScalar(rawY + oldYOffset),

             & point);

     float newX = SkScalarToFloat(point.fX);

     float newY = SkScalarToFloat(point.fY);

     float newXOffset = newX - rawX;

     float newYOffset = newY - rawY;

     mXOffset = newXOffset;

     mYOffset = newYOffset;

     // Apply the transformation to all samples.

     size_t numSamples = mSamplePointerCoords.size();

     for (size_t i = 0; i < numSamples; i++) {

         PointerCoords& c = mSamplePointerCoords.editItemAt(i);

         float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) + oldXOffset;

         float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) + oldYOffset;

         matrix->mapXY(SkFloatToScalar(x), SkFloatToScalar(y), &point);

         c.setAxisValue(AMOTION_EVENT_AXIS_X, SkScalarToFloat(point.fX) - newXOffset);

         c.setAxisValue(AMOTION_EVENT_AXIS_Y, SkScalarToFloat(point.fY) - newYOffset);

         float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);

         c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, transformAngle(matrix, orientation));

     }

 }

 status_t MotionEvent::readFromParcel(Parcel* parcel) {

     size_t pointerCount = parcel->readInt32();

     size_t sampleCount = parcel->readInt32();

     if (pointerCount == 0 || pointerCount > MAX_POINTERS || sampleCount == 0) {

         return BAD_VALUE;

     }

     mDeviceId = parcel->readInt32();

     mSource = parcel->readInt32();

     mAction = parcel->readInt32();

     mFlags = parcel->readInt32();

     mEdgeFlags = parcel->readInt32();

     mMetaState = parcel->readInt32();

     mButtonState = parcel->readInt32();

     mXOffset = parcel->readFloat();

     mYOffset = parcel->readFloat();

     mXPrecision = parcel->readFloat();

     mYPrecision = parcel->readFloat();

     mDownTime = parcel->readInt64();

     mPointerProperties.clear();

     mPointerProperties.setCapacity(pointerCount);

     mSampleEventTimes.clear();

     mSampleEventTimes.setCapacity(sampleCount);

     mSamplePointerCoords.clear();

     mSamplePointerCoords.setCapacity(sampleCount * pointerCount);

     for (size_t i = 0; i < pointerCount; i++) {

         mPointerProperties.push();

         PointerProperties& properties = mPointerProperties.editTop();

         properties.id = parcel->readInt32();

         properties.toolType = parcel->readInt32();

     }

     while (sampleCount-- > 0) {

         mSampleEventTimes.push(parcel->readInt64());

         for (size_t i = 0; i < pointerCount; i++) {

             mSamplePointerCoords.push();

             status_t status = mSamplePointerCoords.editTop().readFromParcel(parcel);

             if (status) {

                 return status;

             }

         }

     }

     return OK;

 }

 status_t MotionEvent::writeToParcel(Parcel* parcel) const {

     size_t pointerCount = mPointerProperties.size();

     size_t sampleCount = mSampleEventTimes.size();

     parcel->writeInt32(pointerCount);

     parcel->writeInt32(sampleCount);

     parcel->writeInt32(mDeviceId);

     parcel->writeInt32(mSource);

     parcel->writeInt32(mAction);

     parcel->writeInt32(mFlags);

     parcel->writeInt32(mEdgeFlags);

     parcel->writeInt32(mMetaState);

     parcel->writeInt32(mButtonState);

     parcel->writeFloat(mXOffset);

     parcel->writeFloat(mYOffset);

     parcel->writeFloat(mXPrecision);

     parcel->writeFloat(mYPrecision);

     parcel->writeInt64(mDownTime);

     for (size_t i = 0; i < pointerCount; i++) {

         const PointerProperties& properties = mPointerProperties.itemAt(i);

         parcel->writeInt32(properties.id);

         parcel->writeInt32(properties.toolType);

     }

     const PointerCoords* pc = mSamplePointerCoords.array();

     for (size_t h = 0; h < sampleCount; h++) {

         parcel->writeInt64(mSampleEventTimes.itemAt(h));

         for (size_t i = 0; i < pointerCount; i++) {

             status_t status = (pc++)->writeToParcel(parcel);

             if (status) {

                 return status;

             }

         }

     }

     return OK;

 }

 #endif

 bool MotionEvent::isTouchEvent(int32_t source, int32_t action) {

     if (source & AINPUT_SOURCE_CLASS_POINTER) {

         // Specifically excludes HOVER_MOVE and SCROLL.

         switch (action & AMOTION_EVENT_ACTION_MASK) {

         case AMOTION_EVENT_ACTION_DOWN:

         case AMOTION_EVENT_ACTION_MOVE:

         case AMOTION_EVENT_ACTION_UP:

         case AMOTION_EVENT_ACTION_POINTER_DOWN:

         case AMOTION_EVENT_ACTION_POINTER_UP:

         case AMOTION_EVENT_ACTION_CANCEL:

         case AMOTION_EVENT_ACTION_OUTSIDE:

             return true;

         }

     }

     return false;

 }

 // --- PooledInputEventFactory ---

 PooledInputEventFactory::PooledInputEventFactory(size_t maxPoolSize) :

         mMaxPoolSize(maxPoolSize) {

 }

 PooledInputEventFactory::~PooledInputEventFactory() {

     for (size_t i = 0; i < mKeyEventPool.size(); i++) {

         delete mKeyEventPool.itemAt(i);

     }

     for (size_t i = 0; i < mMotionEventPool.size(); i++) {

         delete mMotionEventPool.itemAt(i);

     }

 }

 KeyEvent* PooledInputEventFactory::createKeyEvent() {

     if (!mKeyEventPool.isEmpty()) {

         KeyEvent* event = mKeyEventPool.top();

         mKeyEventPool.pop();

         return event;

     }

     return new KeyEvent();

 }

 MotionEvent* PooledInputEventFactory::createMotionEvent() {

     if (!mMotionEventPool.isEmpty()) {

         MotionEvent* event = mMotionEventPool.top();

         mMotionEventPool.pop();

         return event;

     }

     return new MotionEvent();

 }

 void PooledInputEventFactory::recycle(InputEvent* event) {

     switch (event->getType()) {

     case AINPUT_EVENT_TYPE_KEY:

         if (mKeyEventPool.size() < mMaxPoolSize) {

             mKeyEventPool.push(static_cast<KeyEvent*>(event));

             return;

         }

         break;

     case AINPUT_EVENT_TYPE_MOTION:

         if (mMotionEventPool.size() < mMaxPoolSize) {

             mMotionEventPool.push(static_cast<MotionEvent*>(event));

             return;

         }

         break;

     }

     delete event;

 }

 } // namespace android