1 /* 2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef EVENT_MONITOR_HANDLER_H 17 #define EVENT_MONITOR_HANDLER_H 18 19 #include <unordered_set> 20 21 #include "gesture_monitor_handler.h" 22 #include "i_input_event_collection_handler.h" 23 #include "i_input_event_handler.h" 24 #include "nap_process.h" 25 26 namespace OHOS { 27 namespace MMI { 28 class EventMonitorHandler final : public IInputEventHandler { 29 public: 30 EventMonitorHandler() = default; 31 DISALLOW_COPY_AND_MOVE(EventMonitorHandler); 32 ~EventMonitorHandler() override = default; 33 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 34 void HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent) override; 35 #endif // OHOS_BUILD_ENABLE_KEYBOARD 36 #ifdef OHOS_BUILD_ENABLE_POINTER 37 void HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent) override; 38 #endif // OHOS_BUILD_ENABLE_POINTER 39 #ifdef OHOS_BUILD_ENABLE_TOUCH 40 void HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent) override; 41 #endif // OHOS_BUILD_ENABLE_TOUCH 42 bool CheckHasInputHandler(HandleEventType eventType); 43 int32_t AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, 44 std::shared_ptr<IInputEventConsumer> callback, 45 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 46 void RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, 47 std::shared_ptr<IInputEventConsumer> callback, 48 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 49 int32_t AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, 50 SessionPtr session, TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 51 void RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, 52 SessionPtr session, TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 53 int32_t AddInputHandler(InputHandlerType handlerType, std::vector<int32_t> actionsType, SessionPtr session); 54 void RemoveInputHandler(InputHandlerType handlerType, std::vector<int32_t> actionsType, SessionPtr session); 55 void MarkConsumed(int32_t eventId, SessionPtr session); 56 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 57 bool OnHandleEvent(std::shared_ptr<KeyEvent> KeyEvent); 58 #endif // OHOS_BUILD_ENABLE_KEYBOARD 59 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 60 bool OnHandleEvent(std::shared_ptr<PointerEvent> PointerEvent); 61 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 62 void Dump(int32_t fd, const std::vector<std::string> &args); 63 #ifdef PLAYER_FRAMEWORK_EXISTS 64 void ProcessScreenCapture(int32_t pid, bool isStart); 65 #endif 66 67 private: 68 void InitSessionLostCallback(); 69 void OnSessionLost(SessionPtr session); 70 71 private: 72 class SessionHandler { 73 public: 74 SessionHandler(InputHandlerType handlerType, HandleEventType eventType, 75 std::shared_ptr<IInputEventConsumer> cb, 76 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0) handlerType_(handlerType)77 : handlerType_(handlerType), eventType_(eventType & HANDLE_EVENT_TYPE_ALL), callback_(cb) 78 { 79 if ((gestureType & TOUCH_GESTURE_TYPE_ALL) != TOUCH_GESTURE_TYPE_NONE) { 80 gesture_.AddGestureMonitor(gestureType, fingers); 81 } 82 } 83 84 SessionHandler(InputHandlerType handlerType, HandleEventType eventType, SessionPtr session, 85 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0) handlerType_(handlerType)86 : handlerType_(handlerType), eventType_(eventType & HANDLE_EVENT_TYPE_ALL), session_(session) 87 { 88 if ((gestureType & TOUCH_GESTURE_TYPE_ALL) != TOUCH_GESTURE_TYPE_NONE) { 89 gesture_.AddGestureMonitor(gestureType, fingers); 90 } 91 } 92 93 SessionHandler(InputHandlerType handlerType, uint32_t eventType, SessionPtr session, 94 std::vector<int32_t> actionsType, std::shared_ptr<IInputEventConsumer> cb = nullptr) handlerType_(handlerType)95 : handlerType_(handlerType), eventType_(eventType), session_(session), actionsType_(actionsType), 96 callback_(cb) {} 97 SessionHandler(const SessionHandler & other)98 SessionHandler(const SessionHandler& other) 99 { 100 handlerType_ = other.handlerType_; 101 eventType_ = other.eventType_; 102 session_ = other.session_; 103 callback_ = other.callback_; 104 gesture_ = other.gesture_; 105 actionsType_ = other.actionsType_; 106 } 107 108 bool Expect(std::shared_ptr<PointerEvent> pointerEvent) const; 109 void SendToClient(std::shared_ptr<KeyEvent> keyEvent, NetPacket &pkt) const; 110 void SendToClient(std::shared_ptr<PointerEvent> pointerEvent, NetPacket &pkt) const; 111 bool operator<(const SessionHandler& other) const 112 { 113 return (session_ < other.session_); 114 } operator()115 void operator()(const GestureMonitorHandler& other) 116 { 117 gesture_ = other; 118 } 119 120 InputHandlerType handlerType_; 121 HandleEventType eventType_; 122 SessionPtr session_ { nullptr }; 123 std::vector<int32_t> actionsType_; 124 GestureMonitorHandler gesture_; 125 std::shared_ptr<IInputEventConsumer> callback_ { nullptr }; 126 }; 127 128 class MonitorCollection : public IInputEventCollectionHandler, protected NoCopyable { 129 public: 130 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 131 virtual bool HandleEvent(std::shared_ptr<KeyEvent> KeyEvent) override; 132 #endif // OHOS_BUILD_ENABLE_KEYBOARD 133 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 134 virtual bool HandleEvent(std::shared_ptr<PointerEvent> pointerEvent) override; 135 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 136 bool CheckHasInputHandler(HandleEventType eventType); 137 int32_t UpdateEventTypeMonitor(const std::set<SessionHandler>::iterator &iter, 138 const SessionHandler &monitor, SessionHandler &handler, bool isFound); 139 int32_t UpdateActionsTypeMonitor(const std::set<SessionHandler>::iterator &iter, 140 const SessionHandler &monitor, bool isFound); 141 int32_t AddMonitor(const SessionHandler& mon); 142 void RemoveMonitor(const SessionHandler& mon); 143 void MarkConsumed(int32_t eventId, SessionPtr session); 144 bool IsNeedInsertToMonitors(std::vector<int32_t> actionsType); 145 146 bool HasMonitor(SessionPtr session); 147 bool HasScreenCaptureMonitor(SessionPtr session); 148 void RemoveScreenCaptureMonitor(SessionPtr session); 149 void RecoveryScreenCaptureMonitor(SessionPtr session); 150 #ifdef OHOS_BUILD_ENABLE_TOUCH 151 void UpdateConsumptionState(std::shared_ptr<PointerEvent> pointerEvent); 152 #endif // OHOS_BUILD_ENABLE_TOUCH 153 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 154 void IsSendToClient(const SessionHandler &monitor, std::shared_ptr<PointerEvent> pointerEvent, 155 NetPacket &pkt, std::unordered_set<int32_t> fingerFocusPidSet); 156 void Monitor(std::shared_ptr<PointerEvent> pointerEvent); 157 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 158 void OnSessionLost(SessionPtr session); 159 void Dump(int32_t fd, const std::vector<std::string> &args); 160 bool CheckIfNeedSendToClient(SessionHandler monitor, std::shared_ptr<PointerEvent> pointerEvent, 161 std::unordered_set<int32_t> fingerFocusPidSet); 162 bool IsPinch(std::shared_ptr<PointerEvent> pointerEvent); 163 bool IsRotate(std::shared_ptr<PointerEvent> pointerEvent); 164 bool IsThreeFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent); 165 bool IsFourFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent); 166 bool IsBeginAndEnd(std::shared_ptr<PointerEvent> pointerEvent); 167 bool IsThreeFingersTap(std::shared_ptr<PointerEvent> pointerEvent); 168 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT 169 bool IsFingerprint(std::shared_ptr<PointerEvent> pointerEvent); 170 bool CheckIfNeedSendFingerprintEvent(SessionHandler &monitor, std::shared_ptr<PointerEvent> pointerEvent, 171 std::unordered_set<int32_t> fingerFocusPidSet); 172 #endif // OHOS_BUILD_ENABLE_FINGERPRINT 173 #ifdef OHOS_BUILD_ENABLE_X_KEY 174 bool IsXKey(std::shared_ptr<PointerEvent> pointerEvent); 175 #endif // OHOS_BUILD_ENABLE_X_KEY 176 177 struct ConsumptionState { 178 std::set<int32_t> eventIds_; 179 bool isMonitorConsumed_ { false }; 180 std::shared_ptr<PointerEvent> lastPointerEvent_ { nullptr }; 181 }; 182 183 private: 184 std::set<SessionHandler> monitors_; 185 std::map<int32_t, std::set<SessionHandler>> endScreenCaptureMonitors_; 186 std::unordered_map<int32_t, ConsumptionState> states_; 187 std::vector<int32_t> insertToMonitorsActions_; 188 }; 189 190 private: 191 bool sessionLostCallbackInitialized_ { false }; 192 MonitorCollection monitors_; 193 }; 194 } // namespace MMI 195 } // namespace OHOS 196 #endif // EVENT_MONITOR_HANDLER_H