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 "gesture_monitor_handler.h" 20 #include "i_input_event_collection_handler.h" 21 #include "i_input_event_handler.h" 22 #include "nap_process.h" 23 24 namespace OHOS { 25 namespace MMI { 26 class EventMonitorHandler final : public IInputEventHandler { 27 public: 28 EventMonitorHandler() = default; 29 DISALLOW_COPY_AND_MOVE(EventMonitorHandler); 30 ~EventMonitorHandler() override = default; 31 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 32 void HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent) override; 33 #endif // OHOS_BUILD_ENABLE_KEYBOARD 34 #ifdef OHOS_BUILD_ENABLE_POINTER 35 void HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent) override; 36 #endif // OHOS_BUILD_ENABLE_POINTER 37 #ifdef OHOS_BUILD_ENABLE_TOUCH 38 void HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent) override; 39 #endif // OHOS_BUILD_ENABLE_TOUCH 40 bool CheckHasInputHandler(HandleEventType eventType); 41 int32_t AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, 42 std::shared_ptr<IInputEventConsumer> callback, 43 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 44 void RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, 45 std::shared_ptr<IInputEventConsumer> callback, 46 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 47 int32_t AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, 48 SessionPtr session, TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 49 void RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, 50 SessionPtr session, TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0); 51 int32_t AddInputHandler(InputHandlerType handlerType, std::vector<int32_t> actionsType, SessionPtr session); 52 void RemoveInputHandler(InputHandlerType handlerType, std::vector<int32_t> actionsType, SessionPtr session); 53 void MarkConsumed(int32_t eventId, SessionPtr session); 54 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 55 bool OnHandleEvent(std::shared_ptr<KeyEvent> KeyEvent); 56 #endif // OHOS_BUILD_ENABLE_KEYBOARD 57 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 58 bool OnHandleEvent(std::shared_ptr<PointerEvent> PointerEvent); 59 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 60 void Dump(int32_t fd, const std::vector<std::string> &args); 61 #ifdef PLAYER_FRAMEWORK_EXISTS 62 void ProcessScreenCapture(int32_t pid, bool isStart); 63 #endif 64 65 private: 66 void InitSessionLostCallback(); 67 void OnSessionLost(SessionPtr session); 68 69 private: 70 class SessionHandler { 71 public: 72 SessionHandler(InputHandlerType handlerType, HandleEventType eventType, 73 std::shared_ptr<IInputEventConsumer> cb, 74 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0) handlerType_(handlerType)75 : handlerType_(handlerType), eventType_(eventType & HANDLE_EVENT_TYPE_ALL), callback_(cb) 76 { 77 if ((gestureType & TOUCH_GESTURE_TYPE_ALL) != TOUCH_GESTURE_TYPE_NONE) { 78 gesture_.AddGestureMonitor(gestureType, fingers); 79 } 80 } 81 82 SessionHandler(InputHandlerType handlerType, HandleEventType eventType, SessionPtr session, 83 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE, int32_t fingers = 0) handlerType_(handlerType)84 : handlerType_(handlerType), eventType_(eventType & HANDLE_EVENT_TYPE_ALL), session_(session) 85 { 86 if ((gestureType & TOUCH_GESTURE_TYPE_ALL) != TOUCH_GESTURE_TYPE_NONE) { 87 gesture_.AddGestureMonitor(gestureType, fingers); 88 } 89 } 90 91 SessionHandler(InputHandlerType handlerType, uint32_t eventType, SessionPtr session, 92 std::vector<int32_t> actionsType, std::shared_ptr<IInputEventConsumer> cb = nullptr) handlerType_(handlerType)93 : handlerType_(handlerType), eventType_(eventType), session_(session), actionsType_(actionsType), 94 callback_(cb) {} 95 SessionHandler(const SessionHandler & other)96 SessionHandler(const SessionHandler& other) 97 { 98 handlerType_ = other.handlerType_; 99 eventType_ = other.eventType_; 100 session_ = other.session_; 101 callback_ = other.callback_; 102 gesture_ = other.gesture_; 103 actionsType_ = other.actionsType_; 104 } 105 106 bool Expect(std::shared_ptr<PointerEvent> pointerEvent) const; 107 void SendToClient(std::shared_ptr<KeyEvent> keyEvent, NetPacket &pkt) const; 108 void SendToClient(std::shared_ptr<PointerEvent> pointerEvent, NetPacket &pkt) const; 109 bool operator<(const SessionHandler& other) const 110 { 111 return (session_ < other.session_); 112 } operator()113 void operator()(const GestureMonitorHandler& other) 114 { 115 gesture_ = other; 116 } 117 118 InputHandlerType handlerType_; 119 HandleEventType eventType_; 120 SessionPtr session_ { nullptr }; 121 std::vector<int32_t> actionsType_; 122 GestureMonitorHandler gesture_; 123 std::shared_ptr<IInputEventConsumer> callback_ { nullptr }; 124 }; 125 126 class MonitorCollection : public IInputEventCollectionHandler, protected NoCopyable { 127 public: 128 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 129 virtual bool HandleEvent(std::shared_ptr<KeyEvent> KeyEvent) override; 130 #endif // OHOS_BUILD_ENABLE_KEYBOARD 131 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 132 virtual bool HandleEvent(std::shared_ptr<PointerEvent> pointerEvent) override; 133 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 134 bool CheckHasInputHandler(HandleEventType eventType); 135 int32_t UpdateEventTypeMonitor(const std::set<SessionHandler>::iterator &iter, 136 const SessionHandler &monitor, SessionHandler &handler, bool isFound); 137 int32_t UpdateActionsTypeMonitor(const std::set<SessionHandler>::iterator &iter, 138 const SessionHandler &monitor, bool isFound); 139 int32_t AddMonitor(const SessionHandler& mon); 140 void RemoveMonitor(const SessionHandler& mon); 141 void MarkConsumed(int32_t eventId, SessionPtr session); 142 bool IsNeedInsertToMonitors(std::vector<int32_t> actionsType); 143 144 bool HasMonitor(SessionPtr session); 145 bool HasScreenCaptureMonitor(SessionPtr session); 146 void RemoveScreenCaptureMonitor(SessionPtr session); 147 void RecoveryScreenCaptureMonitor(SessionPtr session); 148 #ifdef OHOS_BUILD_ENABLE_TOUCH 149 void UpdateConsumptionState(std::shared_ptr<PointerEvent> pointerEvent); 150 #endif // OHOS_BUILD_ENABLE_TOUCH 151 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 152 void IsSendToClient(const SessionHandler &monitor, std::shared_ptr<PointerEvent> pointerEvent, 153 NetPacket &pkt); 154 void Monitor(std::shared_ptr<PointerEvent> pointerEvent); 155 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 156 void OnSessionLost(SessionPtr session); 157 void Dump(int32_t fd, const std::vector<std::string> &args); 158 bool CheckIfNeedSendToClient(SessionHandler monitor, std::shared_ptr<PointerEvent> pointerEvent); 159 bool IsPinch(std::shared_ptr<PointerEvent> pointerEvent); 160 bool IsRotate(std::shared_ptr<PointerEvent> pointerEvent); 161 bool IsThreeFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent); 162 bool IsFourFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent); 163 bool IsBeginAndEnd(std::shared_ptr<PointerEvent> pointerEvent); 164 bool IsThreeFingersTap(std::shared_ptr<PointerEvent> pointerEvent); 165 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT 166 bool IsFingerprint(std::shared_ptr<PointerEvent> pointerEvent); 167 #endif // OHOS_BUILD_ENABLE_FINGERPRINT 168 169 struct ConsumptionState { 170 std::set<int32_t> eventIds_; 171 bool isMonitorConsumed_ { false }; 172 std::shared_ptr<PointerEvent> lastPointerEvent_ { nullptr }; 173 }; 174 175 private: 176 std::set<SessionHandler> monitors_; 177 std::map<int32_t, std::set<SessionHandler>> endScreenCaptureMonitors_; 178 std::unordered_map<int32_t, ConsumptionState> states_; 179 std::vector<int32_t> insertToMonitorsActions_; 180 }; 181 182 private: 183 bool sessionLostCallbackInitialized_ { false }; 184 MonitorCollection monitors_; 185 }; 186 } // namespace MMI 187 } // namespace OHOS 188 #endif // EVENT_MONITOR_HANDLER_H