1 /*
2  * Copyright (C) 2019 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 #pragma once
18 
19 #include "InputDispatcherConfiguration.h"
20 
21 #include <android-base/properties.h>
22 #include <binder/IBinder.h>
23 #include <gui/InputApplication.h>
24 #include <gui/PidUid.h>
25 #include <input/Input.h>
26 #include <input/InputDevice.h>
27 #include <utils/RefBase.h>
28 #include <set>
29 
30 namespace android {
31 
32 /*
33  * Input dispatcher policy interface.
34  *
35  * The input dispatcher policy is used by the input dispatcher to interact with the Window Manager
36  * and other system components.
37  *
38  * The actual implementation is partially supported by callbacks into the DVM
39  * via JNI.  This interface is also mocked in the unit tests.
40  */
41 class InputDispatcherPolicyInterface {
42 public:
43     InputDispatcherPolicyInterface() = default;
44     virtual ~InputDispatcherPolicyInterface() = default;
45 
46     /* Notifies the system that an application does not have a focused window.
47      */
48     virtual void notifyNoFocusedWindowAnr(
49             const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) = 0;
50 
51     /* Notifies the system that a window just became unresponsive. This indicates that ANR
52      * should be raised for this window. The window can be identified via its input token and the
53      * pid of the owner. The string reason contains information about the input event that we
54      * haven't received a response for.
55      */
56     virtual void notifyWindowUnresponsive(const sp<IBinder>& token, std::optional<gui::Pid> pid,
57                                           const std::string& reason) = 0;
58 
59     /* Notifies the system that a window just became responsive. This is only called after the
60      * window was first marked "unresponsive". This indicates that ANR dialog (if any) should
61      * no longer should be shown to the user. The window is eligible to cause a new ANR in the
62      * future.
63      */
64     virtual void notifyWindowResponsive(const sp<IBinder>& token, std::optional<gui::Pid> pid) = 0;
65 
66     /* Notifies the system that an input channel is unrecoverably broken. */
67     virtual void notifyInputChannelBroken(const sp<IBinder>& token) = 0;
68     virtual void notifyFocusChanged(const sp<IBinder>& oldToken, const sp<IBinder>& newToken) = 0;
69     virtual void notifySensorEvent(int32_t deviceId, InputDeviceSensorType sensorType,
70                                    InputDeviceSensorAccuracy accuracy, nsecs_t timestamp,
71                                    const std::vector<float>& values) = 0;
72     virtual void notifySensorAccuracy(int32_t deviceId, InputDeviceSensorType sensorType,
73                                       InputDeviceSensorAccuracy accuracy) = 0;
74     virtual void notifyVibratorState(int32_t deviceId, bool isOn) = 0;
75 
76     /*
77      * Notifies the system that focused display has changed.
78      */
79     virtual void notifyFocusedDisplayChanged(ui::LogicalDisplayId displayId) = 0;
80 
81     /* Filters an input event.
82      * Return true to dispatch the event unmodified, false to consume the event.
83      * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED
84      * to injectInputEvent.
85      */
86     virtual bool filterInputEvent(const InputEvent& inputEvent, uint32_t policyFlags) = 0;
87 
88     /* Intercepts a key event immediately before queueing it.
89      * The policy can use this method as an opportunity to perform power management functions
90      * and early event preprocessing such as updating policy flags.
91      *
92      * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
93      * should be dispatched to applications.
94      */
95     virtual void interceptKeyBeforeQueueing(const KeyEvent& keyEvent, uint32_t& policyFlags) = 0;
96 
97     /* Intercepts a touch, trackball or other motion event before queueing it.
98      * The policy can use this method as an opportunity to perform power management functions
99      * and early event preprocessing such as updating policy flags.
100      *
101      * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
102      * should be dispatched to applications.
103      */
104     virtual void interceptMotionBeforeQueueing(ui::LogicalDisplayId displayId, uint32_t source,
105                                                int32_t action, nsecs_t when,
106                                                uint32_t& policyFlags) = 0;
107 
108     /* Allows the policy a chance to intercept a key before dispatching. */
109     virtual nsecs_t interceptKeyBeforeDispatching(const sp<IBinder>& token,
110                                                   const KeyEvent& keyEvent,
111                                                   uint32_t policyFlags) = 0;
112 
113     /* Allows the policy a chance to perform default processing for an unhandled key.
114      * Returns an alternate key event to redispatch as a fallback, if needed. */
115     virtual std::optional<KeyEvent> dispatchUnhandledKey(const sp<IBinder>& token,
116                                                          const KeyEvent& keyEvent,
117                                                          uint32_t policyFlags) = 0;
118 
119     /* Notifies the policy about switch events.
120      */
121     virtual void notifySwitch(nsecs_t when, uint32_t switchValues, uint32_t switchMask,
122                               uint32_t policyFlags) = 0;
123 
124     /* Poke user activity for an event dispatched to a window. */
125     virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType,
126                                   ui::LogicalDisplayId displayId) = 0;
127 
128     /*
129      * Return true if the provided event is stale, and false otherwise. Used for determining
130      * whether the dispatcher should drop the event.
131      */
isStaleEvent(nsecs_t currentTime,nsecs_t eventTime)132     virtual bool isStaleEvent(nsecs_t currentTime, nsecs_t eventTime) {
133         static const std::chrono::duration STALE_EVENT_TIMEOUT =
134                 std::chrono::seconds(10) * android::base::HwTimeoutMultiplier();
135         return std::chrono::nanoseconds(currentTime - eventTime) >= STALE_EVENT_TIMEOUT;
136     }
137 
138     /**
139      * Get the additional latency to add while waiting for other input events to process before
140      * dispatching the pending key.
141      * If there are unprocessed events, the pending key will not be dispatched immediately. Instead,
142      * the dispatcher will wait for this timeout, to account for the possibility that the focus
143      * might change due to touch or other events (such as another app getting launched by keys).
144      * This would give the pending key the opportunity to go to a newly focused window instead.
145      */
getKeyWaitingForEventsTimeout()146     virtual std::chrono::nanoseconds getKeyWaitingForEventsTimeout() {
147         return KEY_WAITING_FOR_EVENTS_TIMEOUT;
148     }
149 
150     /* Notifies the policy that a pointer down event has occurred outside the current focused
151      * window.
152      *
153      * The touchedToken passed as an argument is the window that received the input event.
154      */
155     virtual void onPointerDownOutsideFocus(const sp<IBinder>& touchedToken) = 0;
156 
157     /* Change the Pointer Capture state in InputReader.
158      *
159      * InputDispatcher is solely responsible for updating the Pointer Capture state.
160      */
161     virtual void setPointerCapture(const PointerCaptureRequest&) = 0;
162 
163     /* Notifies the policy that the drag window has moved over to another window */
164     virtual void notifyDropWindow(const sp<IBinder>& token, float x, float y) = 0;
165 
166     /* Notifies the policy that there was an input device interaction with apps. */
167     virtual void notifyDeviceInteraction(DeviceId deviceId, nsecs_t timestamp,
168                                          const std::set<gui::Uid>& uids) = 0;
169 
170 private:
171     // Additional key latency in case a connection is still processing some motion events.
172     // This will help with the case when a user touched a button that opens a new window,
173     // and gives us the chance to dispatch the key to this new window.
174     static constexpr std::chrono::nanoseconds KEY_WAITING_FOR_EVENTS_TIMEOUT =
175             std::chrono::milliseconds(500);
176 };
177 
178 } // namespace android
179