1 /* 2 * Copyright (C) 2005 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 // 18 #ifndef _RUNTIME_EVENT_HUB_H 19 #define _RUNTIME_EVENT_HUB_H 20 21 #include <android/input.h> 22 #include <utils/String8.h> 23 #include <utils/threads.h> 24 #include <utils/Log.h> 25 #include <utils/threads.h> 26 #include <utils/List.h> 27 #include <utils/Errors.h> 28 29 #include <linux/input.h> 30 31 /* These constants are not defined in linux/input.h but they are part of the multitouch 32 * input protocol. */ 33 34 #define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */ 35 #define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */ 36 #define ABS_MT_WIDTH_MAJOR 0x32 /* Major axis of approaching ellipse */ 37 #define ABS_MT_WIDTH_MINOR 0x33 /* Minor axis (omit if circular) */ 38 #define ABS_MT_ORIENTATION 0x34 /* Ellipse orientation */ 39 #define ABS_MT_POSITION_X 0x35 /* Center X ellipse position */ 40 #define ABS_MT_POSITION_Y 0x36 /* Center Y ellipse position */ 41 #define ABS_MT_TOOL_TYPE 0x37 /* Type of touching device (finger, pen, ...) */ 42 #define ABS_MT_BLOB_ID 0x38 /* Group a set of packets as a blob */ 43 #define ABS_MT_TRACKING_ID 0x39 /* Unique ID of initiated contact */ 44 #define ABS_MT_PRESSURE 0x3a /* Pressure on contact area */ 45 46 #define MT_TOOL_FINGER 0 /* Identifies a finger */ 47 #define MT_TOOL_PEN 1 /* Identifies a pen */ 48 49 #define SYN_MT_REPORT 2 50 51 /* Convenience constants. */ 52 53 #define BTN_FIRST 0x100 // first button scancode 54 #define BTN_LAST 0x15f // last button scancode 55 56 struct pollfd; 57 58 namespace android { 59 60 class KeyLayoutMap; 61 62 /* 63 * A raw event as retrieved from the EventHub. 64 */ 65 struct RawEvent { 66 nsecs_t when; 67 int32_t deviceId; 68 int32_t type; 69 int32_t scanCode; 70 int32_t keyCode; 71 int32_t value; 72 uint32_t flags; 73 }; 74 75 /* Describes an absolute axis. */ 76 struct RawAbsoluteAxisInfo { 77 bool valid; // true if the information is valid, false otherwise 78 79 int32_t minValue; // minimum value 80 int32_t maxValue; // maximum value 81 int32_t flat; // center flat position, eg. flat == 8 means center is between -8 and 8 82 int32_t fuzz; // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise 83 getRangeRawAbsoluteAxisInfo84 inline int32_t getRange() { return maxValue - minValue; } 85 clearRawAbsoluteAxisInfo86 inline void clear() { 87 valid = false; 88 minValue = 0; 89 maxValue = 0; 90 flat = 0; 91 fuzz = 0; 92 } 93 }; 94 95 /* 96 * Input device classes. 97 */ 98 enum { 99 /* The input device is a keyboard. */ 100 INPUT_DEVICE_CLASS_KEYBOARD = 0x00000001, 101 102 /* The input device is an alpha-numeric keyboard (not just a dial pad). */ 103 INPUT_DEVICE_CLASS_ALPHAKEY = 0x00000002, 104 105 /* The input device is a touchscreen (either single-touch or multi-touch). */ 106 INPUT_DEVICE_CLASS_TOUCHSCREEN = 0x00000004, 107 108 /* The input device is a trackball. */ 109 INPUT_DEVICE_CLASS_TRACKBALL = 0x00000008, 110 111 /* The input device is a multi-touch touchscreen. */ 112 INPUT_DEVICE_CLASS_TOUCHSCREEN_MT= 0x00000010, 113 114 /* The input device is a directional pad (implies keyboard, has DPAD keys). */ 115 INPUT_DEVICE_CLASS_DPAD = 0x00000020, 116 117 /* The input device is a gamepad (implies keyboard, has BUTTON keys). */ 118 INPUT_DEVICE_CLASS_GAMEPAD = 0x00000040, 119 120 /* The input device has switches. */ 121 INPUT_DEVICE_CLASS_SWITCH = 0x00000080, 122 }; 123 124 /* 125 * Grand Central Station for events. 126 * 127 * The event hub aggregates input events received across all known input 128 * devices on the system, including devices that may be emulated by the simulator 129 * environment. In addition, the event hub generates fake input events to indicate 130 * when devices are added or removed. 131 * 132 * The event hub provies a stream of input events (via the getEvent function). 133 * It also supports querying the current actual state of input devices such as identifying 134 * which keys are currently down. Finally, the event hub keeps track of the capabilities of 135 * individual input devices, such as their class and the set of key codes that they support. 136 */ 137 class EventHubInterface : public virtual RefBase { 138 protected: EventHubInterface()139 EventHubInterface() { } ~EventHubInterface()140 virtual ~EventHubInterface() { } 141 142 public: 143 // Synthetic raw event type codes produced when devices are added or removed. 144 enum { 145 // Sent when a device is added. 146 DEVICE_ADDED = 0x10000000, 147 // Sent when a device is removed. 148 DEVICE_REMOVED = 0x20000000, 149 // Sent when all added/removed devices from the most recent scan have been reported. 150 // This event is always sent at least once. 151 FINISHED_DEVICE_SCAN = 0x30000000, 152 }; 153 154 virtual uint32_t getDeviceClasses(int32_t deviceId) const = 0; 155 156 virtual String8 getDeviceName(int32_t deviceId) const = 0; 157 158 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis, 159 RawAbsoluteAxisInfo* outAxisInfo) const = 0; 160 161 virtual status_t scancodeToKeycode(int32_t deviceId, int scancode, 162 int32_t* outKeycode, uint32_t* outFlags) const = 0; 163 164 // exclude a particular device from opening 165 // this can be used to ignore input devices for sensors 166 virtual void addExcludedDevice(const char* deviceName) = 0; 167 168 /* 169 * Wait for the next event to become available and return it. 170 * After returning, the EventHub holds onto a wake lock until the next call to getEvent. 171 * This ensures that the device will not go to sleep while the event is being processed. 172 * If the device needs to remain awake longer than that, then the caller is responsible 173 * for taking care of it (say, by poking the power manager user activity timer). 174 */ 175 virtual bool getEvent(RawEvent* outEvent) = 0; 176 177 /* 178 * Query current input state. 179 */ 180 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const = 0; 181 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const = 0; 182 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const = 0; 183 184 /* 185 * Examine key input devices for specific framework keycode support 186 */ 187 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes, 188 uint8_t* outFlags) const = 0; 189 190 virtual void dump(String8& dump) = 0; 191 }; 192 193 class EventHub : public EventHubInterface 194 { 195 public: 196 EventHub(); 197 198 status_t errorCheck() const; 199 200 virtual uint32_t getDeviceClasses(int32_t deviceId) const; 201 202 virtual String8 getDeviceName(int32_t deviceId) const; 203 204 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis, 205 RawAbsoluteAxisInfo* outAxisInfo) const; 206 207 virtual status_t scancodeToKeycode(int32_t deviceId, int scancode, 208 int32_t* outKeycode, uint32_t* outFlags) const; 209 210 virtual void addExcludedDevice(const char* deviceName); 211 212 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const; 213 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const; 214 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const; 215 216 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, 217 const int32_t* keyCodes, uint8_t* outFlags) const; 218 219 virtual bool getEvent(RawEvent* outEvent); 220 221 virtual void dump(String8& dump); 222 223 protected: 224 virtual ~EventHub(); 225 226 private: 227 bool openPlatformInput(void); 228 229 int openDevice(const char *device); 230 int closeDevice(const char *device); 231 int scanDir(const char *dirname); 232 int readNotify(int nfd); 233 234 status_t mError; 235 236 struct device_t { 237 const int32_t id; 238 const String8 path; 239 String8 name; 240 uint32_t classes; 241 uint8_t* keyBitmask; 242 KeyLayoutMap* layoutMap; 243 String8 keylayoutFilename; 244 int fd; 245 device_t* next; 246 247 device_t(int32_t _id, const char* _path, const char* name); 248 ~device_t(); 249 }; 250 251 device_t* getDeviceLocked(int32_t deviceId) const; 252 bool hasKeycodeLocked(device_t* device, int keycode) const; 253 254 int32_t getScanCodeStateLocked(device_t* device, int32_t scanCode) const; 255 int32_t getKeyCodeStateLocked(device_t* device, int32_t keyCode) const; 256 int32_t getSwitchStateLocked(device_t* device, int32_t sw) const; 257 bool markSupportedKeyCodesLocked(device_t* device, size_t numCodes, 258 const int32_t* keyCodes, uint8_t* outFlags) const; 259 260 // Protect all internal state. 261 mutable Mutex mLock; 262 263 bool mHaveFirstKeyboard; 264 int32_t mFirstKeyboardId; // the API is that the built-in keyboard is id 0, so map it 265 266 struct device_ent { 267 device_t* device; 268 uint32_t seq; 269 }; 270 device_ent *mDevicesById; 271 int mNumDevicesById; 272 273 device_t *mOpeningDevices; 274 device_t *mClosingDevices; 275 276 device_t **mDevices; 277 struct pollfd *mFDs; 278 int mFDCount; 279 280 bool mOpened; 281 bool mNeedToSendFinishedDeviceScan; 282 List<String8> mExcludedDevices; 283 284 // device ids that report particular switches. 285 #ifdef EV_SW 286 int32_t mSwitches[SW_MAX + 1]; 287 #endif 288 289 static const int INPUT_BUFFER_SIZE = 64; 290 struct input_event mInputBufferData[INPUT_BUFFER_SIZE]; 291 int32_t mInputBufferIndex; 292 int32_t mInputBufferCount; 293 int32_t mInputDeviceIndex; 294 }; 295 296 }; // namespace android 297 298 #endif // _RUNTIME_EVENT_HUB_H 299