blob: 693ec30b7d7d44d9ecf3509daad646d19bed364e [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
20#include "EventHub.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080021#include "InputListener.h"
Prabir Pradhan29c95332018-11-14 20:14:11 -080022#include "InputReaderBase.h"
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070023#include "InputReaderContext.h"
Prabir Pradhan5a57cff2019-10-31 18:40:33 -070024#include "InputThread.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080025
Prabir Pradhanc7ef27e2020-02-03 19:19:15 -080026#include <PointerControllerInterface.h>
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -070027#include <utils/Condition.h>
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -070028#include <utils/Mutex.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080029
Nathaniel R. Lewis10793a62019-11-05 02:17:02 +000030#include <unordered_map>
Siarhei Vishniakoud6343922018-07-06 23:33:37 +010031#include <vector>
Michael Wrightd02c5b62014-02-10 15:10:22 -080032
Michael Wrightd02c5b62014-02-10 15:10:22 -080033namespace android {
34
35class InputDevice;
36class InputMapper;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070037struct StylusState;
Michael Wrightd02c5b62014-02-10 15:10:22 -080038
Michael Wrightd02c5b62014-02-10 15:10:22 -080039/* 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 *
Prabir Pradhan28efc192019-11-05 01:10:04 +000043 * 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
Michael Wrightd02c5b62014-02-10 15:10:22 -080045 * 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
Prabir Pradhan28efc192019-11-05 01:10:04 +000048 * InputListener. All calls to InputListener must happen from InputReader's thread.
Michael Wrightd02c5b62014-02-10 15:10:22 -080049 */
50class InputReader : public InputReaderInterface {
51public:
Siarhei Vishniakou3bc7e092019-07-24 17:43:30 -070052 InputReader(std::shared_ptr<EventHubInterface> eventHub,
53 const sp<InputReaderPolicyInterface>& policy,
54 const sp<InputListenerInterface>& listener);
Michael Wrightd02c5b62014-02-10 15:10:22 -080055 virtual ~InputReader();
56
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070057 virtual void dump(std::string& dump) override;
58 virtual void monitor() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080059
Prabir Pradhan28efc192019-11-05 01:10:04 +000060 virtual status_t start() override;
61 virtual status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080062
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070063 virtual void getInputDevices(std::vector<InputDeviceInfo>& outInputDevices) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080064
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070065 virtual bool isInputDeviceEnabled(int32_t deviceId) override;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -070066
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070067 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;
Michael Wrightd02c5b62014-02-10 15:10:22 -080072
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070073 virtual void toggleCapsLockState(int32_t deviceId) override;
Andrii Kulian763a3a42016-03-08 10:46:16 -080074
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070075 virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070076 const int32_t* keyCodes, uint8_t* outFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080077
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070078 virtual void requestRefreshConfiguration(uint32_t changes) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080079
80 virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070081 ssize_t repeat, int32_t token) override;
82 virtual void cancelVibrate(int32_t deviceId, int32_t token) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080083
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -070084 virtual 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.
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080088 virtual std::shared_ptr<InputDevice> createDeviceLocked(
89 int32_t deviceId, const InputDeviceIdentifier& identifier);
Michael Wrightd02c5b62014-02-10 15:10:22 -080090
Prabir Pradhan28efc192019-11-05 01:10:04 +000091 // With each iteration of the loop, InputReader reads and processes one incoming message from
92 // the EventHub.
93 void loopOnce();
94
Michael Wrightd02c5b62014-02-10 15:10:22 -080095 class ContextImpl : public InputReaderContext {
96 InputReader* mReader;
Garfield Tanff1f1bb2020-01-28 13:24:04 -080097 IdGenerator mIdGenerator;
Michael Wrightd02c5b62014-02-10 15:10:22 -080098
99 public:
Chih-Hung Hsieh6d2ede12016-09-01 11:28:23 -0700100 explicit ContextImpl(InputReader* reader);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800101
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -0700102 virtual void updateGlobalMetaState() override;
103 virtual int32_t getGlobalMetaState() override;
104 virtual void disableVirtualKeysUntil(nsecs_t time) override;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800105 virtual bool shouldDropVirtualKey(nsecs_t now, int32_t keyCode, int32_t scanCode) override;
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -0700106 virtual void fadePointer() override;
Prabir Pradhanc7ef27e2020-02-03 19:19:15 -0800107 virtual sp<PointerControllerInterface> getPointerController(int32_t deviceId) override;
Prabir Pradhanf1fbf9e2019-09-04 16:29:40 -0700108 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;
Garfield Tan6a5a14e2020-01-28 13:24:04 -0800115 virtual int32_t getNextId() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800116 } mContext;
117
118 friend class ContextImpl;
119
120private:
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700121 std::unique_ptr<InputThread> mThread;
Prabir Pradhan28efc192019-11-05 01:10:04 +0000122
Michael Wrightd02c5b62014-02-10 15:10:22 -0800123 Mutex mLock;
124
125 Condition mReaderIsAliveCondition;
126
Siarhei Vishniakou3bc7e092019-07-24 17:43:30 -0700127 // 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;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800131 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
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800140 // 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;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800143
144 // low-level input event decoding and device management
145 void processEventsLocked(const RawEvent* rawEvents, size_t count);
146
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800147 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);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800150 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
Michael Wright842500e2015-03-13 17:32:02 -0700158 void notifyExternalStylusPresenceChanged();
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800159 void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices);
Michael Wright842500e2015-03-13 17:32:02 -0700160 void dispatchExternalStylusState(const StylusState& state);
161
Prabir Pradhanc7ef27e2020-02-03 19:19:15 -0800162 // 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();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166 void fadePointerLocked();
167
168 int32_t mGeneration;
169 int32_t bumpGenerationLocked();
170
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800171 int32_t mNextInputDeviceId;
172 int32_t nextInputDeviceIdLocked();
173
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800174 void getInputDevicesLocked(std::vector<InputDeviceInfo>& outInputDevices);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800175
176 nsecs_t mDisableVirtualKeysTimeout;
177 void disableVirtualKeysUntilLocked(nsecs_t time);
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800178 bool shouldDropVirtualKeyLocked(nsecs_t now, int32_t keyCode, int32_t scanCode);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800179
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,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700189 GetStateFunc getStateFunc);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800190 bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700191 const int32_t* keyCodes, uint8_t* outFlags);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800192
193 // find an InputDevice from an InputDevice id
194 InputDevice* findInputDevice(int32_t deviceId);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800195};
196
Michael Wrightd02c5b62014-02-10 15:10:22 -0800197} // namespace android
198
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700199#endif // _UI_INPUTREADER_INPUT_READER_H