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 
25 #include <utils/BitSet.h>
26 #include <utils/Condition.h>
27 #include <utils/KeyedVector.h>
28 #include <utils/Mutex.h>
29 #include <utils/Timers.h>
30 
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.  Most of the work it does happens
44  * on the input reader thread 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.
49  */
50 class InputReader : public InputReaderInterface {
51 public:
52     InputReader(const sp<EventHubInterface>& eventHub, const sp<InputReaderPolicyInterface>& policy,
53                 const sp<InputListenerInterface>& listener);
54     virtual ~InputReader();
55 
56     virtual void dump(std::string& dump);
57     virtual void monitor();
58 
59     virtual void loopOnce();
60 
61     virtual void getInputDevices(std::vector<InputDeviceInfo>& outInputDevices);
62 
63     virtual bool isInputDeviceEnabled(int32_t deviceId);
64 
65     virtual int32_t getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode);
66     virtual int32_t getKeyCodeState(int32_t deviceId, uint32_t sourceMask, int32_t keyCode);
67     virtual int32_t getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t sw);
68 
69     virtual void toggleCapsLockState(int32_t deviceId);
70 
71     virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
72                          const int32_t* keyCodes, uint8_t* outFlags);
73 
74     virtual void requestRefreshConfiguration(uint32_t changes);
75 
76     virtual void vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
77                          ssize_t repeat, int32_t token);
78     virtual void cancelVibrate(int32_t deviceId, int32_t token);
79 
80     virtual bool canDispatchToDisplay(int32_t deviceId, int32_t displayId);
81 protected:
82     // These members are protected so they can be instrumented by test cases.
83     virtual InputDevice* createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
84                                             const InputDeviceIdentifier& identifier,
85                                             uint32_t classes);
86 
87     class ContextImpl : public InputReaderContext {
88         InputReader* mReader;
89 
90     public:
91         explicit ContextImpl(InputReader* reader);
92 
93         virtual void updateGlobalMetaState();
94         virtual int32_t getGlobalMetaState();
95         virtual void disableVirtualKeysUntil(nsecs_t time);
96         virtual bool shouldDropVirtualKey(nsecs_t now, InputDevice* device, int32_t keyCode,
97                                           int32_t scanCode);
98         virtual void fadePointer();
99         virtual void requestTimeoutAtTime(nsecs_t when);
100         virtual int32_t bumpGeneration();
101         virtual void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices);
102         virtual void dispatchExternalStylusState(const StylusState& outState);
103         virtual InputReaderPolicyInterface* getPolicy();
104         virtual InputListenerInterface* getListener();
105         virtual EventHubInterface* getEventHub();
106         virtual uint32_t getNextSequenceNum();
107     } mContext;
108 
109     friend class ContextImpl;
110 
111 private:
112     Mutex mLock;
113 
114     Condition mReaderIsAliveCondition;
115 
116     sp<EventHubInterface> mEventHub;
117     sp<InputReaderPolicyInterface> mPolicy;
118     sp<QueuedInputListener> mQueuedListener;
119 
120     InputReaderConfiguration mConfig;
121 
122     // used by InputReaderContext::getNextSequenceNum() as a counter for event sequence numbers
123     uint32_t mNextSequenceNum;
124 
125     // The event queue.
126     static const int EVENT_BUFFER_SIZE = 256;
127     RawEvent mEventBuffer[EVENT_BUFFER_SIZE];
128 
129     KeyedVector<int32_t, InputDevice*> mDevices;
130 
131     // low-level input event decoding and device management
132     void processEventsLocked(const RawEvent* rawEvents, size_t count);
133 
134     void addDeviceLocked(nsecs_t when, int32_t deviceId);
135     void removeDeviceLocked(nsecs_t when, int32_t deviceId);
136     void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);
137     void timeoutExpiredLocked(nsecs_t when);
138 
139     void handleConfigurationChangedLocked(nsecs_t when);
140 
141     int32_t mGlobalMetaState;
142     void updateGlobalMetaStateLocked();
143     int32_t getGlobalMetaStateLocked();
144 
145     void notifyExternalStylusPresenceChanged();
146     void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices);
147     void dispatchExternalStylusState(const StylusState& state);
148 
149     void fadePointerLocked();
150 
151     int32_t mGeneration;
152     int32_t bumpGenerationLocked();
153 
154     void getInputDevicesLocked(std::vector<InputDeviceInfo>& outInputDevices);
155 
156     nsecs_t mDisableVirtualKeysTimeout;
157     void disableVirtualKeysUntilLocked(nsecs_t time);
158     bool shouldDropVirtualKeyLocked(nsecs_t now, InputDevice* device, int32_t keyCode,
159                                     int32_t scanCode);
160 
161     nsecs_t mNextTimeout;
162     void requestTimeoutAtTimeLocked(nsecs_t when);
163 
164     uint32_t mConfigurationChangesToRefresh;
165     void refreshConfigurationLocked(uint32_t changes);
166 
167     // state queries
168     typedef int32_t (InputDevice::*GetStateFunc)(uint32_t sourceMask, int32_t code);
169     int32_t getStateLocked(int32_t deviceId, uint32_t sourceMask, int32_t code,
170                            GetStateFunc getStateFunc);
171     bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
172                                      const int32_t* keyCodes, uint8_t* outFlags);
173 };
174 
175 } // namespace android
176 
177 #endif // _UI_INPUTREADER_INPUT_READER_H
178