1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <InputListener.h>
#include <android-base/result.h>
#include <android/gui/FocusRequest.h>
#include <android/os/InputEventInjectionResult.h>
#include <android/os/InputEventInjectionSync.h>
#include <gui/InputApplication.h>
#include <gui/WindowInfo.h>
#include <input/InputDevice.h>
#include <input/InputTransport.h>
#include <unordered_map>
namespace android {
/* Notifies the system about input events generated by the input reader.
* The dispatcher is expected to be mostly asynchronous. */
class InputDispatcherInterface : public InputListenerInterface {
public:
InputDispatcherInterface() {}
virtual ~InputDispatcherInterface() {}
/* Dumps the state of the input dispatcher.
*
* This method may be called on any thread (usually by the input manager). */
virtual void dump(std::string& dump) const = 0;
/* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */
virtual void monitor() = 0;
/**
* Wait until dispatcher is idle. That means, there are no further events to be processed,
* and all of the policy callbacks have been completed.
* Return true if the dispatcher is idle.
* Return false if the timeout waiting for the dispatcher to become idle has expired.
*/
virtual bool waitForIdle() const = 0;
/* Make the dispatcher start processing events.
*
* The dispatcher will start consuming events from the InputListenerInterface
* in the order that they were received.
*/
virtual status_t start() = 0;
/* Makes the dispatcher stop processing events. */
virtual status_t stop() = 0;
/* Injects an input event and optionally waits for sync.
* The synchronization mode determines whether the method blocks while waiting for
* input injection to proceed.
* Returns one of the INPUT_EVENT_INJECTION_XXX constants.
*
* If a targetUid is provided, InputDispatcher will only consider injecting the input event into
* windows owned by the provided uid. If the input event is targeted at a window that is not
* owned by the provided uid, input injection will fail. If no targetUid is provided, the input
* event will be dispatched as-is.
*
* This method may be called on any thread (usually by the input manager). The caller must
* perform all necessary permission checks prior to injecting events.
*/
virtual android::os::InputEventInjectionResult injectInputEvent(
const InputEvent* event, std::optional<gui::Uid> targetUid,
android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout,
uint32_t policyFlags) = 0;
/*
* Check whether InputEvent actually happened by checking the signature of the event.
*
* Return nullptr if the event cannot be verified.
*/
virtual std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) = 0;
/* Sets the focused application on the given display.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual void setFocusedApplication(
int32_t displayId,
const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) = 0;
/* Sets the focused display.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual void setFocusedDisplay(int32_t displayId) = 0;
/** Sets the minimum time between user activity pokes. */
virtual void setMinTimeBetweenUserActivityPokes(std::chrono::milliseconds interval) = 0;
/* Sets the input dispatching mode.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual void setInputDispatchMode(bool enabled, bool frozen) = 0;
/* Sets whether input event filtering is enabled.
* When enabled, incoming input events are sent to the policy's filterInputEvent
* method instead of being dispatched. The filter is expected to use
* injectInputEvent to inject the events it would like to have dispatched.
* It should include POLICY_FLAG_FILTERED in the policy flags during injection.
*/
virtual void setInputFilterEnabled(bool enabled) = 0;
/**
* Set the touch mode state.
* Touch mode is a per display state that apps may enter / exit based on specific user
* interactions with input devices. If <code>inTouchMode</code> is set to true, the display
* identified by <code>displayId</code> will be changed to touch mode. Performs a permission
* check if hasPermission is set to false.
*
* This method also enqueues a a TouchModeEntry message for dispatching.
*
* Returns true when changing touch mode state.
*/
virtual bool setInTouchMode(bool inTouchMode, gui::Pid pid, gui::Uid uid, bool hasPermission,
int32_t displayId) = 0;
/**
* Sets the maximum allowed obscuring opacity by UID to propagate touches.
* For certain window types (eg. SAWs), the decision of honoring
* FLAG_NOT_TOUCHABLE or not depends on the combined obscuring opacity of
* the windows above the touch-consuming window.
*/
virtual void setMaximumObscuringOpacityForTouch(float opacity) = 0;
/**
* Transfers a touch gesture from one window to another window. Transferring touch will not
* have any effect on the focused window.
*
* Returns true on success. False if the window did not actually have an active touch gesture.
*/
virtual bool transferTouchGesture(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
bool isDragDrop) = 0;
/**
* Transfer a touch gesture to the provided channel, no matter where the current touch is.
* Transferring touch will not have any effect on the focused window.
*
* Returns true on success, false if there was no on-going touch on the display.
* @deprecated
*/
virtual bool transferTouchOnDisplay(const sp<IBinder>& destChannelToken, int32_t displayId) = 0;
/**
* Sets focus on the specified window.
*/
virtual void setFocusedWindow(const gui::FocusRequest&) = 0;
/**
* Creates an input channel that may be used as targets for input events.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual base::Result<std::unique_ptr<InputChannel>> createInputChannel(
const std::string& name) = 0;
/**
* Creates an input channel to be used to monitor all input events on a display.
*
* Each monitor must target a specific display and will only receive input events sent to that
* display.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual base::Result<std::unique_ptr<InputChannel>> createInputMonitor(int32_t displayId,
const std::string& name,
gui::Pid pid) = 0;
/* Removes input channels that will no longer receive input events.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual status_t removeInputChannel(const sp<IBinder>& connectionToken) = 0;
/* Allows an input monitor steal the current pointer stream away from normal input windows.
*
* This method may be called on any thread (usually by the input manager).
*/
virtual status_t pilferPointers(const sp<IBinder>& token) = 0;
/**
* Enables Pointer Capture on the specified window if the window has focus.
*
* InputDispatcher is the source of truth of Pointer Capture.
*/
virtual void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) = 0;
/**
* Sets the eligibility of a given display to enable pointer capture. If a display is marked
* ineligible, all attempts to request pointer capture for windows on that display will fail.
* TODO(b/214621487): Remove or move to a display flag.
*/
virtual void setDisplayEligibilityForPointerCapture(int displayId, bool isEligible) = 0;
/* Flush input device motion sensor.
*
* Returns true on success.
*/
virtual bool flushSensor(int deviceId, InputDeviceSensorType sensorType) = 0;
/**
* Called when a display has been removed from the system.
*/
virtual void displayRemoved(int32_t displayId) = 0;
/*
* Abort the current touch stream.
*/
virtual void cancelCurrentTouch() = 0;
/*
* Updates key repeat configuration timeout and delay.
*/
virtual void setKeyRepeatConfiguration(std::chrono::nanoseconds timeout,
std::chrono::nanoseconds delay) = 0;
/*
* Determine if a pointer from a device is being dispatched to the given window.
*/
virtual bool isPointerInWindow(const sp<IBinder>& token, int32_t displayId, DeviceId deviceId,
int32_t pointerId) = 0;
};
} // namespace android
|
