services/input/InputListener.h

   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  */
  16
  17 #ifndef _UI_INPUT_LISTENER_H
  18 #define _UI_INPUT_LISTENER_H
  19
  20 #include <androidfw/Input.h>
  21 #include <utils/RefBase.h>
  22 #include <utils/Vector.h>
  23
  24 namespace android {
  25
  26 class InputListenerInterface;
  27
  28
  29 /* Superclass of all input event argument objects */
  30 struct NotifyArgs {
  31     virtual ~NotifyArgs() { }
  32
  33     virtual void notify(const sp<InputListenerInterface>& listener) const = 0;
  34 };
  35
  36
  37 /* Describes a configuration change event. */
  38 struct NotifyConfigurationChangedArgs : public NotifyArgs {
  39     nsecs_t eventTime;
  40
  41     inline NotifyConfigurationChangedArgs() { }
  42
  43     NotifyConfigurationChangedArgs(nsecs_t eventTime);
  44
  45     NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other);
  46
  47     virtual ~NotifyConfigurationChangedArgs() { }
  48
  49     virtual void notify(const sp<InputListenerInterface>& listener) const;
  50 };
  51
  52
  53 /* Describes a key event. */
  54 struct NotifyKeyArgs : public NotifyArgs {
  55     nsecs_t eventTime;
  56     int32_t deviceId;
  57     uint32_t source;
  58     uint32_t policyFlags;
  59     int32_t action;
  60     int32_t flags;
  61     int32_t keyCode;
  62     int32_t scanCode;
  63     int32_t metaState;
  64     nsecs_t downTime;
  65
  66     inline NotifyKeyArgs() { }
  67
  68     NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
  69             int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
  70             int32_t metaState, nsecs_t downTime);
  71
  72     NotifyKeyArgs(const NotifyKeyArgs& other);
  73
  74     virtual ~NotifyKeyArgs() { }
  75
  76     virtual void notify(const sp<InputListenerInterface>& listener) const;
  77 };
  78
  79
  80 /* Describes a motion event. */
  81 struct NotifyMotionArgs : public NotifyArgs {
  82     nsecs_t eventTime;
  83     int32_t deviceId;
  84     uint32_t source;
  85     uint32_t policyFlags;
  86     int32_t action;
  87     int32_t flags;
  88     int32_t metaState;
  89     int32_t buttonState;
  90     int32_t edgeFlags;
  91     int32_t displayId;
  92     uint32_t pointerCount;
  93     PointerProperties pointerProperties[MAX_POINTERS];
  94     PointerCoords pointerCoords[MAX_POINTERS];
  95     float xPrecision;
  96     float yPrecision;
  97     nsecs_t downTime;
  98
  99     inline NotifyMotionArgs() { }
 100
 101     NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
 102             int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
 103             int32_t edgeFlags, int32_t displayId, uint32_t pointerCount,
 104             const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
 105             float xPrecision, float yPrecision, nsecs_t downTime);
 106
 107     NotifyMotionArgs(const NotifyMotionArgs& other);
 108
 109     virtual ~NotifyMotionArgs() { }
 110
 111     virtual void notify(const sp<InputListenerInterface>& listener) const;
 112 };
 113
 114
 115 /* Describes a switch event. */
 116 struct NotifySwitchArgs : public NotifyArgs {
 117     nsecs_t eventTime;
 118     uint32_t policyFlags;
 119     uint32_t switchValues;
 120     uint32_t switchMask;
 121
 122     inline NotifySwitchArgs() { }
 123
 124     NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
 125             uint32_t switchValues, uint32_t switchMask);
 126
 127     NotifySwitchArgs(const NotifySwitchArgs& other);
 128
 129     virtual ~NotifySwitchArgs() { }
 130
 131     virtual void notify(const sp<InputListenerInterface>& listener) const;
 132 };
 133
 134
 135 /* Describes a device reset event, such as when a device is added,
 136  * reconfigured, or removed. */
 137 struct NotifyDeviceResetArgs : public NotifyArgs {
 138     nsecs_t eventTime;
 139     int32_t deviceId;
 140
 141     inline NotifyDeviceResetArgs() { }
 142
 143     NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId);
 144
 145     NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other);
 146
 147     virtual ~NotifyDeviceResetArgs() { }
 148
 149     virtual void notify(const sp<InputListenerInterface>& listener) const;
 150 };
 151
 152
 153 /*
 154  * The interface used by the InputReader to notify the InputListener about input events.
 155  */
 156 class InputListenerInterface : public virtual RefBase {
 157 protected:
 158     InputListenerInterface() { }
 159     virtual ~InputListenerInterface() { }
 160
 161 public:
 162     virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) = 0;
 163     virtual void notifyKey(const NotifyKeyArgs* args) = 0;
 164     virtual void notifyMotion(const NotifyMotionArgs* args) = 0;
 165     virtual void notifySwitch(const NotifySwitchArgs* args) = 0;
 166     virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) = 0;
 167 };
 168
 169
 170 /*
 171  * An implementation of the listener interface that queues up and defers dispatch
 172  * of decoded events until flushed.
 173  */
 174 class QueuedInputListener : public InputListenerInterface {
 175 protected:
 176     virtual ~QueuedInputListener();
 177
 178 public:
 179     QueuedInputListener(const sp<InputListenerInterface>& innerListener);
 180
 181     virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
 182     virtual void notifyKey(const NotifyKeyArgs* args);
 183     virtual void notifyMotion(const NotifyMotionArgs* args);
 184     virtual void notifySwitch(const NotifySwitchArgs* args);
 185     virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
 186
 187     void flush();
 188
 189 private:
 190     sp<InputListenerInterface> mInnerListener;
 191     Vector<NotifyArgs*> mArgsQueue;
 192 };
 193
 194 } // namespace android
 195
 196 #endif // _UI_INPUT_LISTENER_H