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 #pragma once
18 
19 #include <android-base/thread_annotations.h>
20 #include <utils/Condition.h>
21 #include <utils/Mutex.h>
22 
23 #include <memory>
24 #include <unordered_map>
25 #include <vector>
26 
27 #include "EventHub.h"
28 #include "InputListener.h"
29 #include "InputReaderBase.h"
30 #include "InputReaderContext.h"
31 #include "InputThread.h"
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, InputListenerInterface& listener);
54     virtual ~InputReader();
55 
56     void dump(std::string& dump) override;
57     void monitor() override;
58 
59     status_t start() override;
60     status_t stop() override;
61 
62     std::vector<InputDeviceInfo> getInputDevices() const override;
63 
64     int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode) override;
65     int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, int32_t keyCode) override;
66     int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t sw) override;
67 
68     void addKeyRemapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode) const override;
69 
70     int32_t getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKeyCode) const override;
71 
72     void toggleCapsLockState(int32_t deviceId) override;
73 
74     bool hasKeys(int32_t deviceId, uint32_t sourceMask, const std::vector<int32_t>& keyCodes,
75                  uint8_t* outFlags) override;
76 
77     void requestRefreshConfiguration(ConfigurationChanges changes) override;
78 
79     void vibrate(int32_t deviceId, const VibrationSequence& sequence, ssize_t repeat,
80                  int32_t token) override;
81     void cancelVibrate(int32_t deviceId, int32_t token) override;
82 
83     bool isVibrating(int32_t deviceId) override;
84 
85     std::vector<int32_t> getVibratorIds(int32_t deviceId) override;
86 
87     bool canDispatchToDisplay(int32_t deviceId, ui::LogicalDisplayId displayId) override;
88 
89     bool enableSensor(int32_t deviceId, InputDeviceSensorType sensorType,
90                       std::chrono::microseconds samplingPeriod,
91                       std::chrono::microseconds maxBatchReportLatency) override;
92 
93     void disableSensor(int32_t deviceId, InputDeviceSensorType sensorType) override;
94 
95     void flushSensor(int32_t deviceId, InputDeviceSensorType sensorType) override;
96 
97     std::optional<int32_t> getBatteryCapacity(int32_t deviceId) override;
98 
99     std::optional<int32_t> getBatteryStatus(int32_t deviceId) override;
100 
101     std::optional<std::string> getBatteryDevicePath(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     std::optional<std::string> getBluetoothAddress(int32_t deviceId) const override;
116 
117     void sysfsNodeChanged(const std::string& sysfsNodePath) override;
118 
119     DeviceId getLastUsedInputDeviceId() override;
120 
121 protected:
122     // These members are protected so they can be instrumented by test cases.
123     virtual std::shared_ptr<InputDevice> createDeviceLocked(nsecs_t when, int32_t deviceId,
124                                                             const InputDeviceIdentifier& identifier)
125             REQUIRES(mLock);
126 
127     // With each iteration of the loop, InputReader reads and processes one incoming message from
128     // the EventHub.
129     void loopOnce();
130 
131     class ContextImpl : public InputReaderContext {
132         InputReader* mReader;
133         IdGenerator mIdGenerator;
134 
135     public:
136         explicit ContextImpl(InputReader* reader);
137         // lock is already held by the input loop
138         void updateGlobalMetaState() NO_THREAD_SAFETY_ANALYSIS override;
139         int32_t getGlobalMetaState() NO_THREAD_SAFETY_ANALYSIS override;
140         void disableVirtualKeysUntil(nsecs_t time) REQUIRES(mReader->mLock) override;
141         bool shouldDropVirtualKey(nsecs_t now, int32_t keyCode, int32_t scanCode)
142                 REQUIRES(mReader->mLock) override;
143         void requestTimeoutAtTime(nsecs_t when) REQUIRES(mReader->mLock) override;
144         int32_t bumpGeneration() NO_THREAD_SAFETY_ANALYSIS override;
145         void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices)
146                 REQUIRES(mReader->mLock) override;
147         [[nodiscard]] std::list<NotifyArgs> dispatchExternalStylusState(const StylusState& outState)
148                 REQUIRES(mReader->mLock) override;
149         InputReaderPolicyInterface* getPolicy() REQUIRES(mReader->mLock) override;
150         EventHubInterface* getEventHub() REQUIRES(mReader->mLock) override;
151         int32_t getNextId() NO_THREAD_SAFETY_ANALYSIS override;
152         void updateLedMetaState(int32_t metaState) REQUIRES(mReader->mLock) override;
153         int32_t getLedMetaState() REQUIRES(mReader->mLock) REQUIRES(mLock) override;
154         void setPreventingTouchpadTaps(bool prevent) REQUIRES(mReader->mLock)
155                 REQUIRES(mLock) override;
156         bool isPreventingTouchpadTaps() REQUIRES(mReader->mLock) REQUIRES(mLock) override;
157         void setLastKeyDownTimestamp(nsecs_t when) REQUIRES(mReader->mLock)
158                 REQUIRES(mLock) override;
159         nsecs_t getLastKeyDownTimestamp() REQUIRES(mReader->mLock) REQUIRES(mLock) override;
160         KeyboardClassifier& getKeyboardClassifier() override;
161     } mContext;
162 
163     friend class ContextImpl;
164     // Test cases need to override the locked functions
165     mutable std::mutex mLock;
166 
167 private:
168     std::unique_ptr<InputThread> mThread;
169 
170     std::condition_variable mReaderIsAliveCondition;
171 
172     // This could be unique_ptr, but due to the way InputReader tests are written,
173     // it is made shared_ptr here. In the tests, an EventHub reference is retained by the test
174     // in parallel to passing it to the InputReader.
175     std::shared_ptr<EventHubInterface> mEventHub;
176     sp<InputReaderPolicyInterface> mPolicy;
177 
178     // The next stage that should receive the events generated inside InputReader.
179     InputListenerInterface& mNextListener;
180 
181     // Classifier for keyboard/keyboard-like devices
182     std::unique_ptr<KeyboardClassifier> mKeyboardClassifier;
183 
184     // As various events are generated inside InputReader, they are stored inside this list. The
185     // list can only be accessed with the lock, so the events inside it are well-ordered.
186     // Once the reader is done working, these events will be swapped into a temporary storage and
187     // sent to the 'mNextListener' without holding the lock.
188     std::list<NotifyArgs> mPendingArgs GUARDED_BY(mLock);
189 
190     InputReaderConfiguration mConfig GUARDED_BY(mLock);
191 
192     // An input device can represent a collection of EventHub devices. This map provides a way
193     // to lookup the input device instance from the EventHub device id.
194     std::unordered_map<int32_t /*eventHubId*/, std::shared_ptr<InputDevice>> mDevices
195             GUARDED_BY(mLock);
196 
197     // An input device contains one or more eventHubId, this map provides a way to lookup the
198     // EventHubIds contained in the input device from the input device instance.
199     std::unordered_map<std::shared_ptr<InputDevice>, std::vector<int32_t> /*eventHubId*/>
200             mDeviceToEventHubIdsMap GUARDED_BY(mLock);
201 
202     // true if tap-to-click on touchpad currently disabled
GUARDED_BY(mLock)203     bool mPreventingTouchpadTaps GUARDED_BY(mLock){false};
204 
205     // records timestamp of the last key press on the physical keyboard
GUARDED_BY(mLock)206     nsecs_t mLastKeyDownTimestamp GUARDED_BY(mLock){0};
207 
208     // The input device that produced a new gesture most recently.
GUARDED_BY(mLock)209     DeviceId mLastUsedDeviceId GUARDED_BY(mLock){ReservedInputDeviceId::INVALID_INPUT_DEVICE_ID};
210 
211     // low-level input event decoding and device management
212     [[nodiscard]] std::list<NotifyArgs> processEventsLocked(const RawEvent* rawEvents, size_t count)
213             REQUIRES(mLock);
214 
215     void addDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock);
216     void removeDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock);
217     [[nodiscard]] std::list<NotifyArgs> processEventsForDeviceLocked(int32_t eventHubId,
218                                                                      const RawEvent* rawEvents,
219                                                                      size_t count) REQUIRES(mLock);
220     [[nodiscard]] std::list<NotifyArgs> timeoutExpiredLocked(nsecs_t when) REQUIRES(mLock);
221 
222     void handleConfigurationChangedLocked(nsecs_t when) REQUIRES(mLock);
223 
224     int32_t mGlobalMetaState GUARDED_BY(mLock);
225     void updateGlobalMetaStateLocked() REQUIRES(mLock);
226     int32_t getGlobalMetaStateLocked() REQUIRES(mLock);
227 
228     int32_t mLedMetaState GUARDED_BY(mLock);
229     void updateLedMetaStateLocked(int32_t metaState) REQUIRES(mLock);
230     int32_t getLedMetaStateLocked() REQUIRES(mLock);
231 
232     void notifyExternalStylusPresenceChangedLocked() REQUIRES(mLock);
233     void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices) REQUIRES(mLock);
234     [[nodiscard]] std::list<NotifyArgs> dispatchExternalStylusStateLocked(const StylusState& state)
235             REQUIRES(mLock);
236 
237     int32_t mGeneration GUARDED_BY(mLock);
238     int32_t bumpGenerationLocked() REQUIRES(mLock);
239 
240     int32_t mNextInputDeviceId GUARDED_BY(mLock);
241     int32_t nextInputDeviceIdLocked() REQUIRES(mLock);
242 
243     std::vector<InputDeviceInfo> getInputDevicesLocked() const REQUIRES(mLock);
244 
245     nsecs_t mDisableVirtualKeysTimeout GUARDED_BY(mLock);
246     void disableVirtualKeysUntilLocked(nsecs_t time) REQUIRES(mLock);
247     bool shouldDropVirtualKeyLocked(nsecs_t now, int32_t keyCode, int32_t scanCode) REQUIRES(mLock);
248 
249     nsecs_t mNextTimeout GUARDED_BY(mLock);
250     void requestTimeoutAtTimeLocked(nsecs_t when) REQUIRES(mLock);
251 
252     ConfigurationChanges mConfigurationChangesToRefresh GUARDED_BY(mLock);
253     void refreshConfigurationLocked(ConfigurationChanges changes) REQUIRES(mLock);
254 
255     PointerCaptureRequest mCurrentPointerCaptureRequest GUARDED_BY(mLock);
256 
257     // state queries
258     typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
259     int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
260                            GetStateFunc getStateFunc) REQUIRES(mLock);
261     bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask,
262                                      const std::vector<int32_t>& keyCodes, uint8_t* outFlags)
263             REQUIRES(mLock);
264 
265     // find an InputDevice from an InputDevice id
266     InputDevice* findInputDeviceLocked(int32_t deviceId) const REQUIRES(mLock);
267 };
268 
269 } // namespace android
270