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 #ifndef _UI_INPUTREADER_INPUT_READER_H 18 #define _UI_INPUTREADER_INPUT_READER_H 19 20 #include "EventHub.h" 21 #include "InputListener.h" 22 #include "InputReaderBase.h" 23 #include "InputReaderContext.h" 24 #include "InputThread.h" 25 26 #include <PointerControllerInterface.h> 27 #include <utils/Condition.h> 28 #include <utils/Mutex.h> 29 30 #include <unordered_map> 31 #include <vector> 32 33 namespace android { 34 35 class InputDevice; 36 class InputMapper; 37 struct StylusState; 38 39 /* The input reader reads raw event data from the event hub and processes it into input events 40 * that it sends to the input listener. Some functions of the input reader, such as early 41 * event filtering in low power states, are controlled by a separate policy object. 42 * 43 * The InputReader owns a collection of InputMappers. InputReader starts its own thread, where 44 * most of the work happens, but the InputReader can receive queries from other system 45 * components running on arbitrary threads. To keep things manageable, the InputReader 46 * uses a single Mutex to guard its state. The Mutex may be held while calling into the 47 * EventHub or the InputReaderPolicy but it is never held while calling into the 48 * InputListener. All calls to InputListener must happen from InputReader's thread. 49 */ 50 class InputReader : public InputReaderInterface { 51 public: 52 InputReader(std::shared_ptr<EventHubInterface> eventHub, 53 const sp<InputReaderPolicyInterface>& policy, 54 const sp<InputListenerInterface>& listener); 55 virtual ~InputReader(); 56 57 virtual void dump(std::string& dump) override; 58 virtual void monitor() override; 59 60 virtual status_t start() override; 61 virtual status_t stop() override; 62 63 virtual void getInputDevices(std::vector<InputDeviceInfo>& outInputDevices) override; 64 65 virtual bool isInputDeviceEnabled(int32_t deviceId) override; 66 67 virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, 68 int32_t scanCode) override; 69 virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, 70 int32_t keyCode) override; 71 virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t sw) override; 72 73 virtual void toggleCapsLockState(int32_t deviceId) override; 74 75 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes, 76 const int32_t* keyCodes, uint8_t* outFlags) override; 77 78 virtual void requestRefreshConfiguration(uint32_t changes) override; 79 80 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize, 81 ssize_t repeat, int32_t token) override; 82 virtual void cancelVibrate(int32_t deviceId, int32_t token) override; 83 84 virtual bool canDispatchToDisplay(int32_t deviceId, int32_t displayId) override; 85 86 protected: 87 // These members are protected so they can be instrumented by test cases. 88 virtual std::shared_ptr<InputDevice> createDeviceLocked( 89 int32_t deviceId, const InputDeviceIdentifier& identifier); 90 91 // With each iteration of the loop, InputReader reads and processes one incoming message from 92 // the EventHub. 93 void loopOnce(); 94 95 class ContextImpl : public InputReaderContext { 96 InputReader* mReader; 97 IdGenerator mIdGenerator; 98 99 public: 100 explicit ContextImpl(InputReader* reader); 101 102 virtual void updateGlobalMetaState() override; 103 virtual int32_t getGlobalMetaState() override; 104 virtual void disableVirtualKeysUntil(nsecs_t time) override; 105 virtual bool shouldDropVirtualKey(nsecs_t now, int32_t keyCode, int32_t scanCode) override; 106 virtual void fadePointer() override; 107 virtual sp<PointerControllerInterface> getPointerController(int32_t deviceId) override; 108 virtual void requestTimeoutAtTime(nsecs_t when) override; 109 virtual int32_t bumpGeneration() override; 110 virtual void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices) override; 111 virtual void dispatchExternalStylusState(const StylusState& outState) override; 112 virtual InputReaderPolicyInterface* getPolicy() override; 113 virtual InputListenerInterface* getListener() override; 114 virtual EventHubInterface* getEventHub() override; 115 virtual int32_t getNextId() override; 116 } mContext; 117 118 friend class ContextImpl; 119 120 private: 121 std::unique_ptr<InputThread> mThread; 122 123 Mutex mLock; 124 125 Condition mReaderIsAliveCondition; 126 127 // This could be unique_ptr, but due to the way InputReader tests are written, 128 // it is made shared_ptr here. In the tests, an EventHub reference is retained by the test 129 // in parallel to passing it to the InputReader. 130 std::shared_ptr<EventHubInterface> mEventHub; 131 sp<InputReaderPolicyInterface> mPolicy; 132 sp<QueuedInputListener> mQueuedListener; 133 134 InputReaderConfiguration mConfig; 135 136 // The event queue. 137 static const int EVENT_BUFFER_SIZE = 256; 138 RawEvent mEventBuffer[EVENT_BUFFER_SIZE]; 139 140 // An input device can represent a collection of EventHub devices. This map provides a way 141 // to lookup the input device instance from the EventHub device id. 142 std::unordered_map<int32_t /*eventHubId*/, std::shared_ptr<InputDevice>> mDevices; 143 144 // low-level input event decoding and device management 145 void processEventsLocked(const RawEvent* rawEvents, size_t count); 146 147 void addDeviceLocked(nsecs_t when, int32_t eventHubId); 148 void removeDeviceLocked(nsecs_t when, int32_t eventHubId); 149 void processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents, size_t count); 150 void timeoutExpiredLocked(nsecs_t when); 151 152 void handleConfigurationChangedLocked(nsecs_t when); 153 154 int32_t mGlobalMetaState; 155 void updateGlobalMetaStateLocked(); 156 int32_t getGlobalMetaStateLocked(); 157 158 void notifyExternalStylusPresenceChanged(); 159 void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices); 160 void dispatchExternalStylusState(const StylusState& state); 161 162 // The PointerController that is shared among all the input devices that need it. 163 wp<PointerControllerInterface> mPointerController; 164 sp<PointerControllerInterface> getPointerControllerLocked(int32_t deviceId); 165 void updatePointerDisplayLocked(); 166 void fadePointerLocked(); 167 168 int32_t mGeneration; 169 int32_t bumpGenerationLocked(); 170 171 int32_t mNextInputDeviceId; 172 int32_t nextInputDeviceIdLocked(); 173 174 void getInputDevicesLocked(std::vector<InputDeviceInfo>& outInputDevices); 175 176 nsecs_t mDisableVirtualKeysTimeout; 177 void disableVirtualKeysUntilLocked(nsecs_t time); 178 bool shouldDropVirtualKeyLocked(nsecs_t now, int32_t keyCode, int32_t scanCode); 179 180 nsecs_t mNextTimeout; 181 void requestTimeoutAtTimeLocked(nsecs_t when); 182 183 uint32_t mConfigurationChangesToRefresh; 184 void refreshConfigurationLocked(uint32_t changes); 185 186 // state queries 187 typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code); 188 int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code, 189 GetStateFunc getStateFunc); 190 bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes, 191 const int32_t* keyCodes, uint8_t* outFlags); 192 193 // find an InputDevice from an InputDevice id 194 InputDevice* findInputDevice(int32_t deviceId); 195 }; 196 197 } // namespace android 198 199 #endif // _UI_INPUTREADER_INPUT_READER_H 200