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 "client_msg_handler.h"
17
18 #include <cinttypes>
19 #include <iostream>
20 #include <sstream>
21
22 #include "anr_handler.h"
23 #include "bytrace_adapter.h"
24 #include "event_log_helper.h"
25 #include "input_device.h"
26 #include "input_device_impl.h"
27 #include "input_event_data_transformation.h"
28 #include "input_handler_manager.h"
29 #include "input_manager_impl.h"
30 #ifdef OHOS_BUILD_ENABLE_MONITOR
31 #include "input_monitor_manager.h"
32 #endif // OHOS_BUILD_ENABLE_MONITOR
33 #include "mmi_client.h"
34 #include "multimodal_event_handler.h"
35 #include "multimodal_input_connect_manager.h"
36 #include "napi_constants.h"
37 #include "proto.h"
38 #include "time_cost_chk.h"
39 #include "util.h"
40 #include "pre_monitor_manager.h"
41
42 #undef MMI_LOG_TAG
43 #define MMI_LOG_TAG "ClientMsgHandler"
44
45 namespace OHOS {
46 namespace MMI {
47 namespace {
48 constexpr int32_t PRINT_INTERVAL_COUNT { 50 };
49 } // namespace
Init()50 void ClientMsgHandler::Init()
51 {
52 MsgCallback funs[] = {
53 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
54 { MmiMessageId::ON_KEY_EVENT, [this] (const UDSClient& client, NetPacket& pkt) {
55 return this->OnKeyEvent(client, pkt); }},
56 { MmiMessageId::ON_SUBSCRIBE_KEY, [this] (const UDSClient &client, NetPacket &pkt) {
57 return this->OnSubscribeKeyEventCallback(client, pkt); }},
58 { MmiMessageId::ON_PRE_KEY_EVENT, [this] (const UDSClient &client, NetPacket &pkt) {
59 return this->OnPreKeyEvent(client, pkt); }},
60 #endif // OHOS_BUILD_ENABLE_KEYBOARD
61 #ifdef OHOS_BUILD_ENABLE_SWITCH
62 { MmiMessageId::ON_SUBSCRIBE_SWITCH, [this] (const UDSClient &client, NetPacket &pkt) {
63 return this->OnSubscribeSwitchEventCallback(client, pkt); }},
64 #endif // OHOS_BUILD_ENABLE_SWITCH
65 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
66 { MmiMessageId::ON_POINTER_EVENT, [this] (const UDSClient& client, NetPacket& pkt) {
67 return this->OnPointerEvent(client, pkt); }},
68 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
69 { MmiMessageId::ADD_INPUT_DEVICE_LISTENER, [this] (const UDSClient& client, NetPacket& pkt) {
70 return this->OnDevListener(client, pkt); }},
71 { MmiMessageId::NOTICE_ANR, [this] (const UDSClient& client, NetPacket& pkt) {
72 return this->OnAnr(client, pkt); }},
73 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || \
74 defined(OHOS_BUILD_ENABLE_MONITOR))
75 { MmiMessageId::REPORT_KEY_EVENT, [this] (const UDSClient& client, NetPacket& pkt) {
76 return this->ReportKeyEvent(client, pkt); }},
77 #endif // OHOS_BUILD_ENABLE_KEYBOARD
78 #if (defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)) && \
79 (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR))
80 { MmiMessageId::REPORT_POINTER_EVENT, [this] (const UDSClient& client, NetPacket& pkt) {
81 return this->ReportPointerEvent(client, pkt); }},
82 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
83 { MmiMessageId::NOTIFY_BUNDLE_NAME, [this] (const UDSClient& client, NetPacket& pkt) {
84 return this->NotifyBundleName(client, pkt); }},
85 { MmiMessageId::WINDOW_STATE_ERROR_NOTIFY, [this] (const UDSClient& client, NetPacket& pkt) {
86 return this->NotifyWindowStateError(client, pkt); }},
87 };
88 for (auto &it : funs) {
89 if (!RegistrationEvent(it)) {
90 MMI_HILOGW("Failed to register event errCode:%{public}d", EVENT_REG_FAIL);
91 continue;
92 }
93 }
94 }
95
InitProcessedCallback()96 void ClientMsgHandler::InitProcessedCallback()
97 {
98 CALL_DEBUG_ENTER;
99 int32_t tokenType = MULTIMODAL_INPUT_CONNECT_MGR->GetTokenType();
100 if (tokenType == TokenType::TOKEN_HAP || tokenType == TokenType::TOKEN_SYSTEM_HAP) {
101 MMI_HILOGD("Current session is hap");
102 dispatchCallback_ = [] (int32_t eventId, int64_t actionTime) {
103 return ClientMsgHandler::OnDispatchEventProcessed(eventId, actionTime);
104 };
105 } else if (tokenType == static_cast<int32_t>(TokenType::TOKEN_NATIVE)) {
106 MMI_HILOGD("Current session is native");
107 } else {
108 MMI_HILOGE("Current session is unknown tokenType:%{public}d", tokenType);
109 }
110 }
111
OnMsgHandler(const UDSClient & client,NetPacket & pkt)112 void ClientMsgHandler::OnMsgHandler(const UDSClient& client, NetPacket& pkt)
113 {
114 auto id = pkt.GetMsgId();
115 TimeCostChk chk("ClientMsgHandler::OnMsgHandler", "overtime 300(us)", MAX_OVER_TIME, id);
116 auto callback = GetMsgCallback(id);
117 CHKPV(callback);
118 ResetLogTrace();
119 auto ret = (*callback)(client, pkt);
120 if (ret < 0) {
121 MMI_HILOGE("Msg handling failed. id:%{public}d, ret:%{public}d", id, ret);
122 return;
123 }
124 }
125
126 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnKeyEvent(const UDSClient & client,NetPacket & pkt)127 int32_t ClientMsgHandler::OnKeyEvent(const UDSClient& client, NetPacket& pkt)
128 {
129 auto key = KeyEvent::Create();
130 CHKPR(key, ERROR_NULL_POINTER);
131 int32_t ret = InputEventDataTransformation::NetPacketToKeyEvent(pkt, key);
132 if (ret != RET_OK) {
133 MMI_HILOG_DISPATCHE("Read netPacket failed");
134 return RET_ERR;
135 }
136 LogTracer lt(key->GetId(), key->GetEventType(), key->GetKeyAction());
137 int32_t fd = 0;
138 pkt >> fd;
139 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
140 if (InputEventDataTransformation::UnmarshallingEnhanceData(pkt, key) != ERR_OK) {
141 MMI_HILOG_DISPATCHE("Failed to deserialize enhance data key event");
142 return RET_ERR;
143 }
144 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
145 if (pkt.ChkRWError()) {
146 MMI_HILOG_DISPATCHE("Packet read fd failed");
147 return PACKET_READ_FAIL;
148 }
149 MMI_HILOG_DISPATCHD("Key event dispatcher of client, Fd:%{public}d", fd);
150 MMI_HILOG_DISPATCHI("Received.");
151 BytraceAdapter::StartBytrace(key, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_DISPATCH_EVENT);
152 key->SetProcessedCallback(dispatchCallback_);
153 InputMgrImpl.OnKeyEvent(key);
154 key->MarkProcessed();
155 return RET_OK;
156 }
157
OnPreKeyEvent(const UDSClient & client,NetPacket & pkt)158 int32_t ClientMsgHandler::OnPreKeyEvent(const UDSClient& client, NetPacket& pkt)
159 {
160 auto keyEvent = KeyEvent::Create();
161 CHKPR(keyEvent, ERROR_NULL_POINTER);
162 int32_t ret = InputEventDataTransformation::NetPacketToKeyEvent(pkt, keyEvent);
163 if (ret != RET_OK) {
164 MMI_HILOG_DISPATCHE("Read netPacket failed");
165 return RET_ERR;
166 }
167 int32_t fd = -1;
168 int32_t handlerId = -1;
169 pkt >> fd >> handlerId;
170 if (pkt.ChkRWError()) {
171 MMI_HILOG_ANRDETECTE("Packet read fd failed");
172 return PACKET_READ_FAIL;
173 }
174 MMI_HILOG_DISPATCHD("PRE key event dispathcer of clent, Fd:%{public}d", fd);
175 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_DISPATCH_EVENT);
176 PRE_MONITOR_MGR.OnPreKeyEvent(keyEvent, handlerId);
177 return RET_OK;
178 }
179 #endif // OHOS_BUILD_ENABLE_KEYBOARD
180
NotifyBundleName(const UDSClient & client,NetPacket & pkt)181 int32_t ClientMsgHandler::NotifyBundleName(const UDSClient& client, NetPacket& pkt)
182 {
183 CALL_DEBUG_ENTER;
184 int32_t pid = 0;
185 int32_t uid = 0;
186 int32_t syncStatus = 0;
187 std::string bundleName;
188 pkt >> pid >> uid >> bundleName >> syncStatus;
189 InputMgrImpl.NotifyBundleName(pid, uid, bundleName, syncStatus);
190 MMI_HILOGD("NotifyBundleName pid:%{public}d, uid:%{public}d, bundleName:%{public}s, syncStatus:%{public}d",
191 pid, uid, bundleName.c_str(), syncStatus);
192 return RET_OK;
193 }
194
195 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
OnPointerEvent(const UDSClient & client,NetPacket & pkt)196 int32_t ClientMsgHandler::OnPointerEvent(const UDSClient& client, NetPacket& pkt)
197 {
198 CALL_DEBUG_ENTER;
199 auto pointerEvent = PointerEvent::Create();
200 CHKPR(pointerEvent, ERROR_NULL_POINTER);
201 if (InputEventDataTransformation::Unmarshalling(pkt, pointerEvent) != ERR_OK) {
202 MMI_HILOG_DISPATCHE("Failed to deserialize pointer event");
203 return RET_ERR;
204 }
205 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
206 if (InputEventDataTransformation::UnmarshallingEnhanceData(pkt, pointerEvent) != ERR_OK) {
207 MMI_HILOG_DISPATCHE("Failed to deserialize enhance data pointer event");
208 return RET_ERR;
209 }
210 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
211 LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
212 if (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_AXIS_UPDATE &&
213 pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_ROTATE_UPDATE) {
214 std::string logInfo = std::string("ac: ") + pointerEvent->DumpPointerAction();
215 aggregator_.Record({MMI_LOG_DISPATCH, INPUT_KEY_FLOW, __FUNCTION__, __LINE__}, logInfo.c_str(),
216 std::to_string(pointerEvent->GetId()));
217 }
218 if (PointerEvent::POINTER_ACTION_CANCEL == pointerEvent->GetPointerAction() ||
219 PointerEvent::POINTER_ACTION_HOVER_CANCEL == pointerEvent->GetPointerAction() ||
220 PointerEvent::POINTER_ACTION_FINGERPRINT_CANCEL == pointerEvent->GetPointerAction()) {
221 MMI_HILOG_DISPATCHI("Operation canceled");
222 }
223 pointerEvent->SetProcessedCallback(dispatchCallback_);
224 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START, BytraceAdapter::POINT_DISPATCH_EVENT);
225 processedCount_++;
226 if (processedCount_ == PRINT_INTERVAL_COUNT) {
227 MMI_HILOG_FREEZEI("Last eventId:%{public}d, current eventId:%{public}d", lastEventId_, pointerEvent->GetId());
228 processedCount_ = 0;
229 lastEventId_ = pointerEvent->GetId();
230 }
231 InputMgrImpl.OnPointerEvent(pointerEvent);
232 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_JOYSTICK) {
233 pointerEvent->MarkProcessed();
234 }
235 return RET_OK;
236 }
237 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
238
239 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnSubscribeKeyEventCallback(const UDSClient & client,NetPacket & pkt)240 int32_t ClientMsgHandler::OnSubscribeKeyEventCallback(const UDSClient &client, NetPacket &pkt)
241 {
242 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
243 CHKPR(keyEvent, ERROR_NULL_POINTER);
244 int32_t ret = InputEventDataTransformation::NetPacketToKeyEvent(pkt, keyEvent);
245 if (ret != RET_OK) {
246 MMI_HILOGE("Read net packet failed");
247 return RET_ERR;
248 }
249 LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
250 int32_t fd = -1;
251 int32_t subscribeId = -1;
252 pkt >> fd >> subscribeId;
253 if (pkt.ChkRWError()) {
254 MMI_HILOGE("Packet read fd failed");
255 return PACKET_READ_FAIL;
256 }
257 if (keyEvent->GetKeyCode() == KeyEvent::KEYCODE_POWER) {
258 if (!EventLogHelper::IsBetaVersion()) {
259 MMI_HILOGI("Subscribe:%{public}d,Fd:%{public}d,KeyEvent:%{public}d, "
260 "Action:%{public}d, KeyAction:%{public}d, EventType:%{public}d,Flag:%{public}u",
261 subscribeId, fd, keyEvent->GetId(), keyEvent->GetAction(), keyEvent->GetKeyAction(),
262 keyEvent->GetEventType(), keyEvent->GetFlag());
263 } else {
264 MMI_HILOGI("Subscribe:%{public}d,Fd:%{public}d,KeyEvent:%{public}d, "
265 "Action:%{public}d, KeyAction:%{public}d, EventType:%{public}d,Flag:%{public}u",
266 subscribeId, fd, keyEvent->GetId(), keyEvent->GetAction(), keyEvent->GetKeyAction(),
267 keyEvent->GetEventType(), keyEvent->GetFlag());
268 }
269 } else {
270 MMI_HILOGD("Subscribe:%{public}d,Fd:%{public}d,KeyEvent:%{public}d,"
271 "KeyCode:%{private}d,ActionTime:%{public}" PRId64 ",ActionStartTime:%{public}" PRId64 ","
272 "Action:%{public}d,KeyAction:%{public}d,EventType:%{public}d,Flag:%{public}u",
273 subscribeId, fd, keyEvent->GetId(), keyEvent->GetKeyCode(), keyEvent->GetActionTime(),
274 keyEvent->GetActionStartTime(), keyEvent->GetAction(), keyEvent->GetKeyAction(),
275 keyEvent->GetEventType(), keyEvent->GetFlag());
276 }
277
278 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_SUBSCRIBE_EVENT);
279 return KeyEventInputSubscribeMgr.OnSubscribeKeyEventCallback(keyEvent, subscribeId);
280 }
281 #endif // OHOS_BUILD_ENABLE_KEYBOARD
282
283 #ifdef OHOS_BUILD_ENABLE_SWITCH
OnSubscribeSwitchEventCallback(const UDSClient & client,NetPacket & pkt)284 int32_t ClientMsgHandler::OnSubscribeSwitchEventCallback(const UDSClient &client, NetPacket &pkt)
285 {
286 std::shared_ptr<SwitchEvent> switchEvent = std::make_shared<SwitchEvent>(0);
287 int32_t ret = InputEventDataTransformation::NetPacketToSwitchEvent(pkt, switchEvent);
288 if (ret != RET_OK) {
289 MMI_HILOGE("Read net packet failed");
290 return RET_ERR;
291 }
292 LogTracer lt(switchEvent->GetId(), switchEvent->GetEventType(), switchEvent->GetAction());
293 int32_t fd = -1;
294 int32_t subscribeId = -1;
295 pkt >> fd >> subscribeId;
296 if (pkt.ChkRWError()) {
297 MMI_HILOGE("Packet read fd failed");
298 return PACKET_READ_FAIL;
299 }
300 return SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback(switchEvent, subscribeId);
301 }
302 #endif
303
OnDevListener(const UDSClient & client,NetPacket & pkt)304 int32_t ClientMsgHandler::OnDevListener(const UDSClient& client, NetPacket& pkt)
305 {
306 CALL_DEBUG_ENTER;
307 std::string type;
308 int32_t deviceId = 0;
309 pkt >> type >> deviceId;
310 if (pkt.ChkRWError()) {
311 MMI_HILOGE("Packet read type failed");
312 return RET_ERR;
313 }
314 INPUT_DEVICE_IMPL.OnDevListener(deviceId, type);
315 return RET_OK;
316 }
317
318 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || \
319 defined(OHOS_BUILD_ENABLE_MONITOR))
ReportKeyEvent(const UDSClient & client,NetPacket & pkt)320 int32_t ClientMsgHandler::ReportKeyEvent(const UDSClient& client, NetPacket& pkt)
321 {
322 CALL_DEBUG_ENTER;
323 InputHandlerType handlerType;
324 uint32_t deviceTags = 0;
325 pkt >> handlerType >> deviceTags;
326 if (pkt.ChkRWError()) {
327 MMI_HILOG_DISPATCHE("Packet read handler failed");
328 return RET_ERR;
329 }
330 auto keyEvent = KeyEvent::Create();
331 CHKPR(keyEvent, ERROR_NULL_POINTER);
332 if (InputEventDataTransformation::NetPacketToKeyEvent(pkt, keyEvent) != ERR_OK) {
333 MMI_HILOG_DISPATCHE("Failed to deserialize key event");
334 return RET_ERR;
335 }
336 LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
337 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::TRACE_START, BytraceAdapter::KEY_INTERCEPT_EVENT);
338 switch (handlerType) {
339 case INTERCEPTOR: {
340 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
341 InputInterMgr->OnInputEvent(keyEvent, deviceTags);
342 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
343 break;
344 }
345 case MONITOR: {
346 #ifdef OHOS_BUILD_ENABLE_MONITOR
347 IMonitorMgr->OnInputEvent(keyEvent, deviceTags);
348 #endif // OHOS_BUILD_ENABLE_MONITOR
349 break;
350 }
351 default: {
352 MMI_HILOG_DISPATCHW("Failed to intercept or monitor on the event");
353 break;
354 }
355 }
356 return RET_OK;
357 }
358 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
359
360 #if (defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)) && \
361 (defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR))
ReportPointerEvent(const UDSClient & client,NetPacket & pkt)362 int32_t ClientMsgHandler::ReportPointerEvent(const UDSClient& client, NetPacket& pkt)
363 {
364 InputHandlerType handlerType;
365 uint32_t deviceTags = 0;
366 pkt >> handlerType >> deviceTags;
367 if (pkt.ChkRWError()) {
368 MMI_HILOG_DISPATCHE("Packet read Pointer data failed");
369 return RET_ERR;
370 }
371 MMI_HILOG_DISPATCHD("Client handlerType:%{public}d", handlerType);
372 auto pointerEvent = PointerEvent::Create();
373 CHKPR(pointerEvent, ERROR_NULL_POINTER);
374 if (InputEventDataTransformation::Unmarshalling(pkt, pointerEvent) != ERR_OK) {
375 MMI_HILOG_DISPATCHW("Failed to deserialize pointer event");
376 return RET_ERR;
377 }
378 LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
379 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START, BytraceAdapter::POINT_INTERCEPT_EVENT);
380 switch (handlerType) {
381 case INTERCEPTOR: {
382 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
383 InputInterMgr->OnInputEvent(pointerEvent, deviceTags);
384 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
385 break;
386 }
387 case MONITOR: {
388 #ifdef OHOS_BUILD_ENABLE_MONITOR
389 IMonitorMgr->OnInputEvent(pointerEvent, deviceTags);
390 #endif // OHOS_BUILD_ENABLE_MONITOR
391 break;
392 }
393 default: {
394 MMI_HILOG_DISPATCHW("Failed to intercept or monitor on the event");
395 break;
396 }
397 }
398 return RET_OK;
399 }
400 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
401
OnDispatchEventProcessed(int32_t eventId,int64_t actionTime)402 void ClientMsgHandler::OnDispatchEventProcessed(int32_t eventId, int64_t actionTime)
403 {
404 CALL_DEBUG_ENTER;
405 ANRHDL->SetLastProcessedEventId(ANR_DISPATCH, eventId, actionTime);
406 }
407
OnAnr(const UDSClient & client,NetPacket & pkt)408 int32_t ClientMsgHandler::OnAnr(const UDSClient& client, NetPacket& pkt)
409 {
410 CALL_DEBUG_ENTER;
411 int32_t pid = 0;
412 int32_t eventId = 0;
413 pkt >> pid;
414 pkt >> eventId;
415 if (pkt.ChkRWError()) {
416 MMI_HILOG_ANRDETECTE("Packet read data failed");
417 return RET_ERR;
418 }
419 MMI_HILOG_ANRDETECTI("Client pid:%{public}d eventId:%{public}d", pid, eventId);
420 InputMgrImpl.OnAnr(pid, eventId);
421 return RET_OK;
422 }
423
NotifyWindowStateError(const UDSClient & client,NetPacket & pkt)424 int32_t ClientMsgHandler::NotifyWindowStateError(const UDSClient& client, NetPacket& pkt)
425 {
426 CALL_DEBUG_ENTER;
427 int32_t pid = 0;
428 int32_t windowId = 0;
429 pkt >> pid;
430 pkt >> windowId;
431 if (pkt.ChkRWError()) {
432 MMI_HILOG_ANRDETECTE("Packet read data failed");
433 return RET_ERR;
434 }
435 MMI_HILOG_ANRDETECTI("Client pid:%{public}d windowId:%{public}d", pid, windowId);
436 InputMgrImpl.OnWindowStateError(pid, windowId);
437 return RET_OK;
438 }
439
440 } // namespace MMI
441 } // namespace OHOS
442