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