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_INPUT_MANAGER_H
18 #define _UI_INPUT_MANAGER_H
19 
20 /**
21  * Native input manager.
22  */
23 
24 #include "InputClassifier.h"
25 #include "InputReaderBase.h"
26 
27 #include <InputDispatcherInterface.h>
28 #include <InputDispatcherPolicyInterface.h>
29 #include <input/Input.h>
30 #include <input/InputTransport.h>
31 
32 #include <android/os/BnInputFlinger.h>
33 #include <android/os/IInputFlinger.h>
34 #include <utils/Errors.h>
35 #include <utils/RefBase.h>
36 #include <utils/Timers.h>
37 #include <utils/Vector.h>
38 
39 using android::os::BnInputFlinger;
40 
41 namespace android {
42 class InputChannel;
43 class InputDispatcherThread;
44 
45 /*
46  * The input manager is the core of the system event processing.
47  *
48  * The input manager has three components.
49  *
50  * 1. The InputReader class starts a thread that reads and preprocesses raw input events, applies
51  *    policy, and posts messages to a queue managed by the InputClassifier.
52  * 2. The InputClassifier class starts a thread to communicate with the device-specific
53  *    classifiers. It then waits on the queue of events from InputReader, applies a classification
54  *    to them, and queues them for the InputDispatcher.
55  * 3. The InputDispatcher class starts a thread that waits for new events on the
56  *    previous queue and asynchronously dispatches them to applications.
57  *
58  * By design, none of these classes share any internal state.  Moreover, all communication is
59  * done one way from the InputReader to the InputDispatcher and never the reverse.  All
60  * classes may interact with the InputDispatchPolicy, however.
61  *
62  * The InputManager class never makes any calls into Java itself.  Instead, the
63  * InputDispatchPolicy is responsible for performing all external interactions with the
64  * system, including calling DVM services.
65  */
66 class InputManagerInterface : public virtual RefBase {
67 protected:
InputManagerInterface()68     InputManagerInterface() { }
~InputManagerInterface()69     virtual ~InputManagerInterface() { }
70 
71 public:
72     /* Starts the input threads. */
73     virtual status_t start() = 0;
74 
75     /* Stops the input threads and waits for them to exit. */
76     virtual status_t stop() = 0;
77 
78     /* Gets the input reader. */
79     virtual sp<InputReaderInterface> getReader() = 0;
80 
81     /* Gets the input classifier */
82     virtual sp<InputClassifierInterface> getClassifier() = 0;
83 
84     /* Gets the input dispatcher. */
85     virtual sp<InputDispatcherInterface> getDispatcher() = 0;
86 };
87 
88 class InputManager : public InputManagerInterface, public BnInputFlinger {
89 protected:
90     ~InputManager() override;
91 
92 public:
93     InputManager(
94             const sp<InputReaderPolicyInterface>& readerPolicy,
95             const sp<InputDispatcherPolicyInterface>& dispatcherPolicy);
96 
97     status_t start() override;
98     status_t stop() override;
99 
100     sp<InputReaderInterface> getReader() override;
101     sp<InputClassifierInterface> getClassifier() override;
102     sp<InputDispatcherInterface> getDispatcher() override;
103 
104     status_t dump(int fd, const Vector<String16>& args) override;
105     binder::Status createInputChannel(const std::string& name, InputChannel* outChannel) override;
106     binder::Status removeInputChannel(const sp<IBinder>& connectionToken) override;
107     binder::Status setFocusedWindow(const gui::FocusRequest&) override;
108 
109 private:
110     sp<InputReaderInterface> mReader;
111 
112     sp<InputClassifierInterface> mClassifier;
113 
114     sp<InputDispatcherInterface> mDispatcher;
115 };
116 
117 } // namespace android
118 
119 #endif // _UI_INPUT_MANAGER_H
120