The Tor Browser: widget/gonk/libui/InputListener.cpp@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /*

     2  * Copyright (C) 2011 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  */

    17 #define LOG_TAG "InputListener"

    19 //#define LOG_NDEBUG 0

    21 #include "InputListener.h"

    23 #include "cutils_log.h"

    25 namespace android {

    27 // --- NotifyConfigurationChangedArgs ---

    29 NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(nsecs_t eventTime) :

    30         eventTime(eventTime) {

    31 }

    33 NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(

    34         const NotifyConfigurationChangedArgs& other) :

    35         eventTime(other.eventTime) {

    36 }

    38 void NotifyConfigurationChangedArgs::notify(const sp<InputListenerInterface>& listener) const {

    39     listener->notifyConfigurationChanged(this);

    40 }

    43 // --- NotifyKeyArgs ---

    45 NotifyKeyArgs::NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,

    46         uint32_t policyFlags,

    47         int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,

    48         int32_t metaState, nsecs_t downTime) :

    49         eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),

    50         action(action), flags(flags), keyCode(keyCode), scanCode(scanCode),

    51         metaState(metaState), downTime(downTime) {

    52 }

    54 NotifyKeyArgs::NotifyKeyArgs(const NotifyKeyArgs& other) :

    55         eventTime(other.eventTime), deviceId(other.deviceId), source(other.source),

    56         policyFlags(other.policyFlags),

    57         action(other.action), flags(other.flags),

    58         keyCode(other.keyCode), scanCode(other.scanCode),

    59         metaState(other.metaState), downTime(other.downTime) {

    60 }

    62 void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {

    63     listener->notifyKey(this);

    64 }

    67 // --- NotifyMotionArgs ---

    69 NotifyMotionArgs::NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,

    70         uint32_t policyFlags,

    71         int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,

    72         int32_t edgeFlags, int32_t displayId, uint32_t pointerCount,

    73         const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,

    74         float xPrecision, float yPrecision, nsecs_t downTime) :

    75         eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),

    76         action(action), flags(flags), metaState(metaState), buttonState(buttonState),

    77         edgeFlags(edgeFlags), displayId(displayId), pointerCount(pointerCount),

    78         xPrecision(xPrecision), yPrecision(yPrecision), downTime(downTime) {

    79     for (uint32_t i = 0; i < pointerCount; i++) {

    80         this->pointerProperties[i].copyFrom(pointerProperties[i]);

    81         this->pointerCoords[i].copyFrom(pointerCoords[i]);

    82     }

    83 }

    85 NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other) :

    86         eventTime(other.eventTime), deviceId(other.deviceId), source(other.source),

    87         policyFlags(other.policyFlags),

    88         action(other.action), flags(other.flags),

    89         metaState(other.metaState), buttonState(other.buttonState),

    90         edgeFlags(other.edgeFlags), displayId(other.displayId),

    91         pointerCount(other.pointerCount),

    92         xPrecision(other.xPrecision), yPrecision(other.yPrecision), downTime(other.downTime) {

    93     for (uint32_t i = 0; i < pointerCount; i++) {

    94         pointerProperties[i].copyFrom(other.pointerProperties[i]);

    95         pointerCoords[i].copyFrom(other.pointerCoords[i]);

    96     }

    97 }

    99 void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {

   100     listener->notifyMotion(this);

   101 }

   104 // --- NotifySwitchArgs ---

   106 NotifySwitchArgs::NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,

   107         uint32_t switchValues, uint32_t switchMask) :

   108         eventTime(eventTime), policyFlags(policyFlags),

   109         switchValues(switchValues), switchMask(switchMask) {

   110 }

   112 NotifySwitchArgs::NotifySwitchArgs(const NotifySwitchArgs& other) :

   113         eventTime(other.eventTime), policyFlags(other.policyFlags),

   114         switchValues(other.switchValues), switchMask(other.switchMask) {

   115 }

   117 void NotifySwitchArgs::notify(const sp<InputListenerInterface>& listener) const {

   118     listener->notifySwitch(this);

   119 }

   122 // --- NotifyDeviceResetArgs ---

   124 NotifyDeviceResetArgs::NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId) :

   125         eventTime(eventTime), deviceId(deviceId) {

   126 }

   128 NotifyDeviceResetArgs::NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other) :

   129         eventTime(other.eventTime), deviceId(other.deviceId) {

   130 }

   132 void NotifyDeviceResetArgs::notify(const sp<InputListenerInterface>& listener) const {

   133     listener->notifyDeviceReset(this);

   134 }

   137 // --- QueuedInputListener ---

   139 QueuedInputListener::QueuedInputListener(const sp<InputListenerInterface>& innerListener) :

   140         mInnerListener(innerListener) {

   141 }

   143 QueuedInputListener::~QueuedInputListener() {

   144     size_t count = mArgsQueue.size();

   145     for (size_t i = 0; i < count; i++) {

   146         delete mArgsQueue[i];

   147     }

   148 }

   150 void QueuedInputListener::notifyConfigurationChanged(

   151         const NotifyConfigurationChangedArgs* args) {

   152     mArgsQueue.push(new NotifyConfigurationChangedArgs(*args));

   153 }

   155 void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {

   156     mArgsQueue.push(new NotifyKeyArgs(*args));

   157 }

   159 void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {

   160     mArgsQueue.push(new NotifyMotionArgs(*args));

   161 }

   163 void QueuedInputListener::notifySwitch(const NotifySwitchArgs* args) {

   164     mArgsQueue.push(new NotifySwitchArgs(*args));

   165 }

   167 void QueuedInputListener::notifyDeviceReset(const NotifyDeviceResetArgs* args) {

   168     mArgsQueue.push(new NotifyDeviceResetArgs(*args));

   169 }

   171 void QueuedInputListener::flush() {

   172     size_t count = mArgsQueue.size();

   173     for (size_t i = 0; i < count; i++) {

   174         NotifyArgs* args = mArgsQueue[i];

   175         args->notify(mInnerListener);

   176         delete args;

   177     }

   178     mArgsQueue.clear();

   179 }

   182 } // namespace android

The Tor Browser / file revision