1 /*
2 * Copyright (c) 2025 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_pre_monitor_handler.h"
17
18 #include "input_event_data_transformation.h"
19 #include "input_event_handler.h"
20 #include "util_ex.h"
21
22 #undef MMI_LOG_DOMAIN
23 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "EventPreMonitorHandler"
26
27 namespace OHOS {
28 namespace MMI {
29 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)30 void EventPreMonitorHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)
31 {
32 CHKPV(keyEvent);
33 OnHandleEvent(keyEvent);
34 CHKPV(nextHandler_);
35 nextHandler_->HandleKeyEvent(keyEvent);
36 }
37 #endif // OHOS_BUILD_ENABLE_KEYBOARD
38
39 #ifdef OHOS_BUILD_ENABLE_POINTER
HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)40 void EventPreMonitorHandler::HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)
41 {
42 CHKPV(pointerEvent);
43 CHKPV(nextHandler_);
44 nextHandler_->HandlePointerEvent(pointerEvent);
45 }
46 #endif // OHOS_BUILD_ENABLE_POINTER
47
48 #ifdef OHOS_BUILD_ENABLE_TOUCH
HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)49 void EventPreMonitorHandler::HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)
50 {
51 CHKPV(pointerEvent);
52 CHKPV(nextHandler_);
53 nextHandler_->HandleTouchEvent(pointerEvent);
54 }
55 #endif // OHOS_BUILD_ENABLE_TOUCH
56
AddInputHandler(SessionPtr session,int32_t handlerId,HandleEventType eventType,std::vector<int32_t> keys)57 int32_t EventPreMonitorHandler::AddInputHandler(
58 SessionPtr session, int32_t handlerId, HandleEventType eventType, std::vector<int32_t> keys)
59 {
60 CALL_INFO_TRACE;
61 CHKPR(session, RET_ERR);
62 if ((eventType & HANDLE_EVENT_TYPE_ALL) == HANDLE_EVENT_TYPE_NONE) {
63 MMI_HILOGE("Invalid event type");
64 return RET_ERR;
65 }
66 InitSessionLostCallback();
67 auto mon = std::make_shared<SessionHandler>(session, handlerId, eventType, keys);
68 return monitors_.AddMonitor(mon, keys);
69 }
70
RemoveInputHandler(SessionPtr sess,int32_t handlerId)71 void EventPreMonitorHandler::RemoveInputHandler(SessionPtr sess, int32_t handlerId)
72 {
73 CALL_INFO_TRACE;
74 monitors_.RemoveMonitor(sess, handlerId);
75 }
76
77 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnHandleEvent(std::shared_ptr<KeyEvent> keyEvent)78 bool EventPreMonitorHandler::OnHandleEvent(std::shared_ptr<KeyEvent> keyEvent)
79 {
80 MMI_HILOGD("Handle KeyEvent");
81 CHKPF(keyEvent);
82 auto keyHandler = InputHandler->GetEventNormalizeHandler();
83 CHKPF(keyHandler);
84 if (keyEvent->GetKeyCode() != keyHandler->GetCurrentHandleKeyCode()) {
85 MMI_HILOGW("Keycode has been changed");
86 }
87 if (keyEvent->HasFlag(InputEvent::EVENT_FLAG_NO_MONITOR)) {
88 MMI_HILOGD("This event has been tagged as not to be monitored");
89 } else {
90 if (monitors_.HandleEvent(keyEvent)) {
91 MMI_HILOGD("Key event was consumed");
92 return true;
93 }
94 }
95 return false;
96 }
97 #endif // OHOS_BUILD_ENABLE_KEYBOARD
98
InitSessionLostCallback()99 void EventPreMonitorHandler::InitSessionLostCallback()
100 {
101 if (sessionLostCallbackInitialized_) {
102 return;
103 }
104 auto udsServerPtr = InputHandler->GetUDSServer();
105 CHKPV(udsServerPtr);
106 udsServerPtr->AddSessionDeletedCallback([this] (SessionPtr session) {
107 return this->OnSessionLost(session);
108 });
109 sessionLostCallbackInitialized_ = true;
110 MMI_HILOGD("The callback on session deleted is registered successfully");
111 }
112
OnSessionLost(SessionPtr session)113 void EventPreMonitorHandler::OnSessionLost(SessionPtr session)
114 {
115 monitors_.OnSessionLost(session);
116 }
117
SendToClient(std::shared_ptr<KeyEvent> keyEvent,NetPacket & pkt,int32_t handlerId) const118 void EventPreMonitorHandler::SessionHandler::SendToClient(
119 std::shared_ptr<KeyEvent> keyEvent, NetPacket &pkt, int32_t handlerId) const
120 {
121 CHKPV(keyEvent);
122 CHKPV(session_);
123 pkt.Clean();
124 if (InputEventDataTransformation::KeyEventToNetPacket(keyEvent, pkt) != RET_OK) {
125 MMI_HILOGE("Packet key event failed, errCode:%{public}d", STREAM_BUF_WRITE_FAIL);
126 return;
127 }
128 int32_t fd = session_->GetFd();
129 pkt << fd << handlerId;
130 if (!session_->SendMsg(pkt)) {
131 MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
132 }
133 }
134
AddMonitor(const std::shared_ptr<SessionHandler> monitor,std::vector<int32_t> keys)135 int32_t EventPreMonitorHandler::MonitorCollection::AddMonitor(
136 const std::shared_ptr<SessionHandler> monitor, std::vector<int32_t> keys)
137 {
138 if (sessionHandlers_.size() >= MAX_N_INPUT_MONITORS) {
139 MMI_HILOGE("The number of monitors exceeds the maximum:%{public}zu, monitors errCode:%{public}d",
140 sessionHandlers_.size(),
141 INVALID_MONITOR_MON);
142 return RET_ERR;
143 }
144 for (auto &iter : sessionHandlers_) {
145 if (IsEqualsKeys(keys, iter.first)) {
146 iter.second.push_back(monitor);
147 return RET_OK;
148 }
149 }
150 sessionHandlers_[keys] = std::list<std::shared_ptr<SessionHandler>>();
151 sessionHandlers_[keys].push_back(monitor);
152
153 return RET_OK;
154 }
155
IsEqualsKeys(std::vector<int32_t> newKeys,std::vector<int32_t> oldKeys)156 bool EventPreMonitorHandler::MonitorCollection::IsEqualsKeys(std::vector<int32_t> newKeys, std::vector<int32_t> oldKeys)
157 {
158 if (newKeys.size() != oldKeys.size()) {
159 MMI_HILOGE("The size of preKeys is not match");
160 return false;
161 }
162
163 for (const auto &newKey : newKeys) {
164 auto it = std::find(oldKeys.begin(), oldKeys.end(), newKey);
165 if (it == oldKeys.end()) {
166 MMI_HILOGE("Can't find the key");
167 return false;
168 }
169 }
170
171 return true;
172 }
173
RemoveMonitor(SessionPtr sess,int32_t handlerId)174 void EventPreMonitorHandler::MonitorCollection::RemoveMonitor(SessionPtr sess, int32_t handlerId)
175 {
176 for (auto iter = sessionHandlers_.begin(); iter != sessionHandlers_.end();) {
177 auto &sessionHandlers = iter->second;
178 for (auto it = sessionHandlers.begin(); it != sessionHandlers.end();) {
179 if ((*it)->handlerId_ == handlerId && (*it)->session_ == sess) {
180 it = sessionHandlers.erase(it);
181 } else {
182 ++it;
183 }
184 }
185 if (sessionHandlers.empty()) {
186 iter = sessionHandlers_.erase(iter);
187 } else {
188 ++iter;
189 }
190 }
191 }
192
193 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleEvent(std::shared_ptr<KeyEvent> keyEvent)194 bool EventPreMonitorHandler::MonitorCollection::HandleEvent(std::shared_ptr<KeyEvent> keyEvent)
195 {
196 CHKPF(keyEvent);
197 MMI_HILOGD("Handle KeyEvent");
198 NetPacket pkt(MmiMessageId::ON_PRE_KEY_EVENT);
199 if (pkt.ChkRWError()) {
200 MMI_HILOGE("Packet write key event failed");
201 return false;
202 }
203 for (auto iter = sessionHandlers_.begin(); iter != sessionHandlers_.end(); iter++) {
204 auto &sessionHandlers = iter->second;
205 for (auto it = sessionHandlers.begin(); it != sessionHandlers.end(); it++) {
206 auto keys = (*it)->keys_;
207 auto keyIter = std::find(keys.begin(), keys.end(), keyEvent->GetKeyCode());
208 if (keyIter != keys.end()) {
209 (*it)->SendToClient(keyEvent, pkt, (*it)->handlerId_);
210 }
211 }
212 }
213 return false;
214 }
215 #endif // OHOS_BUILD_ENABLE_KEYBOARD
216
217 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
HandleEvent(std::shared_ptr<PointerEvent> pointerEvent)218 bool EventPreMonitorHandler::MonitorCollection::HandleEvent(std::shared_ptr<PointerEvent> pointerEvent)
219 {
220 return false;
221 }
222 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
223
OnSessionLost(SessionPtr session)224 void EventPreMonitorHandler::MonitorCollection::OnSessionLost(SessionPtr session)
225 {
226 CALL_INFO_TRACE;
227 for (auto iter = sessionHandlers_.begin(); iter != sessionHandlers_.end();) {
228 auto &handlers = iter->second;
229 for (auto inner = handlers.begin(); inner != handlers.end();) {
230 auto handler = *inner;
231 if (handler->session_ == session) {
232 inner = handlers.erase(inner);
233 } else {
234 ++inner;
235 }
236 }
237 if (handlers.empty()) {
238 iter = sessionHandlers_.erase(iter);
239 } else {
240 ++iter;
241 }
242 }
243 }
244
Dump(int32_t fd,const std::vector<std::string> & args)245 void EventPreMonitorHandler::Dump(int32_t fd, const std::vector<std::string> &args)
246 {
247 return monitors_.Dump(fd, args);
248 }
249
Dump(int32_t fd,const std::vector<std::string> & args)250 void EventPreMonitorHandler::MonitorCollection::Dump(int32_t fd, const std::vector<std::string> &args)
251 {
252 CALL_DEBUG_ENTER;
253 mprintf(fd, "Monitor information:\t");
254 mprintf(fd, "monitors: count=%zu", sessionHandlers_.size());
255 for (const auto &item : sessionHandlers_) {
256 const std::list<std::shared_ptr<SessionHandler>> &handlers = item.second;
257 for (const auto &handler : handlers) {
258 SessionPtr session = handler->session_;
259 if (!session) {
260 continue;
261 }
262 mprintf(fd,
263 "EventType:%d | Pid:%d | Uid:%d | Fd:%d "
264 "| EarliestEventTime:%" PRId64 " | Descript:%s "
265 "| ProgramName:%s \t",
266 handler->eventType_, session->GetPid(),
267 session->GetUid(), session->GetFd(),
268 session->GetEarliestEventTime(), session->GetDescript().c_str(),
269 session->GetProgramName().c_str());
270 }
271 }
272 }
273 } // namespace MMI
274 } // namespace OHOS
275