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 #include "event_monitor_handler.h"
17 
18 #include "common_event_support.h"
19 
20 #include "anr_manager.h"
21 #include "app_debug_listener.h"
22 #include "bytrace_adapter.h"
23 #include "define_multimodal.h"
24 #include "display_event_monitor.h"
25 #include "input_event_data_transformation.h"
26 #include "input_event_handler.h"
27 #include "mmi_log.h"
28 #include "napi_constants.h"
29 #include "net_packet.h"
30 #include "proto.h"
31 #include "util_ex.h"
32 #ifdef PLAYER_FRAMEWORK_EXISTS
33 #include "screen_capture_monitor.h"
34 #endif
35 
36 #undef MMI_LOG_DOMAIN
37 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER
38 #undef MMI_LOG_TAG
39 #define MMI_LOG_TAG "EventMonitorHandler"
40 
41 namespace OHOS {
42 namespace MMI {
43 namespace {
44 #ifdef OHOS_BUILD_ENABLE_TOUCH
45 constexpr size_t MAX_EVENTIDS_SIZE { 1000 };
46 #endif // OHOS_BUILD_ENABLE_TOUCH
47 constexpr int32_t ACTIVE_EVENT { 2 };
48 constexpr int32_t REMOVE_OBSERVER { -2 };
49 constexpr int32_t UNOBSERVED { -1 };
50 constexpr int32_t POWER_UID { 5528 };
51 constexpr int32_t THREE_FINGERS { 3 };
52 constexpr int32_t FOUR_FINGERS { 4 };
53 } // namespace
54 
55 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)56 void EventMonitorHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)
57 {
58     CHKPV(keyEvent);
59     OnHandleEvent(keyEvent);
60     CHKPV(nextHandler_);
61     nextHandler_->HandleKeyEvent(keyEvent);
62 }
63 #endif // OHOS_BUILD_ENABLE_KEYBOARD
64 
65 #ifdef OHOS_BUILD_ENABLE_POINTER
HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)66 void EventMonitorHandler::HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)
67 {
68     CHKPV(pointerEvent);
69     if (OnHandleEvent(pointerEvent)) {
70         BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP);
71         MMI_HILOGD("Monitor is succeeded");
72         return;
73     }
74     CHKPV(nextHandler_);
75     nextHandler_->HandlePointerEvent(pointerEvent);
76 }
77 #endif // OHOS_BUILD_ENABLE_POINTER
78 
79 #ifdef OHOS_BUILD_ENABLE_TOUCH
HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)80 void EventMonitorHandler::HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)
81 {
82     CHKPV(pointerEvent);
83     if (OnHandleEvent(pointerEvent)) {
84         BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP);
85         MMI_HILOGD("Monitor is succeeded");
86         return;
87     }
88     int32_t pointerId = pointerEvent->GetPointerId();
89     PointerEvent::PointerItem item;
90     if (pointerEvent->GetPointerItem(pointerId, item)) {
91         if (item.GetToolType() == PointerEvent::TOOL_TYPE_KNUCKLE) {
92             MMI_HILOGD("Knuckle event, skip");
93             return;
94         }
95     }
96     CHKPV(nextHandler_);
97     nextHandler_->HandleTouchEvent(pointerEvent);
98 }
99 #endif // OHOS_BUILD_ENABLE_TOUCH
100 
AddInputHandler(InputHandlerType handlerType,HandleEventType eventType,std::shared_ptr<IInputEventConsumer> callback)101 int32_t EventMonitorHandler::AddInputHandler(InputHandlerType handlerType,
102     HandleEventType eventType, std::shared_ptr<IInputEventConsumer> callback)
103 {
104     CALL_INFO_TRACE;
105     CHKPR(callback, RET_ERR);
106     if ((eventType & HANDLE_EVENT_TYPE_ALL) == HANDLE_EVENT_TYPE_NONE) {
107         MMI_HILOGE("Invalid event type");
108         return RET_ERR;
109     }
110     InitSessionLostCallback();
111     SessionHandler mon {handlerType, eventType, nullptr, callback};
112     return monitors_.AddMonitor(mon);
113 }
114 
AddInputHandler(InputHandlerType handlerType,HandleEventType eventType,SessionPtr session)115 int32_t EventMonitorHandler::AddInputHandler(InputHandlerType handlerType,
116     HandleEventType eventType, SessionPtr session)
117 {
118     CALL_INFO_TRACE;
119     CHKPR(session, RET_ERR);
120     if ((eventType & HANDLE_EVENT_TYPE_ALL) == HANDLE_EVENT_TYPE_NONE) {
121         MMI_HILOGE("Invalid event type");
122         return RET_ERR;
123     }
124     InitSessionLostCallback();
125     SessionHandler mon { handlerType, eventType, session };
126     return monitors_.AddMonitor(mon);
127 }
128 
RemoveInputHandler(InputHandlerType handlerType,HandleEventType eventType,std::shared_ptr<IInputEventConsumer> callback)129 void EventMonitorHandler::RemoveInputHandler(InputHandlerType handlerType,
130     HandleEventType eventType, std::shared_ptr<IInputEventConsumer> callback)
131 {
132     CALL_INFO_TRACE;
133     CHKPV(callback);
134     if (handlerType == InputHandlerType::MONITOR) {
135         SessionHandler monitor {handlerType, eventType, nullptr, callback};
136         monitors_.RemoveMonitor(monitor);
137     }
138 }
139 
RemoveInputHandler(InputHandlerType handlerType,HandleEventType eventType,SessionPtr session)140 void EventMonitorHandler::RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType,
141     SessionPtr session)
142 {
143     CALL_INFO_TRACE;
144     if (handlerType == InputHandlerType::MONITOR) {
145         SessionHandler monitor { handlerType, eventType, session };
146         monitors_.RemoveMonitor(monitor);
147     }
148 }
149 
MarkConsumed(int32_t eventId,SessionPtr session)150 void EventMonitorHandler::MarkConsumed(int32_t eventId, SessionPtr session)
151 {
152     LogTracer lt(eventId, 0, 0);
153     monitors_.MarkConsumed(eventId, session);
154 }
155 
156 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnHandleEvent(std::shared_ptr<KeyEvent> keyEvent)157 bool EventMonitorHandler::OnHandleEvent(std::shared_ptr<KeyEvent> keyEvent)
158 {
159     MMI_HILOGD("Handle KeyEvent");
160     CHKPF(keyEvent);
161     auto keyHandler = InputHandler->GetEventNormalizeHandler();
162     CHKPF(keyHandler);
163     if (keyEvent->GetKeyCode() != keyHandler->GetCurrentHandleKeyCode()) {
164         MMI_HILOGW("Keycode has been changed");
165     }
166     if (keyEvent->HasFlag(InputEvent::EVENT_FLAG_NO_MONITOR)) {
167         MMI_HILOGD("This event has been tagged as not to be monitored");
168     } else {
169         if (monitors_.HandleEvent(keyEvent)) {
170             MMI_HILOGD("Key event was consumed");
171             return true;
172         }
173     }
174     return false;
175 }
176 #endif // OHOS_BUILD_ENABLE_KEYBOARD
177 
178 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
OnHandleEvent(std::shared_ptr<PointerEvent> pointerEvent)179 bool EventMonitorHandler::OnHandleEvent(std::shared_ptr<PointerEvent> pointerEvent)
180 {
181     CHKPF(pointerEvent);
182     if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_NO_MONITOR)) {
183         MMI_HILOGD("This event has been tagged as not to be monitored");
184     } else {
185         if (monitors_.HandleEvent(pointerEvent)) {
186             MMI_HILOGD("Pointer event was monitor");
187             return true;
188         }
189     }
190     MMI_HILOGD("Interception and monitor failed");
191     return false;
192 }
193 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
194 
InitSessionLostCallback()195 void EventMonitorHandler::InitSessionLostCallback()
196 {
197     if (sessionLostCallbackInitialized_)  {
198         return;
199     }
200     auto udsServerPtr = InputHandler->GetUDSServer();
201     CHKPV(udsServerPtr);
202     udsServerPtr->AddSessionDeletedCallback([this] (SessionPtr session) {
203         return this->OnSessionLost(session);
204     }
205     );
206     sessionLostCallbackInitialized_ = true;
207     MMI_HILOGD("The callback on session deleted is registered successfully");
208 }
209 
OnSessionLost(SessionPtr session)210 void EventMonitorHandler::OnSessionLost(SessionPtr session)
211 {
212     monitors_.OnSessionLost(session);
213 }
214 
SendToClient(std::shared_ptr<KeyEvent> keyEvent,NetPacket & pkt) const215 void EventMonitorHandler::SessionHandler::SendToClient(std::shared_ptr<KeyEvent> keyEvent, NetPacket &pkt) const
216 {
217     CHKPV(keyEvent);
218     CHKPV(session_);
219     if (InputEventDataTransformation::KeyEventToNetPacket(keyEvent, pkt) != RET_OK) {
220         MMI_HILOGE("Packet key event failed, errCode:%{public}d", STREAM_BUF_WRITE_FAIL);
221         return;
222     }
223     if (!session_->SendMsg(pkt)) {
224         MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
225     }
226 }
227 
SendToClient(std::shared_ptr<PointerEvent> pointerEvent,NetPacket & pkt) const228 void EventMonitorHandler::SessionHandler::SendToClient(std::shared_ptr<PointerEvent> pointerEvent,
229                                                        NetPacket &pkt) const
230 {
231     CHKPV(pointerEvent);
232     CHKPV(session_);
233     MMI_HILOGD("Service SendToClient InputHandlerType:%{public}d, TokenType:%{public}d, pid:%{public}d",
234         handlerType_, session_->GetTokenType(), session_->GetPid());
235     if (!session_->SendMsg(pkt)) {
236         MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
237         return;
238     }
239 }
240 
AddMonitor(const SessionHandler & monitor)241 int32_t EventMonitorHandler::MonitorCollection::AddMonitor(const SessionHandler& monitor)
242 {
243     if (monitors_.size() >= MAX_N_INPUT_MONITORS) {
244         MMI_HILOGE("The number of monitors exceeds the maximum:%{public}zu, monitors errCode:%{public}d",
245                    monitors_.size(), INVALID_MONITOR_MON);
246         return RET_ERR;
247     }
248     bool isFound = false;
249     auto iter = monitors_.find(monitor);
250     if (iter != monitors_.end()) {
251         if (iter->eventType_ == monitor.eventType_) {
252             MMI_HILOGD("Monitor with event type (%{public}u) already exists", monitor.eventType_);
253             return RET_OK;
254         }
255         isFound = true;
256         monitors_.erase(iter);
257     }
258 
259     auto [sIter, isOk] = monitors_.insert(monitor);
260     if (!isOk) {
261         if (isFound) {
262             MMI_HILOGE("Internal error: monitor has been removed");
263         } else {
264             MMI_HILOGE("Failed to add monitor");
265         }
266         return RET_ERR;
267     }
268 
269     if (isFound) {
270         MMI_HILOGD("Event type is updated:%{public}u", monitor.eventType_);
271     } else {
272         MMI_HILOGD("Service Add Monitor Success");
273     }
274     return RET_OK;
275 }
276 
RemoveMonitor(const SessionHandler & monitor)277 void EventMonitorHandler::MonitorCollection::RemoveMonitor(const SessionHandler& monitor)
278 {
279     auto iter = monitors_.find(monitor);
280     if (iter == monitors_.cend()) {
281         MMI_HILOGE("Monitor does not exist");
282         return;
283     }
284 
285     monitors_.erase(iter);
286     if (monitor.session_) {
287         int32_t pid = monitor.session_->GetPid();
288         auto it = endScreenCaptureMonitors_.find(pid);
289         if (it != endScreenCaptureMonitors_.end()) {
290             auto setIter = endScreenCaptureMonitors_[pid].find(monitor);
291             if (setIter != endScreenCaptureMonitors_[pid].end()) {
292                 endScreenCaptureMonitors_[pid].erase(setIter);
293             }
294             if (endScreenCaptureMonitors_[pid].empty()) {
295                 endScreenCaptureMonitors_.erase(it);
296             }
297         }
298     }
299     if (monitor.eventType_ == HANDLE_EVENT_TYPE_NONE) {
300         MMI_HILOGD("Unregister monitor successfully");
301         return;
302     }
303 
304     auto [sIter, isOk] = monitors_.insert(monitor);
305     if (!isOk) {
306         MMI_HILOGE("Internal error, monitor has been removed");
307         return;
308     }
309     MMI_HILOGD("Event type is updated:%{public}u", monitor.eventType_);
310 }
311 
MarkConsumed(int32_t eventId,SessionPtr session)312 void EventMonitorHandler::MonitorCollection::MarkConsumed(int32_t eventId, SessionPtr session)
313 {
314     if (!HasMonitor(session)) {
315         MMI_HILOGW("Specified monitor does not exist");
316         return;
317     }
318     auto tIter = states_.begin();
319     for (; tIter != states_.end(); ++tIter) {
320         const auto &eventIds = tIter->second.eventIds_;
321         if (eventIds.find(eventId) != eventIds.cend()) {
322             break;
323         }
324     }
325     if (tIter == states_.end()) {
326         MMI_HILOGE("No operation corresponding to this event");
327         return;
328     }
329     ConsumptionState &state = tIter->second;
330 
331     if (state.isMonitorConsumed_) {
332         MMI_HILOGE("Corresponding operation has been marked as consumed");
333         return;
334     }
335     state.isMonitorConsumed_ = true;
336     CHKPV(state.lastPointerEvent_);
337 #ifdef OHOS_BUILD_ENABLE_TOUCH
338     MMI_HILOGD("Cancel operation");
339     auto pointerEvent = std::make_shared<PointerEvent>(*state.lastPointerEvent_);
340     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
341     pointerEvent->SetActionTime(GetSysClockTime());
342     pointerEvent->UpdateId();
343     pointerEvent->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT | InputEvent::EVENT_FLAG_NO_MONITOR);
344     auto inputEventNormalizeHandler = InputHandler->GetEventNormalizeHandler();
345     CHKPV(inputEventNormalizeHandler);
346     inputEventNormalizeHandler->HandleTouchEvent(pointerEvent);
347 #endif // OHOS_BUILD_ENABLE_TOUCH
348 }
349 
350 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleEvent(std::shared_ptr<KeyEvent> keyEvent)351 bool EventMonitorHandler::MonitorCollection::HandleEvent(std::shared_ptr<KeyEvent> keyEvent)
352 {
353     CHKPF(keyEvent);
354     MMI_HILOGD("There are currently %{public}zu monitors", monitors_.size());
355     NetPacket pkt(MmiMessageId::REPORT_KEY_EVENT);
356     pkt << InputHandlerType::MONITOR << static_cast<uint32_t>(evdev_device_udev_tags::EVDEV_UDEV_TAG_INPUT);
357     if (pkt.ChkRWError()) {
358         MMI_HILOGE("Packet write key event failed");
359         return false;
360     }
361     for (const auto &mon : monitors_) {
362         if ((mon.eventType_ & HANDLE_EVENT_TYPE_KEY) != HANDLE_EVENT_TYPE_KEY) {
363             continue;
364         }
365         if (!keyEvent->GetFourceMonitorFlag()) {
366             mon.SendToClient(keyEvent, pkt);
367         } else if (mon.session_ != nullptr && mon.session_->GetUid() == POWER_UID) {
368             mon.SendToClient(keyEvent, pkt);
369         }
370     }
371     if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER &&
372         NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
373         for (const auto &mon : monitors_) {
374             OHOS::MMI::NapProcess::NapStatusData napData;
375             auto sess = mon.session_;
376             if (!sess) {
377                 continue;
378             }
379             napData.pid = sess->GetPid();
380             napData.uid = sess->GetUid();
381             napData.bundleName = sess->GetProgramName();
382             if (NapProcess::GetInstance()->IsNeedNotify(napData)) {
383                 int32_t syncState = ACTIVE_EVENT;
384                 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
385                 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
386             }
387         }
388     }
389     return false;
390 }
391 #endif // OHOS_BUILD_ENABLE_KEYBOARD
392 
393 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
HandleEvent(std::shared_ptr<PointerEvent> pointerEvent)394 bool EventMonitorHandler::MonitorCollection::HandleEvent(std::shared_ptr<PointerEvent> pointerEvent)
395 {
396     CHKPF(pointerEvent);
397 #ifdef OHOS_BUILD_ENABLE_TOUCH
398     UpdateConsumptionState(pointerEvent);
399 #endif // OHOS_BUILD_ENABLE_TOUCH
400     Monitor(pointerEvent);
401     if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN ||
402         pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHPAD) {
403         auto iter = states_.find(pointerEvent->GetDeviceId());
404         return (iter != states_.end() ? iter->second.isMonitorConsumed_ : false);
405     }
406     MMI_HILOGD("This is not a touch-screen event");
407     return false;
408 }
409 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
410 
HasMonitor(SessionPtr session)411 bool EventMonitorHandler::MonitorCollection::HasMonitor(SessionPtr session)
412 {
413     SessionHandler monitor { InputHandlerType::MONITOR, HANDLE_EVENT_TYPE_ALL, session };
414     return (monitors_.find(monitor) != monitors_.end());
415 }
416 
HasScreenCaptureMonitor(SessionPtr session)417 bool EventMonitorHandler::MonitorCollection::HasScreenCaptureMonitor(SessionPtr session)
418 {
419     int32_t pid = session->GetPid();
420     return (endScreenCaptureMonitors_.find(pid) != endScreenCaptureMonitors_.end());
421 }
422 
RemoveScreenCaptureMonitor(SessionPtr session)423 void EventMonitorHandler::MonitorCollection::RemoveScreenCaptureMonitor(SessionPtr session)
424 {
425     if (session->GetTokenType() != TokenType::TOKEN_HAP) {
426         return;
427     }
428     int32_t pid = session->GetPid();
429     std::set<SessionHandler> monitorSet;
430     for (const auto &monitor : monitors_) {
431         if (monitor.session_ == session) {
432             SessionHandler screenCaptureMointor(monitor);
433             monitorSet.insert(screenCaptureMointor);
434         }
435     }
436     for (const auto &monitor : monitorSet) {
437         auto it = monitors_.find(monitor);
438         if (it != monitors_.end()) {
439             monitors_.erase(it);
440         }
441     }
442     endScreenCaptureMonitors_.emplace(pid, monitorSet);
443 }
444 
RecoveryScreenCaptureMonitor(SessionPtr session)445 void EventMonitorHandler::MonitorCollection::RecoveryScreenCaptureMonitor(SessionPtr session)
446 {
447     if (session->GetTokenType() != TokenType::TOKEN_HAP) {
448         return;
449     }
450     int32_t pid = session->GetPid();
451     auto it = endScreenCaptureMonitors_.find(pid);
452     if (it != endScreenCaptureMonitors_.end()) {
453         for (auto &monitor : endScreenCaptureMonitors_[pid]) {
454             SessionHandler screenCaptureMointor(monitor);
455             monitors_.insert(screenCaptureMointor);
456         }
457         endScreenCaptureMonitors_.erase(it);
458     }
459 }
460 
461 #ifdef OHOS_BUILD_ENABLE_TOUCH
UpdateConsumptionState(std::shared_ptr<PointerEvent> pointerEvent)462 void EventMonitorHandler::MonitorCollection::UpdateConsumptionState(std::shared_ptr<PointerEvent> pointerEvent)
463 {
464     CALL_DEBUG_ENTER;
465     CHKPV(pointerEvent);
466     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
467         pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD) {
468         return;
469     }
470     auto sIter = states_.find(pointerEvent->GetDeviceId());
471     if (sIter == states_.end()) {
472         auto [tIter, isOk] = states_.emplace(pointerEvent->GetDeviceId(), ConsumptionState());
473         if (!isOk) {
474             MMI_HILOGE("Failed to emplace consumption state");
475             return;
476         }
477         sIter = tIter;
478     }
479     ConsumptionState &state = sIter->second;
480     if (state.eventIds_.size() >= MAX_EVENTIDS_SIZE) {
481         auto iter = state.eventIds_.begin();
482         state.eventIds_.erase(iter);
483     }
484     auto [tIter, isOk] = state.eventIds_.emplace(pointerEvent->GetId());
485     if (!isOk) {
486         MMI_HILOGW("Failed to stash event");
487     }
488     state.lastPointerEvent_ = pointerEvent;
489 
490     if (pointerEvent->GetPointerIds().size() != 1) {
491         MMI_HILOGD("In intermediate process");
492         return;
493     }
494     if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN ||
495         pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_BEGIN ||
496         pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_SWIPE_BEGIN) {
497         MMI_HILOGD("First press down");
498         state.eventIds_.clear();
499         auto [tIter, isOk] = state.eventIds_.emplace(pointerEvent->GetId());
500         if (!isOk) {
501             MMI_HILOGW("Event number is duplicated");
502         }
503         state.isMonitorConsumed_ = false;
504     } else if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_UP ||
505         pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_END ||
506         pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_SWIPE_END) {
507         MMI_HILOGD("Last lift up");
508         state.eventIds_.clear();
509     }
510 }
511 #endif // OHOS_BUILD_ENABLE_TOUCH
512 
513 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
Monitor(std::shared_ptr<PointerEvent> pointerEvent)514 void EventMonitorHandler::MonitorCollection::Monitor(std::shared_ptr<PointerEvent> pointerEvent)
515 {
516     CHKPV(pointerEvent);
517     MMI_HILOGD("There are currently %{public}zu monitors", monitors_.size());
518     NetPacket pkt(MmiMessageId::REPORT_POINTER_EVENT);
519     pkt << InputHandlerType::MONITOR << static_cast<uint32_t>(evdev_device_udev_tags::EVDEV_UDEV_TAG_INPUT);
520     if (pkt.ChkRWError()) {
521         MMI_HILOGE("Packet write pointer event failed");
522         return;
523     }
524     if (InputEventDataTransformation::Marshalling(pointerEvent, pkt) != RET_OK) {
525         MMI_HILOGE("Marshalling pointer event failed, errCode:%{public}d", STREAM_BUF_WRITE_FAIL);
526         return;
527     }
528     for (const auto &monitor : monitors_) {
529         if ((monitor.eventType_ & HANDLE_EVENT_TYPE_ALL) == monitor.eventType_) {
530             if (monitor.session_ && CheckIfNeedSendToClient(monitor, pointerEvent)) {
531                 monitor.SendToClient(pointerEvent, pkt);
532                 continue;
533             }
534             if (monitor.callback) {
535                 monitor.callback->OnInputEvent(monitor.handlerType_, pointerEvent);
536             }
537         }
538     }
539     if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER &&
540         NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
541         for (const auto &mon : monitors_) {
542             OHOS::MMI::NapProcess::NapStatusData napData;
543             auto sess = mon.session_;
544             if (!sess) {
545                 continue;
546             }
547             napData.pid = sess->GetPid();
548             napData.uid = sess->GetUid();
549             napData.bundleName = sess->GetProgramName();
550             if (NapProcess::GetInstance()->IsNeedNotify(napData)) {
551                 int32_t syncState = ACTIVE_EVENT;
552                 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
553                 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
554             }
555         }
556     }
557 }
558 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
559 
IsPinch(std::shared_ptr<PointerEvent> pointerEvent)560 bool EventMonitorHandler::MonitorCollection::IsPinch(std::shared_ptr<PointerEvent> pointerEvent)
561 {
562     CHKPF(pointerEvent);
563     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_MOUSE &&
564         pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD) {
565         return false;
566     }
567     if ((pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_AXIS_BEGIN &&
568         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_AXIS_UPDATE &&
569         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_AXIS_END)) {
570         return false;
571     }
572     return true;
573 }
574 
IsRotate(std::shared_ptr<PointerEvent> pointerEvent)575 bool EventMonitorHandler::MonitorCollection::IsRotate(std::shared_ptr<PointerEvent> pointerEvent)
576 {
577     CHKPF(pointerEvent);
578     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_MOUSE ||
579         (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_ROTATE_BEGIN &&
580         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_ROTATE_UPDATE &&
581         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_ROTATE_END)) {
582         return false;
583     }
584     return true;
585 }
586 
IsThreeFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent)587 bool EventMonitorHandler::MonitorCollection::IsThreeFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent)
588 {
589     CHKPF(pointerEvent);
590     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD ||
591         pointerEvent->GetFingerCount() != THREE_FINGERS ||
592         (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_BEGIN &&
593         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_UPDATE &&
594         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_END)) {
595         return false;
596     }
597     return true;
598 }
599 
IsFourFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent)600 bool EventMonitorHandler::MonitorCollection::IsFourFingersSwipe(std::shared_ptr<PointerEvent> pointerEvent)
601 {
602     CHKPF(pointerEvent);
603     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD ||
604         pointerEvent->GetFingerCount() != FOUR_FINGERS ||
605         (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_BEGIN &&
606         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_UPDATE &&
607         pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_END)) {
608         return false;
609     }
610     return true;
611 }
612 
IsThreeFingersTap(std::shared_ptr<PointerEvent> pointerEvent)613 bool EventMonitorHandler::MonitorCollection::IsThreeFingersTap(std::shared_ptr<PointerEvent> pointerEvent)
614 {
615     CHKPR(pointerEvent, ERROR_NULL_POINTER);
616     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD ||
617         pointerEvent->GetFingerCount() != THREE_FINGERS ||
618         (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_TRIPTAP)) {
619         return false;
620     }
621     return true;
622 }
623 
624 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
IsFingerprint(std::shared_ptr<PointerEvent> pointerEvent)625 bool EventMonitorHandler::MonitorCollection::IsFingerprint(std::shared_ptr<PointerEvent> pointerEvent)
626 {
627     CHKPR(pointerEvent, ERROR_NULL_POINTER);
628     if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_FINGERPRINT &&
629         (PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN <= pointerEvent->GetPointerAction() &&
630         pointerEvent->GetPointerAction() <= PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK)) {
631             return true;
632     }
633     MMI_HILOGD("not fingerprint event");
634     return false;
635 }
636 #endif
CheckIfNeedSendToClient(SessionHandler monitor,std::shared_ptr<PointerEvent> pointerEvent)637 bool EventMonitorHandler::MonitorCollection::CheckIfNeedSendToClient(SessionHandler monitor,
638     std::shared_ptr<PointerEvent> pointerEvent)
639 {
640 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
641     if ((monitor.eventType_ & HANDLE_EVENT_TYPE_FINGERPRINT) ==
642         HANDLE_EVENT_TYPE_FINGERPRINT && IsFingerprint(pointerEvent)) {
643         return true;
644     }
645 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
646     if ((monitor.eventType_ & HANDLE_EVENT_TYPE_POINTER) == HANDLE_EVENT_TYPE_POINTER) {
647         return true;
648     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_SWIPEINWARD) == HANDLE_EVENT_TYPE_SWIPEINWARD) {
649         return true;
650     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_TOUCH) == HANDLE_EVENT_TYPE_TOUCH &&
651         pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
652         return true;
653     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_MOUSE) == HANDLE_EVENT_TYPE_MOUSE &&
654         pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
655         return true;
656     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_PINCH) == HANDLE_EVENT_TYPE_PINCH &&
657         IsPinch(pointerEvent)) {
658         return true;
659     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_THREEFINGERSSWIP) == HANDLE_EVENT_TYPE_THREEFINGERSSWIP &&
660         IsThreeFingersSwipe(pointerEvent)) {
661         return true;
662     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_FOURFINGERSSWIP) == HANDLE_EVENT_TYPE_FOURFINGERSSWIP &&
663         IsFourFingersSwipe(pointerEvent)) {
664         return true;
665     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_ROTATE) == HANDLE_EVENT_TYPE_ROTATE &&
666         IsRotate(pointerEvent)) {
667         return true;
668     } else if ((monitor.eventType_ & HANDLE_EVENT_TYPE_THREEFINGERSTAP) == HANDLE_EVENT_TYPE_THREEFINGERSTAP &&
669         IsThreeFingersTap(pointerEvent)) {
670         return true;
671     }
672     return false;
673 }
674 
OnSessionLost(SessionPtr session)675 void EventMonitorHandler::MonitorCollection::OnSessionLost(SessionPtr session)
676 {
677     CALL_INFO_TRACE;
678     std::set<SessionHandler>::const_iterator cItr = monitors_.cbegin();
679     while (cItr != monitors_.cend()) {
680         if (cItr->session_ != session) {
681             ++cItr;
682         } else {
683             cItr = monitors_.erase(cItr);
684         }
685     }
686     CHKPV(session);
687     int32_t pid = session->GetPid();
688     auto it = endScreenCaptureMonitors_.find(pid);
689     if (it != endScreenCaptureMonitors_.end()) {
690         endScreenCaptureMonitors_.erase(it);
691     }
692 }
693 
Dump(int32_t fd,const std::vector<std::string> & args)694 void EventMonitorHandler::Dump(int32_t fd, const std::vector<std::string> &args)
695 {
696     return monitors_.Dump(fd, args);
697 }
698 
Dump(int32_t fd,const std::vector<std::string> & args)699 void EventMonitorHandler::MonitorCollection::Dump(int32_t fd, const std::vector<std::string> &args)
700 {
701     CALL_DEBUG_ENTER;
702     mprintf(fd, "Monitor information:\t");
703     mprintf(fd, "monitors: count=%zu", monitors_.size());
704     for (const auto &item : monitors_) {
705         SessionPtr session = item.session_;
706         if (!session) {
707             continue;
708         }
709         mprintf(fd,
710                 "handlerType:%d | Pid:%d | Uid:%d | Fd:%d "
711                 "| EarliestEventTime:%" PRId64 " | Descript:%s "
712                 "| EventType:%u | ProgramName:%s \t",
713                 item.handlerType_, session->GetPid(),
714                 session->GetUid(), session->GetFd(),
715                 session->GetEarliestEventTime(), session->GetDescript().c_str(),
716                 item.eventType_, session->GetProgramName().c_str());
717     }
718 }
719 
720 #ifdef PLAYER_FRAMEWORK_EXISTS
RegisterScreenCaptureListener()721 void EventMonitorHandler::RegisterScreenCaptureListener()
722 {
723     screenCaptureMonitorListener_ = new (std::nothrow) InputScreenCaptureMonitorListener();
724     CHKPV(screenCaptureMonitorListener_);
725     Media::ScreenCaptureMonitor::GetInstance()->RegisterScreenCaptureMonitorListener(screenCaptureMonitorListener_);
726 }
727 
OnScreenCaptureStarted(SessionPtr session)728 void EventMonitorHandler::OnScreenCaptureStarted(SessionPtr session)
729 {
730     if (!monitors_.HasMonitor(session) && !monitors_.HasScreenCaptureMonitor(session)) {
731         MMI_HILOGI("This process has no screen capture monitor");
732         return;
733     }
734     monitors_.RecoveryScreenCaptureMonitor(session);
735 }
736 
OnScreenCaptureFinished(SessionPtr session)737 void EventMonitorHandler::OnScreenCaptureFinished(SessionPtr session)
738 {
739     if (!monitors_.HasMonitor(session)) {
740         MMI_HILOGI("This process has no screen capture monitor");
741         return;
742     }
743     monitors_.RemoveScreenCaptureMonitor(session);
744 }
745 #endif
746 } // namespace MMI
747 } // namespace OHOS
748