blob: 9b07681d95279a80206ba9f183f5c1e8a4d6c11b [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
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
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070017#ifndef _UI_INPUTREADER_INPUT_READER_H
18#define _UI_INPUTREADER_INPUT_READER_H
Michael Wrightd02c5b62014-02-10 15:10:22 -080019
Michael Wright17db18e2020-06-26 20:51:44 +010020#include <PointerControllerInterface.h>
Chris Ye1c2e0892020-11-30 21:41:44 -080021#include <android-base/thread_annotations.h>
Michael Wright17db18e2020-06-26 20:51:44 +010022#include <utils/Condition.h>
23#include <utils/Mutex.h>
24
25#include <memory>
26#include <unordered_map>
27#include <vector>
28
Michael Wrightd02c5b62014-02-10 15:10:22 -080029#include "EventHub.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080030#include "InputListener.h"
Prabir Pradhan29c95332018-11-14 20:14:11 -080031#include "InputReaderBase.h"
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070032#include "InputReaderContext.h"
Prabir Pradhan5a57cff2019-10-31 18:40:33 -070033#include "InputThread.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080034
Michael Wrightd02c5b62014-02-10 15:10:22 -080035namespace android {
36
37class InputDevice;
38class InputMapper;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070039struct StylusState;
Michael Wrightd02c5b62014-02-10 15:10:22 -080040
Michael Wrightd02c5b62014-02-10 15:10:22 -080041/* 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 *
Prabir Pradhan28efc192019-11-05 01:10:04 +000045 * 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
Michael Wrightd02c5b62014-02-10 15:10:22 -080047 * 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
Prabir Pradhan28efc192019-11-05 01:10:04 +000050 * InputListener. All calls to InputListener must happen from InputReader's thread.
Michael Wrightd02c5b62014-02-10 15:10:22 -080051 */
52class InputReader : public InputReaderInterface {
53public:
Siarhei Vishniakou3bc7e092019-07-24 17:43:30 -070054 InputReader(std::shared_ptr<EventHubInterface> eventHub,
55 const sp<InputReaderPolicyInterface>& policy,
56 const sp<InputListenerInterface>& listener);
Michael Wrightd02c5b62014-02-10 15:10:22 -080057 virtual ~InputReader();
58
arthurhungc903df12020-08-11 15:08:42 +080059 void dump(std::string& dump) override;
60 void monitor() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080061
arthurhungc903df12020-08-11 15:08:42 +080062 status_t start() override;
63 status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080064
Chris Ye98d3f532020-10-01 21:48:59 -070065 std::vector<InputDeviceInfo> getInputDevices() const override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080066
arthurhungc903df12020-08-11 15:08:42 +080067 bool isInputDeviceEnabled(int32_t deviceId) override;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -070068
arthurhungc903df12020-08-11 15:08:42 +080069 int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode) override;
70 int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, int32_t keyCode) override;
71 int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t sw) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080072
arthurhungc903df12020-08-11 15:08:42 +080073 void toggleCapsLockState(int32_t deviceId) override;
Andrii Kulian763a3a42016-03-08 10:46:16 -080074
arthurhungc903df12020-08-11 15:08:42 +080075 bool hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes, const int32_t* keyCodes,
76 uint8_t* outFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080077
arthurhungc903df12020-08-11 15:08:42 +080078 void requestRefreshConfiguration(uint32_t changes) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080079
arthurhungc903df12020-08-11 15:08:42 +080080 void vibrate(int32_t deviceId, const std::vector<VibrationElement>& pattern, ssize_t repeat,
81 int32_t token) override;
82 void cancelVibrate(int32_t deviceId, int32_t token) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080083
arthurhungc903df12020-08-11 15:08:42 +080084 bool canDispatchToDisplay(int32_t deviceId, int32_t displayId) override;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070085
Michael Wrightd02c5b62014-02-10 15:10:22 -080086protected:
87 // These members are protected so they can be instrumented by test cases.
Chris Ye1c2e0892020-11-30 21:41:44 -080088 virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t deviceId,
89 const InputDeviceIdentifier& identifier)
90 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -080091
Prabir Pradhan28efc192019-11-05 01:10:04 +000092 // With each iteration of the loop, InputReader reads and processes one incoming message from
93 // the EventHub.
94 void loopOnce();
95
Michael Wrightd02c5b62014-02-10 15:10:22 -080096 class ContextImpl : public InputReaderContext {
97 InputReader* mReader;
Garfield Tanff1f1bb2020-01-28 13:24:04 -080098 IdGenerator mIdGenerator;
Michael Wrightd02c5b62014-02-10 15:10:22 -080099
100 public:
Chih-Hung Hsieh6d2ede12016-09-01 11:28:23 -0700101 explicit ContextImpl(InputReader* reader);
Chris Ye1c2e0892020-11-30 21:41:44 -0800102 // lock is already held by the input loop
103 void updateGlobalMetaState() NO_THREAD_SAFETY_ANALYSIS override;
104 int32_t getGlobalMetaState() NO_THREAD_SAFETY_ANALYSIS override;
105 void disableVirtualKeysUntil(nsecs_t time) NO_THREAD_SAFETY_ANALYSIS override;
106 bool shouldDropVirtualKey(nsecs_t now, int32_t keyCode,
107 int32_t scanCode) NO_THREAD_SAFETY_ANALYSIS override;
108 void fadePointer() NO_THREAD_SAFETY_ANALYSIS override;
109 std::shared_ptr<PointerControllerInterface> getPointerController(int32_t deviceId)
110 NO_THREAD_SAFETY_ANALYSIS override;
111 void requestTimeoutAtTime(nsecs_t when) NO_THREAD_SAFETY_ANALYSIS override;
112 int32_t bumpGeneration() NO_THREAD_SAFETY_ANALYSIS override;
113 void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices)
114 NO_THREAD_SAFETY_ANALYSIS override;
115 void dispatchExternalStylusState(const StylusState& outState)
116 NO_THREAD_SAFETY_ANALYSIS override;
117 InputReaderPolicyInterface* getPolicy() NO_THREAD_SAFETY_ANALYSIS override;
118 InputListenerInterface* getListener() NO_THREAD_SAFETY_ANALYSIS override;
119 EventHubInterface* getEventHub() NO_THREAD_SAFETY_ANALYSIS override;
120 int32_t getNextId() NO_THREAD_SAFETY_ANALYSIS override;
121 void updateLedMetaState(int32_t metaState) NO_THREAD_SAFETY_ANALYSIS override;
122 int32_t getLedMetaState() NO_THREAD_SAFETY_ANALYSIS override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800123 } mContext;
124
125 friend class ContextImpl;
Chris Ye1c2e0892020-11-30 21:41:44 -0800126 // Test cases need to override the locked functions
127 mutable std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800128
129private:
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700130 std::unique_ptr<InputThread> mThread;
Prabir Pradhan28efc192019-11-05 01:10:04 +0000131
Chris Ye1c2e0892020-11-30 21:41:44 -0800132 std::condition_variable mReaderIsAliveCondition;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800133
Siarhei Vishniakou3bc7e092019-07-24 17:43:30 -0700134 // This could be unique_ptr, but due to the way InputReader tests are written,
135 // it is made shared_ptr here. In the tests, an EventHub reference is retained by the test
136 // in parallel to passing it to the InputReader.
137 std::shared_ptr<EventHubInterface> mEventHub;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800138 sp<InputReaderPolicyInterface> mPolicy;
139 sp<QueuedInputListener> mQueuedListener;
140
Chris Ye1c2e0892020-11-30 21:41:44 -0800141 InputReaderConfiguration mConfig GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800142
143 // The event queue.
144 static const int EVENT_BUFFER_SIZE = 256;
Chris Ye1c2e0892020-11-30 21:41:44 -0800145 RawEvent mEventBuffer[EVENT_BUFFER_SIZE] GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800146
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800147 // An input device can represent a collection of EventHub devices. This map provides a way
148 // to lookup the input device instance from the EventHub device id.
Chris Ye1c2e0892020-11-30 21:41:44 -0800149 std::unordered_map<int32_t /*eventHubId*/, std::shared_ptr<InputDevice>> mDevices
150 GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800151
Chris Yee7310032020-09-22 15:36:28 -0700152 // An input device contains one or more eventHubId, this map provides a way to lookup the
153 // EventHubIds contained in the input device from the input device instance.
154 std::unordered_map<std::shared_ptr<InputDevice>, std::vector<int32_t> /*eventHubId*/>
Chris Ye1c2e0892020-11-30 21:41:44 -0800155 mDeviceToEventHubIdsMap GUARDED_BY(mLock);
Chris Yee7310032020-09-22 15:36:28 -0700156
Michael Wrightd02c5b62014-02-10 15:10:22 -0800157 // low-level input event decoding and device management
Chris Ye1c2e0892020-11-30 21:41:44 -0800158 void processEventsLocked(const RawEvent* rawEvents, size_t count) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800159
Chris Ye1c2e0892020-11-30 21:41:44 -0800160 void addDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock);
161 void removeDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock);
162 void processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents, size_t count)
163 REQUIRES(mLock);
164 void timeoutExpiredLocked(nsecs_t when) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800165
Chris Ye1c2e0892020-11-30 21:41:44 -0800166 void handleConfigurationChangedLocked(nsecs_t when) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800167
Chris Ye1c2e0892020-11-30 21:41:44 -0800168 int32_t mGlobalMetaState GUARDED_BY(mLock);
169 void updateGlobalMetaStateLocked() REQUIRES(mLock);
170 int32_t getGlobalMetaStateLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800171
Chris Ye1c2e0892020-11-30 21:41:44 -0800172 int32_t mLedMetaState GUARDED_BY(mLock);
173 void updateLedMetaStateLocked(int32_t metaState) REQUIRES(mLock);
174 int32_t getLedMetaStateLocked() REQUIRES(mLock);
arthurhungc903df12020-08-11 15:08:42 +0800175
Chris Ye1c2e0892020-11-30 21:41:44 -0800176 void notifyExternalStylusPresenceChangedLocked() REQUIRES(mLock);
177 void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices) REQUIRES(mLock);
Michael Wright842500e2015-03-13 17:32:02 -0700178 void dispatchExternalStylusState(const StylusState& state);
179
Prabir Pradhanc7ef27e2020-02-03 19:19:15 -0800180 // The PointerController that is shared among all the input devices that need it.
Michael Wright17db18e2020-06-26 20:51:44 +0100181 std::weak_ptr<PointerControllerInterface> mPointerController;
Chris Ye1c2e0892020-11-30 21:41:44 -0800182 std::shared_ptr<PointerControllerInterface> getPointerControllerLocked(int32_t deviceId)
183 REQUIRES(mLock);
184 void updatePointerDisplayLocked() REQUIRES(mLock);
185 void fadePointerLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800186
Chris Ye1c2e0892020-11-30 21:41:44 -0800187 int32_t mGeneration GUARDED_BY(mLock);
188 int32_t bumpGenerationLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800189
Chris Ye1c2e0892020-11-30 21:41:44 -0800190 int32_t mNextInputDeviceId GUARDED_BY(mLock);
191 int32_t nextInputDeviceIdLocked() REQUIRES(mLock);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800192
Chris Ye1c2e0892020-11-30 21:41:44 -0800193 std::vector<InputDeviceInfo> getInputDevicesLocked() const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800194
Chris Ye1c2e0892020-11-30 21:41:44 -0800195 nsecs_t mDisableVirtualKeysTimeout GUARDED_BY(mLock);
196 void disableVirtualKeysUntilLocked(nsecs_t time) REQUIRES(mLock);
197 bool shouldDropVirtualKeyLocked(nsecs_t now, int32_t keyCode, int32_t scanCode) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800198
Chris Ye1c2e0892020-11-30 21:41:44 -0800199 nsecs_t mNextTimeout GUARDED_BY(mLock);
200 void requestTimeoutAtTimeLocked(nsecs_t when) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800201
Chris Ye1c2e0892020-11-30 21:41:44 -0800202 uint32_t mConfigurationChangesToRefresh GUARDED_BY(mLock);
203 void refreshConfigurationLocked(uint32_t changes) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800204
205 // state queries
206 typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
207 int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
Chris Ye1c2e0892020-11-30 21:41:44 -0800208 GetStateFunc getStateFunc) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800209 bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
Chris Ye1c2e0892020-11-30 21:41:44 -0800210 const int32_t* keyCodes, uint8_t* outFlags) REQUIRES(mLock);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800211
212 // find an InputDevice from an InputDevice id
Chris Ye1c2e0892020-11-30 21:41:44 -0800213 InputDevice* findInputDeviceLocked(int32_t deviceId) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800214};
215
Michael Wrightd02c5b62014-02-10 15:10:22 -0800216} // namespace android
217
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700218#endif // _UI_INPUTREADER_INPUT_READER_H