1 /*
2 * Copyright (c) 2021-2022 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 "client_msg_handler.h"
17
18 #include <cinttypes>
19 #include <iostream>
20 #include <sstream>
21
22 #include "bytrace_adapter.h"
23 #include "event_log_helper.h"
24 #include "input_device.h"
25 #ifdef OHOS_BUILD_ENABLE_COOPERATE
26 #include "input_device_cooperate_impl.h"
27 #endif // OHOS_BUILD_ENABLE_COOPERATE
28 #include "input_device_impl.h"
29 #include "input_event_data_transformation.h"
30 #include "input_handler_manager.h"
31 #include "input_manager_impl.h"
32 #ifdef OHOS_BUILD_ENABLE_MONITOR
33 #include "input_monitor_manager.h"
34 #endif // OHOS_BUILD_ENABLE_MONITOR
35 #include "mmi_client.h"
36 #include "mmi_func_callback.h"
37 #include "multimodal_event_handler.h"
38 #include "multimodal_input_connect_manager.h"
39 #include "napi_constants.h"
40 #include "proto.h"
41 #include "time_cost_chk.h"
42 #include "util.h"
43
44 namespace OHOS {
45 namespace MMI {
46 namespace {
47 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, MMI_LOG_DOMAIN, "ClientMsgHandler"};
48 } // namespace
49
~ClientMsgHandler()50 ClientMsgHandler::~ClientMsgHandler()
51 {
52 dispatchCallback_ = nullptr;
53 }
54
Init()55 void ClientMsgHandler::Init()
56 {
57 MsgCallback funs[] = {
58 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
59 {MmiMessageId::ON_KEY_EVENT, MsgCallbackBind2(&ClientMsgHandler::OnKeyEvent, this)},
60 {MmiMessageId::ON_SUBSCRIBE_KEY, std::bind(&ClientMsgHandler::OnSubscribeKeyEventCallback,
61 this, std::placeholders::_1, std::placeholders::_2)},
62 #endif // OHOS_BUILD_ENABLE_KEYBOARD
63 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
64 {MmiMessageId::ON_POINTER_EVENT, MsgCallbackBind2(&ClientMsgHandler::OnPointerEvent, this)},
65 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
66 {MmiMessageId::INPUT_DEVICE, MsgCallbackBind2(&ClientMsgHandler::OnInputDevice, this)},
67 {MmiMessageId::INPUT_DEVICE_IDS, MsgCallbackBind2(&ClientMsgHandler::OnInputDeviceIds, this)},
68 {MmiMessageId::INPUT_DEVICE_SUPPORT_KEYS, MsgCallbackBind2(&ClientMsgHandler::OnSupportKeys, this)},
69 {MmiMessageId::INPUT_DEVICE_KEYBOARD_TYPE, MsgCallbackBind2(&ClientMsgHandler::OnInputKeyboardType, this)},
70 {MmiMessageId::ADD_INPUT_DEVICE_LISTENER, MsgCallbackBind2(&ClientMsgHandler::OnDevListener, this)},
71 {MmiMessageId::NOTICE_ANR, MsgCallbackBind2(&ClientMsgHandler::OnAnr, this)},
72 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || \
73 defined(OHOS_BUILD_ENABLE_MONITOR))
74 {MmiMessageId::REPORT_KEY_EVENT, MsgCallbackBind2(&ClientMsgHandler::ReportKeyEvent, this)},
75 #endif // OHOS_BUILD_ENABLE_KEYBOARD
76 #if (defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)) && \
77 (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR))
78 {MmiMessageId::REPORT_POINTER_EVENT, MsgCallbackBind2(&ClientMsgHandler::ReportPointerEvent, this)},
79 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
80 #ifdef OHOS_BUILD_ENABLE_COOPERATE
81 {MmiMessageId::COOPERATION_ADD_LISTENER, MsgCallbackBind2(&ClientMsgHandler::OnCooperationListiner, this)},
82 {MmiMessageId::COOPERATION_MESSAGE, MsgCallbackBind2(&ClientMsgHandler::OnCooperationMessage, this)},
83 {MmiMessageId::COOPERATION_GET_STATE, MsgCallbackBind2(&ClientMsgHandler::OnCooperationState, this)},
84 #endif // OHOS_BUILD_ENABLE_COOPERATE
85 };
86 for (auto &it : funs) {
87 if (!RegistrationEvent(it)) {
88 MMI_HILOGW("Failed to register event errCode:%{public}d", EVENT_REG_FAIL);
89 continue;
90 }
91 }
92 }
93
InitProcessedCallback()94 void ClientMsgHandler::InitProcessedCallback()
95 {
96 CALL_DEBUG_ENTER;
97 int32_t tokenType = MultimodalInputConnMgr->GetTokenType();
98 if (tokenType == TokenType::TOKEN_HAP) {
99 MMI_HILOGD("Current session is hap");
100 dispatchCallback_ = std::bind(&ClientMsgHandler::OnDispatchEventProcessed, std::placeholders::_1);
101 } else if (tokenType == static_cast<int32_t>(TokenType::TOKEN_NATIVE)) {
102 MMI_HILOGD("Current session is native");
103 } else {
104 MMI_HILOGE("Current session is unknown tokenType:%{public}d", tokenType);
105 }
106 }
107
OnMsgHandler(const UDSClient & client,NetPacket & pkt)108 void ClientMsgHandler::OnMsgHandler(const UDSClient& client, NetPacket& pkt)
109 {
110 auto id = pkt.GetMsgId();
111 TimeCostChk chk("ClientMsgHandler::OnMsgHandler", "overtime 300(us)", MAX_OVER_TIME, id);
112 auto callback = GetMsgCallback(id);
113 if (callback == nullptr) {
114 MMI_HILOGE("Unknown msg id:%{public}d", id);
115 return;
116 }
117 auto ret = (*callback)(client, pkt);
118 if (ret < 0) {
119 MMI_HILOGE("Msg handling failed. id:%{public}d,ret:%{public}d", id, ret);
120 return;
121 }
122 }
123
124 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnKeyEvent(const UDSClient & client,NetPacket & pkt)125 int32_t ClientMsgHandler::OnKeyEvent(const UDSClient& client, NetPacket& pkt)
126 {
127 auto key = KeyEvent::Create();
128 CHKPR(key, ERROR_NULL_POINTER);
129 int32_t ret = InputEventDataTransformation::NetPacketToKeyEvent(pkt, key);
130 if (ret != RET_OK) {
131 MMI_HILOGE("Read netPacket failed");
132 return RET_ERR;
133 }
134 int32_t fd = 0;
135 pkt >> fd;
136 if (pkt.ChkRWError()) {
137 MMI_HILOGE("Packet read fd failed");
138 return PACKET_READ_FAIL;
139 }
140 MMI_HILOGI("Key event dispatcher of client, Fd:%{public}d", fd);
141 EventLogHelper::PrintEventData(key);
142 BytraceAdapter::StartBytrace(key, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_DISPATCH_EVENT);
143 key->SetProcessedCallback(dispatchCallback_);
144 InputMgrImpl.OnKeyEvent(key);
145 key->MarkProcessed();
146 return RET_OK;
147 }
148 #endif // OHOS_BUILD_ENABLE_KEYBOARD
149
150 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
OnPointerEvent(const UDSClient & client,NetPacket & pkt)151 int32_t ClientMsgHandler::OnPointerEvent(const UDSClient& client, NetPacket& pkt)
152 {
153 CALL_DEBUG_ENTER;
154 auto pointerEvent = PointerEvent::Create();
155 CHKPR(pointerEvent, ERROR_NULL_POINTER);
156 if (InputEventDataTransformation::Unmarshalling(pkt, pointerEvent) != ERR_OK) {
157 MMI_HILOGE("Failed to deserialize pointer event.");
158 return RET_ERR;
159 }
160 MMI_HILOGD("Pointer event dispatcher of client:");
161 EventLogHelper::PrintEventData(pointerEvent);
162 if (PointerEvent::POINTER_ACTION_CANCEL == pointerEvent->GetPointerAction()) {
163 MMI_HILOGI("Operation canceled.");
164 }
165 pointerEvent->SetProcessedCallback(dispatchCallback_);
166 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START, BytraceAdapter::POINT_DISPATCH_EVENT);
167 InputMgrImpl.OnPointerEvent(pointerEvent);
168 return RET_OK;
169 }
170 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
171
172 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnSubscribeKeyEventCallback(const UDSClient & client,NetPacket & pkt)173 int32_t ClientMsgHandler::OnSubscribeKeyEventCallback(const UDSClient &client, NetPacket &pkt)
174 {
175 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
176 CHKPR(keyEvent, ERROR_NULL_POINTER);
177 int32_t ret = InputEventDataTransformation::NetPacketToKeyEvent(pkt, keyEvent);
178 if (ret != RET_OK) {
179 MMI_HILOGE("Read net packet failed");
180 return RET_ERR;
181 }
182 int32_t fd = -1;
183 int32_t subscribeId = -1;
184 pkt >> fd >> subscribeId;
185 if (pkt.ChkRWError()) {
186 MMI_HILOGE("Packet read fd failed");
187 return PACKET_READ_FAIL;
188 }
189 if (keyEvent->GetKeyCode() == KeyEvent::KEYCODE_POWER) {
190 MMI_HILOGI("Subscribe:%{public}d,Fd:%{public}d,KeyEvent:%{public}d,"
191 "KeyCode:%{public}d,ActionTime:%{public}" PRId64 ",ActionStartTime:%{public}" PRId64 ","
192 "Action:%{public}d,KeyAction:%{public}d,EventType:%{public}d,Flag:%{public}u",
193 subscribeId, fd, keyEvent->GetId(), keyEvent->GetKeyCode(), keyEvent->GetActionTime(),
194 keyEvent->GetActionStartTime(), keyEvent->GetAction(), keyEvent->GetKeyAction(),
195 keyEvent->GetEventType(), keyEvent->GetFlag());
196 } else {
197 MMI_HILOGD("Subscribe:%{public}d,Fd:%{public}d,KeyEvent:%{public}d,"
198 "KeyCode:%{public}d,ActionTime:%{public}" PRId64 ",ActionStartTime:%{public}" PRId64 ","
199 "Action:%{public}d,KeyAction:%{public}d,EventType:%{public}d,Flag:%{public}u",
200 subscribeId, fd, keyEvent->GetId(), keyEvent->GetKeyCode(), keyEvent->GetActionTime(),
201 keyEvent->GetActionStartTime(), keyEvent->GetAction(), keyEvent->GetKeyAction(),
202 keyEvent->GetEventType(), keyEvent->GetFlag());
203 }
204
205 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_SUBSCRIBE_EVENT);
206 return KeyEventInputSubscribeMgr.OnSubscribeKeyEventCallback(keyEvent, subscribeId);
207 }
208 #endif // OHOS_BUILD_ENABLE_KEYBOARD
209
OnInputDeviceIds(const UDSClient & client,NetPacket & pkt)210 int32_t ClientMsgHandler::OnInputDeviceIds(const UDSClient& client, NetPacket& pkt)
211 {
212 CALL_DEBUG_ENTER;
213 int32_t userData;
214 std::vector<int32_t> inputDeviceIds;
215 pkt >> userData >> inputDeviceIds;
216 if (inputDeviceIds.size() > MAX_INPUT_DEVICE) {
217 MMI_HILOGE("Device exceeds the max range");
218 return RET_ERR;
219 }
220 if (pkt.ChkRWError()) {
221 MMI_HILOGE("Packet read cooperate msg failed");
222 return RET_ERR;
223 }
224 InputDevImpl.OnInputDeviceIds(userData, inputDeviceIds);
225 return RET_OK;
226 }
227
OnInputDevice(const UDSClient & client,NetPacket & pkt)228 int32_t ClientMsgHandler::OnInputDevice(const UDSClient& client, NetPacket& pkt)
229 {
230 CALL_DEBUG_ENTER;
231 int32_t userData;
232 pkt >> userData;
233 std::shared_ptr<InputDevice> devData = InputDevImpl.DevDataUnmarshalling(pkt);
234 CHKPR(devData, RET_ERR);
235 if (pkt.ChkRWError()) {
236 MMI_HILOGE("Packet read cooperate msg failed");
237 return RET_ERR;
238 }
239 InputDevImpl.OnInputDevice(userData, devData);
240 return RET_OK;
241 }
242
OnSupportKeys(const UDSClient & client,NetPacket & pkt)243 int32_t ClientMsgHandler::OnSupportKeys(const UDSClient& client, NetPacket& pkt)
244 {
245 CALL_DEBUG_ENTER;
246 int32_t userData;
247 size_t size;
248 pkt >> userData >> size;
249 if (size > MAX_SUPPORT_KEY) {
250 MMI_HILOGE("Keys exceeds the max range");
251 return RET_ERR;
252 }
253 std::vector<bool> abilityRet;
254 bool ret;
255 for (size_t i = 0; i < size; ++i) {
256 pkt >> ret;
257 abilityRet.push_back(ret);
258 }
259 if (pkt.ChkRWError()) {
260 MMI_HILOGE("Packet read key Data failed");
261 return RET_ERR;
262 }
263 InputDevImpl.OnSupportKeys(userData, abilityRet);
264 return RET_OK;
265 }
266
OnInputKeyboardType(const UDSClient & client,NetPacket & pkt)267 int32_t ClientMsgHandler::OnInputKeyboardType(const UDSClient& client, NetPacket& pkt)
268 {
269 CALL_DEBUG_ENTER;
270 int32_t userData;
271 int32_t KeyboardType;
272 pkt >> userData >> KeyboardType;
273 if (pkt.ChkRWError()) {
274 MMI_HILOGE("Packet read failed");
275 return PACKET_WRITE_FAIL;
276 }
277 InputDevImpl.OnKeyboardType(userData, KeyboardType);
278 return RET_OK;
279 }
280
OnDevListener(const UDSClient & client,NetPacket & pkt)281 int32_t ClientMsgHandler::OnDevListener(const UDSClient& client, NetPacket& pkt)
282 {
283 CALL_DEBUG_ENTER;
284 std::string type;
285 int32_t deviceId;
286 pkt >> type >> deviceId;
287 if (pkt.ChkRWError()) {
288 MMI_HILOGE("Packet read type failed");
289 return RET_ERR;
290 }
291 InputDevImpl.OnDevListener(deviceId, type);
292 return RET_OK;
293 }
294
295 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || \
296 defined(OHOS_BUILD_ENABLE_MONITOR))
ReportKeyEvent(const UDSClient & client,NetPacket & pkt)297 int32_t ClientMsgHandler::ReportKeyEvent(const UDSClient& client, NetPacket& pkt)
298 {
299 CALL_DEBUG_ENTER;
300 InputHandlerType handlerType;
301 pkt >> handlerType;
302 if (pkt.ChkRWError()) {
303 MMI_HILOGE("Packet read handler failed");
304 return RET_ERR;
305 }
306 auto keyEvent = KeyEvent::Create();
307 CHKPR(keyEvent, ERROR_NULL_POINTER);
308 if (InputEventDataTransformation::NetPacketToKeyEvent(pkt, keyEvent) != ERR_OK) {
309 MMI_HILOGE("Failed to deserialize key event.");
310 return RET_ERR;
311 }
312 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_INTERCEPT_EVENT);
313 switch (handlerType) {
314 case INTERCEPTOR: {
315 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
316 InputInterMgr->OnInputEvent(keyEvent);
317 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
318 break;
319 }
320 case MONITOR: {
321 #ifdef OHOS_BUILD_ENABLE_MONITOR
322 IMonitorMgr->OnInputEvent(keyEvent);
323 #endif // OHOS_BUILD_ENABLE_MONITOR
324 break;
325 }
326 default: {
327 MMI_HILOGW("Failed to intercept or monitor on the event");
328 break;
329 }
330 }
331 return RET_OK;
332 }
333 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
334
335 #if (defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)) && \
336 (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR))
ReportPointerEvent(const UDSClient & client,NetPacket & pkt)337 int32_t ClientMsgHandler::ReportPointerEvent(const UDSClient& client, NetPacket& pkt)
338 {
339 CALL_DEBUG_ENTER;
340 InputHandlerType handlerType;
341 pkt >> handlerType;
342 if (pkt.ChkRWError()) {
343 MMI_HILOGE("Packet read Pointer data failed");
344 return RET_ERR;
345 }
346 MMI_HILOGD("Client handlerType:%{public}d", handlerType);
347 auto pointerEvent = PointerEvent::Create();
348 CHKPR(pointerEvent, ERROR_NULL_POINTER);
349 if (InputEventDataTransformation::Unmarshalling(pkt, pointerEvent) != ERR_OK) {
350 MMI_HILOGE("Failed to deserialize pointer event");
351 return RET_ERR;
352 }
353 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START, BytraceAdapter::POINT_INTERCEPT_EVENT);
354 switch (handlerType) {
355 case INTERCEPTOR: {
356 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
357 InputInterMgr->OnInputEvent(pointerEvent);
358 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
359 break;
360 }
361 case MONITOR: {
362 #ifdef OHOS_BUILD_ENABLE_MONITOR
363 IMonitorMgr->OnInputEvent(pointerEvent);
364 #endif // OHOS_BUILD_ENABLE_MONITOR
365 break;
366 }
367 default: {
368 MMI_HILOGW("Failed to intercept or monitor on the event");
369 break;
370 }
371 }
372 return RET_OK;
373 }
374 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
375
OnDispatchEventProcessed(int32_t eventId)376 void ClientMsgHandler::OnDispatchEventProcessed(int32_t eventId)
377 {
378 CALL_DEBUG_ENTER;
379 MMIClientPtr client = MMIEventHdl.GetMMIClient();
380 CHKPV(client);
381 NetPacket pkt(MmiMessageId::MARK_PROCESS);
382 pkt << eventId << ANR_DISPATCH;
383 if (pkt.ChkRWError()) {
384 MMI_HILOGE("Packet write event failed");
385 return;
386 }
387 if (!client->SendMessage(pkt)) {
388 MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
389 return;
390 }
391 }
392
OnAnr(const UDSClient & client,NetPacket & pkt)393 int32_t ClientMsgHandler::OnAnr(const UDSClient& client, NetPacket& pkt)
394 {
395 CALL_DEBUG_ENTER;
396 int32_t pid;
397 pkt >> pid;
398 if (pkt.ChkRWError()) {
399 MMI_HILOGE("Packet read data failed");
400 return RET_ERR;
401 }
402 MMI_HILOGI("Client pid:%{public}d", pid);
403 InputMgrImpl.OnAnr(pid);
404 return RET_OK;
405 }
406
407 #ifdef OHOS_BUILD_ENABLE_COOPERATE
OnCooperationListiner(const UDSClient & client,NetPacket & pkt)408 int32_t ClientMsgHandler::OnCooperationListiner(const UDSClient& client, NetPacket& pkt)
409 {
410 CALL_DEBUG_ENTER;
411 int32_t userData;
412 std::string deviceId;
413 int32_t nType;
414 pkt >> userData >> deviceId >> nType;
415 if (pkt.ChkRWError()) {
416 MMI_HILOGE("Packet read type failed");
417 return RET_ERR;
418 }
419 InputDevCooperateImpl.OnDevCooperateListener(deviceId, CooperationMessage(nType));
420 return RET_OK;
421 }
422
OnCooperationMessage(const UDSClient & client,NetPacket & pkt)423 int32_t ClientMsgHandler::OnCooperationMessage(const UDSClient& client, NetPacket& pkt)
424 {
425 CALL_DEBUG_ENTER;
426 int32_t userData;
427 std::string deviceId;
428 int32_t nType;
429 pkt >> userData >> deviceId >> nType;
430 if (pkt.ChkRWError()) {
431 MMI_HILOGE("Packet read cooperate msg failed");
432 return RET_ERR;
433 }
434 InputDevCooperateImpl.OnCooprationMessage(userData, deviceId, CooperationMessage(nType));
435 return RET_OK;
436 }
437
OnCooperationState(const UDSClient & client,NetPacket & pkt)438 int32_t ClientMsgHandler::OnCooperationState(const UDSClient& client, NetPacket& pkt)
439 {
440 CALL_DEBUG_ENTER;
441 int32_t userData;
442 bool state;
443 pkt >> userData >> state;
444 if (pkt.ChkRWError()) {
445 MMI_HILOGE("Packet read cooperate msg failed");
446 return RET_ERR;
447 }
448 InputDevCooperateImpl.OnCooperationState(userData, state);
449 return RET_OK;
450 }
451 #endif // OHOS_BUILD_ENABLE_COOPERATE
452 } // namespace MMI
453 } // namespace OHOS
454