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