1 /*
2 * Copyright (c) 2021-2023 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 "mmi_service.h"
17
18 #include <parameters.h>
19 #include <sys/signalfd.h>
20
21 #include <cinttypes>
22 #include <csignal>
23 #include "string_ex.h"
24 #ifdef OHOS_RSS_CLIENT
25 #include <unordered_map>
26 #endif
27
28 #include "ability_manager_client.h"
29 #include "anr_manager.h"
30 #include "app_debug_listener.h"
31 #include "app_state_observer.h"
32 #include "device_event_monitor.h"
33 #include "dfx_define.h"
34 #include "dfx_dump_catcher.h"
35 #include "dfx_hisysevent.h"
36 #include "dfx_json_formatter.h"
37
38 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
39 #include "display_event_monitor.h"
40 #endif // OHOS_BUILD_ENABLE_KEYBOARD
41 #include "event_dump.h"
42 #include "event_log_helper.h"
43 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
44 #include "fingersense_wrapper.h"
45 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
46 #ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
47 #include "gesturesense_wrapper.h"
48 #endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
49 #include "infrared_emitter_controller.h"
50 #include "input_device_manager.h"
51 #include "ipc_skeleton.h"
52 #include "i_input_windows_manager.h"
53 #include "i_pointer_drawing_manager.h"
54 #include "i_preference_manager.h"
55 #include "key_auto_repeat.h"
56 #include "key_command_handler.h"
57 #include "key_map_manager.h"
58 #include "mmi_log.h"
59 #include "multimodal_input_connect_def_parcel.h"
60 #include "permission_helper.h"
61 #include "timer_manager.h"
62 #include "tokenid_kit.h"
63 #include "touch_event_normalize.h"
64 #include "util.h"
65 #include "util_ex.h"
66 #include "watchdog_task.h"
67 #include "xcollie/watchdog.h"
68 #include "xcollie/xcollie.h"
69 #include "xcollie/xcollie_define.h"
70
71 #ifdef OHOS_RSS_CLIENT
72 #include "res_sched_client.h"
73 #include "res_type.h"
74 #include "system_ability_definition.h"
75 #endif // OHOS_RSS_CLIENT
76 #include "setting_datashare.h"
77 #ifdef OHOS_BUILD_ENABLE_ANCO
78 #include "app_mgr_client.h"
79 #include "running_process_info.h"
80 #endif // OHOS_BUILD_ENABLE_ANCO
81
82 #undef MMI_LOG_TAG
83 #define MMI_LOG_TAG "MMIService"
84 #undef MMI_LOG_DOMAIN
85 #define MMI_LOG_DOMAIN MMI_LOG_SERVER
86
87 namespace OHOS {
88 namespace MMI {
89 namespace {
90 std::mutex g_instanceMutex;
91 MMIService* g_MMIService;
92 const std::string DEF_INPUT_SEAT { "seat0" };
93 const std::string THREAD_NAME { "mmi-service" };
94 const std::string SHELL_ASSISTANT { "com.shell_assistant" };
95 constexpr int32_t WATCHDOG_INTERVAL_TIME { 30000 };
96 constexpr int32_t WATCHDOG_DELAY_TIME { 40000 };
97 constexpr int32_t RELOAD_DEVICE_TIME { 2000 };
98 constexpr int32_t REMOVE_OBSERVER { -2 };
99 constexpr int32_t REPEAT_COUNT { 2 };
100 constexpr int32_t UNSUBSCRIBED { -1 };
101 constexpr int32_t UNOBSERVED { -1 };
102 constexpr int32_t SUBSCRIBED { 1 };
103 constexpr int32_t DISTRIBUTE_TIME { 1000 }; // 1000ms
104 constexpr int32_t COMMON_PARAMETER_ERROR { 401 };
105 constexpr size_t MAX_FRAME_NUMS { 100 };
106 constexpr int32_t THREAD_BLOCK_TIMER_SPAN_S { 3 };
107 const std::set<int32_t> g_keyCodeValueSet = {
108 KeyEvent::KEYCODE_FN, KeyEvent::KEYCODE_DPAD_UP, KeyEvent::KEYCODE_DPAD_DOWN, KeyEvent::KEYCODE_DPAD_LEFT,
109 KeyEvent::KEYCODE_DPAD_RIGHT, KeyEvent::KEYCODE_ALT_LEFT, KeyEvent::KEYCODE_ALT_RIGHT,
110 KeyEvent::KEYCODE_SHIFT_LEFT, KeyEvent::KEYCODE_SHIFT_RIGHT, KeyEvent::KEYCODE_TAB, KeyEvent::KEYCODE_ENTER,
111 KeyEvent::KEYCODE_DEL, KeyEvent::KEYCODE_MENU, KeyEvent::KEYCODE_PAGE_UP, KeyEvent::KEYCODE_PAGE_DOWN,
112 KeyEvent::KEYCODE_ESCAPE, KeyEvent::KEYCODE_FORWARD_DEL, KeyEvent::KEYCODE_CTRL_LEFT, KeyEvent::KEYCODE_CTRL_RIGHT,
113 KeyEvent::KEYCODE_CAPS_LOCK, KeyEvent::KEYCODE_SCROLL_LOCK, KeyEvent::KEYCODE_META_LEFT,
114 KeyEvent::KEYCODE_META_RIGHT, KeyEvent::KEYCODE_SYSRQ, KeyEvent::KEYCODE_BREAK, KeyEvent::KEYCODE_MOVE_HOME,
115 KeyEvent::KEYCODE_MOVE_END, KeyEvent::KEYCODE_INSERT, KeyEvent::KEYCODE_F1, KeyEvent::KEYCODE_F2,
116 KeyEvent::KEYCODE_F3, KeyEvent::KEYCODE_F4, KeyEvent::KEYCODE_F5, KeyEvent::KEYCODE_F6, KeyEvent::KEYCODE_F7,
117 KeyEvent::KEYCODE_F8, KeyEvent::KEYCODE_F9, KeyEvent::KEYCODE_F10, KeyEvent::KEYCODE_F11, KeyEvent::KEYCODE_F12,
118 KeyEvent::KEYCODE_NUM_LOCK
119 };
120 #ifdef OHOS_BUILD_ENABLE_ANCO
121 constexpr int32_t DEFAULT_USER_ID { 100 };
122 #endif // OHOS_BUILD_ENABLE_ANCO
123 } // namespace
124
125 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(MMIService::GetInstance());
126
CheckDefineOutput(const char * fmt,Ts...args)127 template <class... Ts> void CheckDefineOutput(const char *fmt, Ts... args)
128 {
129 CHKPV(fmt);
130 char buf[MAX_PACKET_BUF_SIZE] = {};
131 int32_t ret = snprintf_s(buf, MAX_PACKET_BUF_SIZE, MAX_PACKET_BUF_SIZE - 1, fmt, args...);
132 if (ret == -1) {
133 KMSG_LOGE("Call snprintf_s failed.ret = %d", ret);
134 return;
135 }
136 KMSG_LOGI("%s", buf);
137 MMI_HILOGI("%{public}s", buf);
138 }
139
CheckDefine()140 static void CheckDefine()
141 {
142 CheckDefineOutput("ChkDefs:");
143 #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
144 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_POINTER_DRAWING");
145 #endif
146 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
147 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_INTERCEPTOR");
148 #endif
149 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
150 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_KEYBOARD");
151 #endif
152 #ifdef OHOS_BUILD_ENABLE_POINTER
153 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_POINTER");
154 #endif
155 #ifdef OHOS_BUILD_ENABLE_TOUCH
156 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_TOUCH");
157 #endif
158 #ifdef OHOS_BUILD_ENABLE_MONITOR
159 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_MONITOR");
160 #endif
161 }
162
MMIService()163 MMIService::MMIService() : SystemAbility(MULTIMODAL_INPUT_CONNECT_SERVICE_ID, true) {}
164
~MMIService()165 MMIService::~MMIService()
166 {
167 if (g_MMIService != nullptr) {
168 g_MMIService = nullptr;
169 }
170 MMI_HILOGI("~MMIService");
171 }
172
GetInstance()173 MMIService* MMIService::GetInstance()
174 {
175 if (g_MMIService == nullptr) {
176 std::lock_guard<std::mutex> lock(g_instanceMutex);
177 if (g_MMIService == nullptr) {
178 MMI_HILOGI("new MMIService");
179 g_MMIService = new MMIService();
180 }
181 }
182 return g_MMIService;
183 }
184
AddEpoll(EpollEventType type,int32_t fd)185 int32_t MMIService::AddEpoll(EpollEventType type, int32_t fd)
186 {
187 if (type < EPOLL_EVENT_BEGIN || type >= EPOLL_EVENT_END) {
188 MMI_HILOGE("Invalid param type");
189 return RET_ERR;
190 }
191 if (fd < 0) {
192 MMI_HILOGE("Invalid param fd_");
193 return RET_ERR;
194 }
195 if (mmiFd_ < 0) {
196 MMI_HILOGE("Invalid param mmiFd_");
197 return RET_ERR;
198 }
199 auto eventData = std::make_shared<mmi_epoll_event>();
200 eventData->fd = fd;
201 eventData->event_type = type;
202 MMI_HILOGI("userdata:[fd:%{public}d, type:%{public}d]", eventData->fd, eventData->event_type);
203
204 struct epoll_event ev = {};
205 ev.events = EPOLLIN;
206 ev.data.fd = fd;
207 auto ret = EpollCtl(fd, EPOLL_CTL_ADD, ev, mmiFd_);
208 if (ret < 0) {
209 eventData = nullptr;
210 ev.data.ptr = nullptr;
211 return ret;
212 }
213 AddEpollEvent(fd, eventData);
214 return RET_OK;
215 }
216
DelEpoll(EpollEventType type,int32_t fd)217 int32_t MMIService::DelEpoll(EpollEventType type, int32_t fd)
218 {
219 if (type < EPOLL_EVENT_BEGIN || type >= EPOLL_EVENT_END) {
220 MMI_HILOGE("Invalid param type");
221 return RET_ERR;
222 }
223 if (fd < 0) {
224 MMI_HILOGE("Invalid param fd_");
225 return RET_ERR;
226 }
227 if (mmiFd_ < 0) {
228 MMI_HILOGE("Invalid param mmiFd_");
229 return RET_ERR;
230 }
231 struct epoll_event ev = {};
232 auto ret = EpollCtl(fd, EPOLL_CTL_DEL, ev, mmiFd_);
233 if (ret < 0) {
234 MMI_HILOGE("DelEpoll failed");
235 return ret;
236 }
237 return RET_OK;
238 }
239
IsRunning() const240 bool MMIService::IsRunning() const
241 {
242 return (state_ == ServiceRunningState::STATE_RUNNING);
243 }
244
InitLibinputService()245 bool MMIService::InitLibinputService()
246 {
247 if (!(libinputAdapter_.Init([] (void *event, int64_t frameTime) {
248 ::OHOS::DelayedSingleton<InputEventHandler>::GetInstance()->OnEvent(event, frameTime);
249 }
250 ))) {
251 MMI_HILOGE("Libinput init, bind failed");
252 return false;
253 }
254 auto inputFds = libinputAdapter_.GetInputFds();
255 for (auto fd : inputFds) {
256 auto ret = AddEpoll(EPOLL_EVENT_INPUT, fd);
257 if (ret < 0) {
258 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
259 EpollClose();
260 return false;
261 }
262 MMI_HILOGD("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, fd);
263 }
264 return true;
265 }
266
InitService()267 bool MMIService::InitService()
268 {
269 MMI_HILOGD("Server msg handler Init");
270 sMsgHandler_.Init(*this);
271 if (state_ != ServiceRunningState::STATE_NOT_START) {
272 MMI_HILOGE("Service running status is not enabled");
273 return false;
274 }
275 if (EpollCreate(MAX_EVENT_SIZE) < 0) {
276 MMI_HILOGE("Create epoll failed");
277 return false;
278 }
279 auto ret = AddEpoll(EPOLL_EVENT_SOCKET, epollFd_);
280 if (ret < 0) {
281 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
282 EpollClose();
283 return false;
284 }
285 state_ = ServiceRunningState::STATE_RUNNING;
286 if (!(Publish(this))) {
287 state_ = ServiceRunningState::STATE_NOT_START;
288 MMI_HILOGE("Service initialization failed");
289 EpollClose();
290 return false;
291 }
292 MMI_HILOGI("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, epollFd_);
293 return true;
294 }
295
InitDelegateTasks()296 bool MMIService::InitDelegateTasks()
297 {
298 CALL_DEBUG_ENTER;
299 if (!delegateTasks_.Init()) {
300 MMI_HILOGE("The delegate task init failed");
301 return false;
302 }
303 auto ret = AddEpoll(EPOLL_EVENT_ETASK, delegateTasks_.GetReadFd());
304 if (ret < 0) {
305 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
306 EpollClose();
307 return false;
308 }
309 std::function<int32_t(DTaskCallback)> fun = [this](DTaskCallback cb) -> int32_t {
310 return delegateTasks_.PostSyncTask(cb);
311 };
312 delegateInterface_ = std::make_shared<DelegateInterface>(fun);
313 delegateInterface_->Init();
314 MMI_HILOGI("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, delegateTasks_.GetReadFd());
315 return true;
316 }
317
Init()318 int32_t MMIService::Init()
319 {
320 CheckDefine();
321 MMI_HILOGD("WindowsManager Init");
322 WIN_MGR->Init(*this);
323 MMI_HILOGD("NapProcess Init");
324 NapProcess::GetInstance()->Init(*this);
325 MMI_HILOGD("ANRManager Init");
326 ANRMgr->Init(*this);
327 MMI_HILOGI("PointerDrawingManager Init");
328 #ifdef OHOS_BUILD_ENABLE_POINTER
329 if (!IPointerDrawingManager::GetInstance()->Init()) {
330 MMI_HILOGE("Pointer draw init failed");
331 return POINTER_DRAW_INIT_FAIL;
332 }
333 #endif // OHOS_BUILD_ENABLE_POINTER
334 mmiFd_ = EpollCreate(MAX_EVENT_SIZE);
335 if (mmiFd_ < 0) {
336 MMI_HILOGE("Create epoll failed");
337 return EPOLL_CREATE_FAIL;
338 }
339 MMI_HILOGD("Input msg handler init");
340 InputHandler->Init(*this);
341 MMI_HILOGD("Libinput service init");
342 if (!InitLibinputService()) {
343 MMI_HILOGE("Libinput init failed");
344 return LIBINPUT_INIT_FAIL;
345 }
346 MMI_HILOGD("Init DelegateTasks init");
347 if (!InitDelegateTasks()) {
348 MMI_HILOGE("Delegate tasks init failed");
349 return ETASKS_INIT_FAIL;
350 }
351 SetRecvFun([this] (SessionPtr sess, NetPacket& pkt) {sMsgHandler_.OnMsgHandler(sess, pkt);});
352 KeyMapMgr->GetConfigKeyValue("default_keymap", KeyMapMgr->GetDefaultKeyId());
353 OHOS::system::SetParameter(INPUT_POINTER_DEVICES, "false");
354 if (!InitService()) {
355 MMI_HILOGE("Saservice init failed");
356 return SASERVICE_INIT_FAIL;
357 }
358 MMI_HILOGI("Set para input.pointer.device false");
359 return RET_OK;
360 }
361
OnStart()362 void MMIService::OnStart()
363 {
364 CHK_PID_AND_TID();
365 int32_t ret = Init();
366 CHKNOKRV(ret, "Init mmi_service failed");
367 MMI_HILOGD("Started successfully");
368 AddReloadDeviceTimer();
369 t_ = std::thread([this] {this->OnThread();});
370 pthread_setname_np(t_.native_handle(), THREAD_NAME.c_str());
371 auto keyHandler = InputHandler->GetKeyCommandHandler();
372 if (keyHandler != nullptr) {
373 keyHandler->PreHandleEvent();
374 }
375 #ifdef OHOS_RSS_CLIENT
376 MMI_HILOGI("Add system ability listener start");
377 AddSystemAbilityListener(RES_SCHED_SYS_ABILITY_ID);
378 MMI_HILOGI("Add system ability listener success");
379 #endif // OHOS_RSS_CLIENT
380 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER) && defined(OHOS_BUILD_ENABLE_KEYBOARD)
381 FINGERSENSE_WRAPPER->InitFingerSenseWrapper();
382 MMI_HILOGI("Add system ability listener start");
383 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
384 MMI_HILOGI("Add system ability listener success");
385 DISPLAY_MONITOR->InitCommonEventSubscriber();
386 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER && OHOS_BUILD_ENABLE_KEYBOARD
387 #ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
388 GESTURESENSE_WRAPPER->InitGestureSenseWrapper();
389 #endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
390 MMI_HILOGI("Add app manager service listener start");
391 AddSystemAbilityListener(APP_MGR_SERVICE_ID);
392 APP_OBSERVER_MGR->InitAppStateObserver();
393 MMI_HILOGI("Add app manager service listener end");
394 AddSystemAbilityListener(RENDER_SERVICE);
395 AddAppDebugListener();
396 AddSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID);
397 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
398 MMI_HILOGI("Add system ability listener start");
399 AddSystemAbilityListener(PLAYER_DISTRIBUTED_SERVICE_ID);
400 MMI_HILOGI("Add system ability listener end");
401 #endif
402 #ifdef OHOS_BUILD_ENABLE_ANCO
403 InitAncoUds();
404 #endif // OHOS_BUILD_ENABLE_ANCO
405 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
406 IPointerDrawingManager::GetInstance()->InitPointerObserver();
407 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
408 PREFERENCES_MGR->InitPreferences();
409 #if OHOS_BUILD_ENABLE_POINTER
410 bool switchFlag = false;
411 TOUCH_EVENT_HDR->GetTouchpadDoubleTapAndDragState(switchFlag);
412 TOUCH_EVENT_HDR->SetTouchpadDoubleTapAndDragState(switchFlag);
413 #endif
414 TimerMgr->AddTimer(WATCHDOG_INTERVAL_TIME, -1, [this]() {
415 MMI_HILOGD("Set thread status flag to true");
416 threadStatusFlag_ = true;
417 });
418 auto taskFunc = [this]() {
419 if (threadStatusFlag_) {
420 MMI_HILOGD("Set thread status flag to false");
421 threadStatusFlag_ = false;
422 } else {
423 MMI_HILOGE("Timeout happened");
424 }
425 };
426 HiviewDFX::Watchdog::GetInstance().RunPeriodicalTask("MMIService", taskFunc, WATCHDOG_INTERVAL_TIME,
427 WATCHDOG_DELAY_TIME);
428 MMI_HILOGI("Run periodical task success");
429 }
430
OnStop()431 void MMIService::OnStop()
432 {
433 CHK_PID_AND_TID();
434 UdsStop();
435 libinputAdapter_.Stop();
436 state_ = ServiceRunningState::STATE_NOT_START;
437 #ifdef OHOS_RSS_CLIENT
438 MMI_HILOGI("Remove system ability listener start");
439 RemoveSystemAbilityListener(RES_SCHED_SYS_ABILITY_ID);
440 MMI_HILOGI("Remove system ability listener success");
441 #endif
442 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
443 RemoveSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
444 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
445 RemoveSystemAbilityListener(APP_MGR_SERVICE_ID);
446 RemoveSystemAbilityListener(RENDER_SERVICE);
447 RemoveAppDebugListener();
448 RemoveSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID);
449 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
450 RemoveSystemAbilityListener(PLAYER_DISTRIBUTED_SERVICE_ID);
451 #endif
452 #ifdef OHOS_BUILD_ENABLE_ANCO
453 StopAncoUds();
454 #endif // OHOS_BUILD_ENABLE_ANCO
455 }
456
AddAppDebugListener()457 void MMIService::AddAppDebugListener()
458 {
459 CALL_DEBUG_ENTER;
460 appDebugListener_ = AppDebugListener::GetInstance();
461 auto errCode =
462 AAFwk::AbilityManagerClient::GetInstance()->RegisterAppDebugListener(appDebugListener_);
463 if (errCode != RET_OK) {
464 MMI_HILOGE("Call RegisterAppDebugListener failed, errCode:%{public}d", errCode);
465 }
466 }
467
RemoveAppDebugListener()468 void MMIService::RemoveAppDebugListener()
469 {
470 CALL_DEBUG_ENTER;
471 CHKPV(appDebugListener_);
472 auto errCode =
473 AAFwk::AbilityManagerClient::GetInstance()->UnregisterAppDebugListener(appDebugListener_);
474 if (errCode != RET_OK) {
475 MMI_HILOGE("Call UnregisterAppDebugListener failed, errCode:%{public}d", errCode);
476 }
477 }
478
AllocSocketFd(const std::string & programName,const int32_t moduleType,int32_t & toReturnClientFd,int32_t & tokenType)479 int32_t MMIService::AllocSocketFd(const std::string &programName, const int32_t moduleType, int32_t &toReturnClientFd,
480 int32_t &tokenType)
481 {
482 toReturnClientFd = IMultimodalInputConnect::INVALID_SOCKET_FD;
483 int32_t serverFd = IMultimodalInputConnect::INVALID_SOCKET_FD;
484 int32_t pid = GetCallingPid();
485 int32_t uid = GetCallingUid();
486 MMI_HILOGI("Enter, programName:%{public}s, moduleType:%{public}d, pid:%{public}d",
487 programName.c_str(), moduleType, pid);
488 int32_t ret = delegateTasks_.PostSyncTask(
489 [this, &programName, moduleType, uid, pid, &serverFd, &toReturnClientFd, &tokenType] {
490 return this->AddSocketPairInfo(programName, moduleType, uid, pid, serverFd, toReturnClientFd, tokenType);
491 }
492 );
493 DfxHisysevent::ClientConnectData data = {
494 .pid = pid,
495 .uid = uid,
496 .moduleType = moduleType,
497 .programName = programName,
498 .serverFd = serverFd
499 };
500 if (ret != RET_OK) {
501 MMI_HILOGE("Call AddSocketPairInfo failed, return:%{public}d", ret);
502 DfxHisysevent::OnClientConnect(data, OHOS::HiviewDFX::HiSysEvent::EventType::FAULT);
503 return ret;
504 }
505 MMI_HILOGIK("Leave, programName:%{public}s, moduleType:%{public}d, alloc success", programName.c_str(),
506 moduleType);
507 DfxHisysevent::OnClientConnect(data, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR);
508 return RET_OK;
509 }
510
AddInputEventFilter(sptr<IEventFilter> filter,int32_t filterId,int32_t priority,uint32_t deviceTags)511 int32_t MMIService::AddInputEventFilter(sptr<IEventFilter> filter, int32_t filterId, int32_t priority,
512 uint32_t deviceTags)
513 {
514 CALL_INFO_TRACE;
515 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) || defined(OHOS_BUILD_ENABLE_KEYBOARD)
516 CHKPR(filter, ERROR_NULL_POINTER);
517 int32_t clientPid = GetCallingPid();
518 int32_t ret = delegateTasks_.PostSyncTask(
519 [this, filter, filterId, priority, deviceTags, clientPid] {
520 return sMsgHandler_.AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
521 }
522 );
523 if (ret != RET_OK) {
524 MMI_HILOGE("Add event filter failed, return:%{public}d", ret);
525 return ret;
526 }
527 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH || OHOS_BUILD_ENABLE_KEYBOARD
528 return RET_OK;
529 }
530
RemoveInputEventFilter(int32_t filterId)531 int32_t MMIService::RemoveInputEventFilter(int32_t filterId)
532 {
533 CALL_INFO_TRACE;
534 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) || defined(OHOS_BUILD_ENABLE_KEYBOARD)
535 int32_t clientPid = GetCallingPid();
536 int32_t ret = delegateTasks_.PostSyncTask(
537 [this, filterId, clientPid] {
538 return sMsgHandler_.RemoveInputEventFilter(filterId, clientPid);
539 }
540 );
541 if (ret != RET_OK) {
542 MMI_HILOGE("Remove event filter failed, return:%{public}d", ret);
543 return ret;
544 }
545 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH || OHOS_BUILD_ENABLE_KEYBOARD
546 return RET_OK;
547 }
548
OnConnected(SessionPtr s)549 void MMIService::OnConnected(SessionPtr s)
550 {
551 CHKPV(s);
552 MMI_HILOGI("fd:%{public}d", s->GetFd());
553 #ifdef OHOS_BUILD_ENABLE_ANCO
554 if (s->GetProgramName() != SHELL_ASSISTANT) {
555 return;
556 }
557 auto appMgrClient = DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance();
558 if (appMgrClient == nullptr) {
559 return;
560 }
561 int32_t userid = WIN_MGR->GetCurrentUserId();
562 if (userid < 0) {
563 userid = DEFAULT_USER_ID;
564 }
565 std::vector<AppExecFwk::RunningProcessInfo> info;
566 appMgrClient->GetProcessRunningInfosByUserId(info, userid);
567 for (auto &item : info) {
568 if (item.bundleNames.empty()) {
569 continue;
570 }
571 if (SHELL_ASSISTANT == item.bundleNames[0].c_str()) {
572 MMI_HILOGW("record client processes pid %{public}d", item.pid_);
573 shellAssitentPid_ = item.pid_;
574 }
575 }
576 #endif // OHOS_BUILD_ENABLE_ANCO
577 }
578
OnDisconnected(SessionPtr s)579 void MMIService::OnDisconnected(SessionPtr s)
580 {
581 CHKPV(s);
582 MMI_HILOGW("Enter, session desc:%{public}s, fd:%{public}d", s->GetDescript().c_str(), s->GetFd());
583 auto ret = RemoveInputEventFilter(-1);
584 if (ret != RET_OK) {
585 MMI_HILOGF("Remove all filter failed, ret:%{public}d", ret);
586 }
587 #ifdef OHOS_BUILD_ENABLE_ANCO
588 if (s->GetProgramName() == SHELL_ASSISTANT && shellAssitentPid_ == s->GetPid()) {
589 MMI_HILOGW("clean all shell windows pid: %{public}d", s->GetPid());
590 shellAssitentPid_ = -1;
591 IInputWindowsManager::GetInstance()->CleanShellWindowIds();
592 }
593 #endif // OHOS_BUILD_ENABLE_ANCO
594 #ifdef OHOS_BUILD_ENABLE_POINTER
595 IPointerDrawingManager::GetInstance()->DeletePointerVisible(s->GetPid());
596 #endif // OHOS_BUILD_ENABLE_POINTER
597 }
598
SetMouseScrollRows(int32_t rows)599 int32_t MMIService::SetMouseScrollRows(int32_t rows)
600 {
601 CALL_INFO_TRACE;
602 #if defined OHOS_BUILD_ENABLE_POINTER
603 int32_t ret = delegateTasks_.PostSyncTask(
604 [rows] {
605 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetMouseScrollRows(rows);
606 }
607 );
608 if (ret != RET_OK) {
609 MMI_HILOGE("Set the number of mouse scrolling rows failed, return:%{public}d", ret);
610 return ret;
611 }
612 #endif // OHOS_BUILD_ENABLE_POINTER
613 return RET_OK;
614 }
615
SetCustomCursor(int32_t pid,int32_t windowId,int32_t focusX,int32_t focusY,void * pixelMap)616 int32_t MMIService::SetCustomCursor(int32_t pid, int32_t windowId, int32_t focusX, int32_t focusY, void* pixelMap)
617 {
618 CALL_INFO_TRACE;
619 #if defined OHOS_BUILD_ENABLE_POINTER
620 int32_t ret = CheckPidPermission(pid);
621 if (ret != RET_OK) {
622 MMI_HILOGE("Check pid permission failed");
623 return ret;
624 }
625 ret = delegateTasks_.PostSyncTask(std::bind(
626 [pixelMap, pid, windowId, focusX, focusY] {
627 return IPointerDrawingManager::GetInstance()->SetCustomCursor(pixelMap, pid, windowId, focusX, focusY);
628 }
629 ));
630 if (ret != RET_OK) {
631 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
632 return ret;
633 }
634 #endif // OHOS_BUILD_ENABLE_POINTER
635 return RET_OK;
636 }
637
SetMouseIcon(int32_t windowId,void * pixelMap)638 int32_t MMIService::SetMouseIcon(int32_t windowId, void* pixelMap)
639 {
640 CALL_INFO_TRACE;
641 #if defined OHOS_BUILD_ENABLE_POINTER
642 int32_t pid = GetCallingPid();
643 int32_t ret = CheckPidPermission(pid);
644 if (ret != RET_OK) {
645 MMI_HILOGE("Check pid permission failed");
646 return ret;
647 }
648 ret = delegateTasks_.PostSyncTask(std::bind(
649 [pid, windowId, pixelMap] {
650 return IPointerDrawingManager::GetInstance()->SetMouseIcon(pid, windowId, pixelMap);
651 }
652 ));
653 if (ret != RET_OK) {
654 MMI_HILOGE("Set the mouse icon failed, return:%{public}d", ret);
655 return ret;
656 }
657 #endif // OHOS_BUILD_ENABLE_POINTER
658 return RET_OK;
659 }
660
SetMouseHotSpot(int32_t pid,int32_t windowId,int32_t hotSpotX,int32_t hotSpotY)661 int32_t MMIService::SetMouseHotSpot(int32_t pid, int32_t windowId, int32_t hotSpotX, int32_t hotSpotY)
662 {
663 CALL_INFO_TRACE;
664 #if defined OHOS_BUILD_ENABLE_POINTER
665 int32_t ret = CheckPidPermission(pid);
666 if (ret != RET_OK) {
667 MMI_HILOGE("Check pid permission failed");
668 return ret;
669 }
670 ret = delegateTasks_.PostSyncTask(
671 [pid, windowId, hotSpotX, hotSpotY] {
672 return IPointerDrawingManager::GetInstance()->SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
673 }
674 );
675 if (ret != RET_OK) {
676 MMI_HILOGE("Set the mouse hot spot failed, return:%{public}d", ret);
677 return ret;
678 }
679 #endif // OHOS_BUILD_ENABLE_POINTER
680 return RET_OK;
681 }
682
SetNapStatus(int32_t pid,int32_t uid,std::string bundleName,int32_t napStatus)683 int32_t MMIService::SetNapStatus(int32_t pid, int32_t uid, std::string bundleName, int32_t napStatus)
684 {
685 CALL_INFO_TRACE;
686 int32_t ret = CheckPidPermission(pid);
687 if (ret != RET_OK) {
688 MMI_HILOGE("Check pid permission failed");
689 return ret;
690 }
691 NapProcess::GetInstance()->SetNapStatus(pid, uid, bundleName, napStatus);
692 return RET_OK;
693 }
694
695 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadMouseScrollRows(int32_t & rows)696 int32_t MMIService::ReadMouseScrollRows(int32_t &rows)
697 {
698 rows = MouseEventHdr->GetMouseScrollRows();
699 return RET_OK;
700 }
701 #endif // OHOS_BUILD_ENABLE_POINTER
702
GetMouseScrollRows(int32_t & rows)703 int32_t MMIService::GetMouseScrollRows(int32_t &rows)
704 {
705 CALL_INFO_TRACE;
706 #ifdef OHOS_BUILD_ENABLE_POINTER
707 int32_t ret = delegateTasks_.PostSyncTask(
708 [this, &rows] {
709 return this->ReadMouseScrollRows(rows);
710 }
711 );
712 if (ret != RET_OK) {
713 MMI_HILOGE("Get the number of mouse scrolling rows failed, ret:%{public}d", ret);
714 return ret;
715 }
716 #endif // OHOS_BUILD_ENABLE_POINTER
717 return RET_OK;
718 }
719
SetPointerSize(int32_t size)720 int32_t MMIService::SetPointerSize(int32_t size)
721 {
722 CALL_INFO_TRACE;
723 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
724 int32_t ret = delegateTasks_.PostSyncTask(
725 [size] {
726 return IPointerDrawingManager::GetInstance()->SetPointerSize(size);
727 }
728 );
729 if (ret != RET_OK) {
730 MMI_HILOGE("Set pointer size failed, return:%{public}d", ret);
731 return ret;
732 }
733 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
734 return RET_OK;
735 }
736
737 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
ReadPointerSize(int32_t & size)738 int32_t MMIService::ReadPointerSize(int32_t &size)
739 {
740 size = IPointerDrawingManager::GetInstance()->GetPointerSize();
741 return RET_OK;
742 }
743 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
744
GetPointerSize(int32_t & size)745 int32_t MMIService::GetPointerSize(int32_t &size)
746 {
747 CALL_INFO_TRACE;
748 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
749 int32_t ret = delegateTasks_.PostSyncTask(
750 [this, &size] {
751 return this->ReadPointerSize(size);
752 }
753 );
754 if (ret != RET_OK) {
755 MMI_HILOGE("Get pointer size failed, return:%{public}d", ret);
756 return ret;
757 }
758 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
759 return RET_OK;
760 }
761
GetCursorSurfaceId(uint64_t & surfaceId)762 int32_t MMIService::GetCursorSurfaceId(uint64_t &surfaceId)
763 {
764 CALL_INFO_TRACE;
765 #ifdef OHOS_BUILD_ENABLE_POINTER
766 auto ret = delegateTasks_.PostSyncTask(
767 [&surfaceId] {
768 return IPointerDrawingManager::GetInstance()->GetCursorSurfaceId(surfaceId);
769 });
770 if (ret != RET_OK) {
771 MMI_HILOGE("GetCursorSurfaceId fail, error:%{public}d", ret);
772 return ret;
773 }
774 #endif // OHOS_BUILD_ENABLE_POINTER
775 return RET_OK;
776 }
777
SetMousePrimaryButton(int32_t primaryButton)778 int32_t MMIService::SetMousePrimaryButton(int32_t primaryButton)
779 {
780 CALL_INFO_TRACE;
781 #if defined OHOS_BUILD_ENABLE_POINTER
782 int32_t ret = delegateTasks_.PostSyncTask(
783 [primaryButton] {
784 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetMousePrimaryButton(primaryButton);
785 }
786 );
787 if (ret != RET_OK) {
788 MMI_HILOGE("Set mouse primary button failed, return:%{public}d", ret);
789 return ret;
790 }
791 #endif // OHOS_BUILD_ENABLE_POINTER
792 return RET_OK;
793 }
794
795 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadMousePrimaryButton(int32_t & primaryButton)796 int32_t MMIService::ReadMousePrimaryButton(int32_t &primaryButton)
797 {
798 primaryButton = MouseEventHdr->GetMousePrimaryButton();
799 return RET_OK;
800 }
801 #endif // OHOS_BUILD_ENABLE_POINTER
802
GetMousePrimaryButton(int32_t & primaryButton)803 int32_t MMIService::GetMousePrimaryButton(int32_t &primaryButton)
804 {
805 CALL_INFO_TRACE;
806 #ifdef OHOS_BUILD_ENABLE_POINTER
807 int32_t ret = delegateTasks_.PostSyncTask(
808 [this, &primaryButton] {
809 return this->ReadMousePrimaryButton(primaryButton);
810 }
811 );
812 if (ret != RET_OK) {
813 MMI_HILOGE("Get mouse primary button failed, return:%{public}d", ret);
814 return ret;
815 }
816 #endif // OHOS_BUILD_ENABLE_POINTER
817 return RET_OK;
818 }
819
SetPointerVisible(bool visible,int32_t priority)820 int32_t MMIService::SetPointerVisible(bool visible, int32_t priority)
821 {
822 CALL_INFO_TRACE;
823 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
824 auto tokenId = IPCSkeleton::GetCallingTokenID();
825 auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
826 bool isHap = false;
827 if (tokenType == OHOS::Security::AccessToken::TOKEN_HAP) {
828 isHap = true;
829 }
830 int32_t clientPid = GetCallingPid();
831 int32_t ret = delegateTasks_.PostSyncTask(
832 [clientPid, visible, priority, isHap] {
833 return IPointerDrawingManager::GetInstance()->SetPointerVisible(clientPid, visible, priority, isHap);
834 }
835 );
836 if (ret != RET_OK) {
837 MMI_HILOGE("Set pointer visible failed, return:%{public}d", ret);
838 return ret;
839 }
840 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
841 return RET_OK;
842 }
843
844 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
CheckPointerVisible(bool & visible)845 int32_t MMIService::CheckPointerVisible(bool &visible)
846 {
847 visible = IPointerDrawingManager::GetInstance()->IsPointerVisible();
848 return RET_OK;
849 }
850 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
851
IsPointerVisible(bool & visible)852 int32_t MMIService::IsPointerVisible(bool &visible)
853 {
854 CALL_DEBUG_ENTER;
855 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
856 int32_t ret = delegateTasks_.PostSyncTask(
857 [this, &visible] {
858 return this->CheckPointerVisible(visible);
859 }
860 );
861 if (ret != RET_OK) {
862 MMI_HILOGE("Is pointer visible failed, return:%{public}d", ret);
863 return ret;
864 }
865 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
866 return RET_OK;
867 }
868
MarkProcessed(int32_t eventType,int32_t eventId)869 int32_t MMIService::MarkProcessed(int32_t eventType, int32_t eventId)
870 {
871 CALL_DEBUG_ENTER;
872 CHKPR(ANRMgr, RET_ERR);
873 int32_t clientPid = GetCallingPid();
874 int32_t ret = delegateTasks_.PostSyncTask(
875 [clientPid, eventType, eventId] {
876 return ::OHOS::DelayedSingleton<ANRManager>::GetInstance()->MarkProcessed(clientPid, eventType, eventId);
877 }
878 );
879 if (ret != RET_OK) {
880 MMI_HILOGD("Mark event processed failed, ret:%{public}d", ret);
881 return ret;
882 }
883 return RET_OK;
884 }
885
SetPointerColor(int32_t color)886 int32_t MMIService::SetPointerColor(int32_t color)
887 {
888 CALL_INFO_TRACE;
889 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
890 int32_t ret = delegateTasks_.PostSyncTask(
891 [color] {
892 return IPointerDrawingManager::GetInstance()->SetPointerColor(color);
893 }
894 );
895 if (ret != RET_OK) {
896 MMI_HILOGE("Set pointer color failed, return:%{public}d", ret);
897 return ret;
898 }
899 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
900 return RET_OK;
901 }
902
903 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
ReadPointerColor(int32_t & color)904 int32_t MMIService::ReadPointerColor(int32_t &color)
905 {
906 color = IPointerDrawingManager::GetInstance()->GetPointerColor();
907 return RET_OK;
908 }
909 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
910
GetPointerColor(int32_t & color)911 int32_t MMIService::GetPointerColor(int32_t &color)
912 {
913 CALL_INFO_TRACE;
914 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
915 int32_t ret = delegateTasks_.PostSyncTask(
916 [this, &color] {
917 return this->ReadPointerColor(color);
918 }
919 );
920 if (ret != RET_OK) {
921 MMI_HILOGE("Get pointer color failed, return:%{public}d", ret);
922 return ret;
923 }
924 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
925 return RET_OK;
926 }
927
SetPointerSpeed(int32_t speed)928 int32_t MMIService::SetPointerSpeed(int32_t speed)
929 {
930 CALL_INFO_TRACE;
931 #ifdef OHOS_BUILD_ENABLE_POINTER
932 int32_t ret = delegateTasks_.PostSyncTask(
933 [speed] {
934 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetPointerSpeed(speed);
935 }
936 );
937 if (ret != RET_OK) {
938 MMI_HILOGE("Set pointer speed failed, return:%{public}d", ret);
939 return ret;
940 }
941 #endif // OHOS_BUILD_ENABLE_POINTER
942 return RET_OK;
943 }
944
945 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadPointerSpeed(int32_t & speed)946 int32_t MMIService::ReadPointerSpeed(int32_t &speed)
947 {
948 speed = MouseEventHdr->GetPointerSpeed();
949 return RET_OK;
950 }
951 #endif // OHOS_BUILD_ENABLE_POINTER
952
GetPointerSpeed(int32_t & speed)953 int32_t MMIService::GetPointerSpeed(int32_t &speed)
954 {
955 CALL_INFO_TRACE;
956 #ifdef OHOS_BUILD_ENABLE_POINTER
957 int32_t ret = delegateTasks_.PostSyncTask(
958 [this, &speed] {
959 return this->ReadPointerSpeed(speed);
960 }
961 );
962 if (ret != RET_OK) {
963 MMI_HILOGE("Get pointer speed failed, return:%{public}d", ret);
964 return ret;
965 }
966 #endif // OHOS_BUILD_ENABLE_POINTER
967 return RET_OK;
968 }
969
NotifyNapOnline()970 int32_t MMIService::NotifyNapOnline()
971 {
972 CALL_DEBUG_ENTER;
973 NapProcess::GetInstance()->NotifyNapOnline();
974 return RET_OK;
975 }
976
RemoveInputEventObserver()977 int32_t MMIService::RemoveInputEventObserver()
978 {
979 CALL_DEBUG_ENTER;
980 NapProcess::GetInstance()->RemoveInputEventObserver();
981 return RET_OK;
982 }
983
SetPointerStyle(int32_t windowId,PointerStyle pointerStyle,bool isUiExtension)984 int32_t MMIService::SetPointerStyle(int32_t windowId, PointerStyle pointerStyle, bool isUiExtension)
985 {
986 CALL_INFO_TRACE;
987 #ifdef OHOS_BUILD_ENABLE_POINTER
988 int32_t clientPid = GetCallingPid();
989 int32_t ret = delegateTasks_.PostSyncTask(
990 [clientPid, windowId, pointerStyle, isUiExtension] {
991 return IPointerDrawingManager::GetInstance()->SetPointerStyle(
992 clientPid, windowId, pointerStyle, isUiExtension);
993 }
994 );
995 if (ret != RET_OK) {
996 MMI_HILOGE("Set pointer style failed, return:%{public}d", ret);
997 return ret;
998 }
999 #endif // OHOS_BUILD_ENABLE_POINTER
1000 return RET_OK;
1001 }
1002
ClearWindowPointerStyle(int32_t pid,int32_t windowId)1003 int32_t MMIService::ClearWindowPointerStyle(int32_t pid, int32_t windowId)
1004 {
1005 CALL_DEBUG_ENTER;
1006 #ifdef OHOS_BUILD_ENABLE_POINTER
1007 int32_t ret = CheckPidPermission(pid);
1008 if (ret != RET_OK) {
1009 MMI_HILOGE("Check pid permission failed");
1010 return ret;
1011 }
1012 ret = delegateTasks_.PostSyncTask(
1013 [pid, windowId] {
1014 return IPointerDrawingManager::GetInstance()->ClearWindowPointerStyle(pid, windowId);
1015 }
1016 );
1017 if (ret != RET_OK) {
1018 MMI_HILOGE("Set pointer style failed, return:%{public}d", ret);
1019 return ret;
1020 }
1021 #endif // OHOS_BUILD_ENABLE_POINTER
1022 return RET_OK;
1023 }
1024
GetPointerStyle(int32_t windowId,PointerStyle & pointerStyle,bool isUiExtension)1025 int32_t MMIService::GetPointerStyle(int32_t windowId, PointerStyle &pointerStyle, bool isUiExtension)
1026 {
1027 CALL_DEBUG_ENTER;
1028 #ifdef OHOS_BUILD_ENABLE_POINTER
1029 int32_t clientPid = GetCallingPid();
1030 int32_t ret = delegateTasks_.PostSyncTask(
1031 [clientPid, windowId, &pointerStyle, isUiExtension] {
1032 return IPointerDrawingManager::GetInstance()->GetPointerStyle(
1033 clientPid, windowId, pointerStyle, isUiExtension);
1034 }
1035 );
1036 if (ret != RET_OK) {
1037 MMI_HILOGE("Get pointer style failed, return:%{public}d", ret);
1038 return ret;
1039 }
1040 #endif // OHOS_BUILD_ENABLE_POINTER
1041 return RET_OK;
1042 }
1043
SetHoverScrollState(bool state)1044 int32_t MMIService::SetHoverScrollState(bool state)
1045 {
1046 CALL_INFO_TRACE;
1047 #if defined OHOS_BUILD_ENABLE_POINTER
1048 int32_t ret = delegateTasks_.PostSyncTask(
1049 [state] {
1050 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetHoverScrollState(state);
1051 }
1052 );
1053 if (ret != RET_OK) {
1054 MMI_HILOGE("Set mouse hover scroll state failed, return:%{public}d", ret);
1055 return ret;
1056 }
1057 #endif // OHOS_BUILD_ENABLE_POINTER
1058 return RET_OK;
1059 }
1060
1061 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadHoverScrollState(bool & state)1062 int32_t MMIService::ReadHoverScrollState(bool &state)
1063 {
1064 state = WIN_MGR->GetHoverScrollState();
1065 return RET_OK;
1066 }
1067 #endif // OHOS_BUILD_ENABLE_POINTER
1068
GetHoverScrollState(bool & state)1069 int32_t MMIService::GetHoverScrollState(bool &state)
1070 {
1071 CALL_INFO_TRACE;
1072 #ifdef OHOS_BUILD_ENABLE_POINTER
1073 int32_t ret = delegateTasks_.PostSyncTask(
1074 [this, &state] {
1075 return this->ReadHoverScrollState(state);
1076 }
1077 );
1078 if (ret != RET_OK) {
1079 MMI_HILOGE("Get mouse hover scroll state, return:%{public}d", ret);
1080 return ret;
1081 }
1082 #endif // OHOS_BUILD_ENABLE_POINTER
1083 return RET_OK;
1084 }
1085
OnSupportKeys(int32_t deviceId,std::vector<int32_t> & keys,std::vector<bool> & keystroke)1086 int32_t MMIService::OnSupportKeys(int32_t deviceId, std::vector<int32_t> &keys, std::vector<bool> &keystroke)
1087 {
1088 CALL_DEBUG_ENTER;
1089 int32_t ret = INPUT_DEV_MGR->SupportKeys(deviceId, keys, keystroke);
1090 if (ret != RET_OK) {
1091 MMI_HILOGE("Device id not support");
1092 return ret;
1093 }
1094 if (keystroke.size() > MAX_SUPPORT_KEY) {
1095 MMI_HILOGE("Device exceeds the max range");
1096 return RET_ERR;
1097 }
1098 return RET_OK;
1099 }
1100
SupportKeys(int32_t deviceId,std::vector<int32_t> & keys,std::vector<bool> & keystroke)1101 int32_t MMIService::SupportKeys(int32_t deviceId, std::vector<int32_t> &keys, std::vector<bool> &keystroke)
1102 {
1103 CALL_DEBUG_ENTER;
1104 int32_t ret = delegateTasks_.PostSyncTask(
1105 [this, deviceId, &keys, &keystroke] {
1106 return this->OnSupportKeys(deviceId, keys, keystroke);
1107 }
1108 );
1109 if (ret != RET_OK) {
1110 MMI_HILOGE("Support keys info process failed, ret:%{public}d", ret);
1111 return ret;
1112 }
1113 return RET_OK;
1114 }
1115
OnGetDeviceIds(std::vector<int32_t> & ids)1116 int32_t MMIService::OnGetDeviceIds(std::vector<int32_t> &ids)
1117 {
1118 CALL_DEBUG_ENTER;
1119 ids = INPUT_DEV_MGR->GetInputDeviceIds();
1120 return RET_OK;
1121 }
1122
GetDeviceIds(std::vector<int32_t> & ids)1123 int32_t MMIService::GetDeviceIds(std::vector<int32_t> &ids)
1124 {
1125 CALL_DEBUG_ENTER;
1126 int32_t ret = delegateTasks_.PostSyncTask(
1127 [this, &ids] {
1128 return this->OnGetDeviceIds(ids);
1129 }
1130 );
1131 if (ret != RET_OK) {
1132 MMI_HILOGE("Get deviceids failed, ret:%{public}d", ret);
1133 return ret;
1134 }
1135 return RET_OK;
1136 }
1137
OnGetDevice(int32_t deviceId,std::shared_ptr<InputDevice> inputDevice)1138 int32_t MMIService::OnGetDevice(int32_t deviceId, std::shared_ptr<InputDevice> inputDevice)
1139 {
1140 CALL_DEBUG_ENTER;
1141 if (INPUT_DEV_MGR->GetInputDevice(deviceId) == nullptr) {
1142 MMI_HILOGE("Input device not found");
1143 return COMMON_PARAMETER_ERROR;
1144 }
1145 auto tmpDevice = INPUT_DEV_MGR->GetInputDevice(deviceId);
1146 inputDevice->SetId(tmpDevice->GetId());
1147 inputDevice->SetType(tmpDevice->GetType());
1148 inputDevice->SetName(tmpDevice->GetName());
1149 inputDevice->SetBus(tmpDevice->GetBus());
1150 inputDevice->SetVersion(tmpDevice->GetVersion());
1151 inputDevice->SetProduct(tmpDevice->GetProduct());
1152 inputDevice->SetVendor(tmpDevice->GetVendor());
1153 inputDevice->SetPhys(tmpDevice->GetPhys());
1154 inputDevice->SetUniq(tmpDevice->GetUniq());
1155 inputDevice->SetCapabilities(tmpDevice->GetCapabilities());
1156 inputDevice->SetAxisInfo(tmpDevice->GetAxisInfo());
1157
1158 return RET_OK;
1159 }
1160
GetDevice(int32_t deviceId,std::shared_ptr<InputDevice> & inputDevice)1161 int32_t MMIService::GetDevice(int32_t deviceId, std::shared_ptr<InputDevice> &inputDevice)
1162 {
1163 CALL_DEBUG_ENTER;
1164 int32_t ret = delegateTasks_.PostSyncTask(
1165 [this, deviceId, inputDevice] {
1166 return this->OnGetDevice(deviceId, inputDevice);
1167 }
1168 );
1169 if (ret != RET_OK) {
1170 MMI_HILOGE("Get input device info failed, ret:%{public}d", ret);
1171 return ret;
1172 }
1173 return RET_OK;
1174 }
1175
OnRegisterDevListener(int32_t pid)1176 int32_t MMIService::OnRegisterDevListener(int32_t pid)
1177 {
1178 auto sess = GetSession(GetClientFd(pid));
1179 CHKPR(sess, RET_ERR);
1180 INPUT_DEV_MGR->AddDevListener(sess);
1181 return RET_OK;
1182 }
1183
RegisterDevListener()1184 int32_t MMIService::RegisterDevListener()
1185 {
1186 CALL_DEBUG_ENTER;
1187 int32_t pid = GetCallingPid();
1188 int32_t ret = delegateTasks_.PostSyncTask(
1189 [this, pid] {
1190 return this->OnRegisterDevListener(pid);
1191 }
1192 );
1193 if (ret != RET_OK) {
1194 MMI_HILOGE("Register device listener failed, ret:%{public}d", ret);
1195 return ret;
1196 }
1197 return RET_OK;
1198 }
1199
OnUnregisterDevListener(int32_t pid)1200 int32_t MMIService::OnUnregisterDevListener(int32_t pid)
1201 {
1202 auto sess = GetSession(GetClientFd(pid));
1203 INPUT_DEV_MGR->RemoveDevListener(sess);
1204 return RET_OK;
1205 }
1206
UnregisterDevListener()1207 int32_t MMIService::UnregisterDevListener()
1208 {
1209 CALL_DEBUG_ENTER;
1210 int32_t pid = GetCallingPid();
1211 int32_t ret = delegateTasks_.PostSyncTask(
1212 [this, pid] {
1213 return this->OnUnregisterDevListener(pid);
1214 }
1215 );
1216 if (ret != RET_OK) {
1217 MMI_HILOGE("Unregister device listener failed failed, ret:%{public}d", ret);
1218 return ret;
1219 }
1220 return RET_OK;
1221 }
1222
OnGetKeyboardType(int32_t deviceId,int32_t & keyboardType)1223 int32_t MMIService::OnGetKeyboardType(int32_t deviceId, int32_t &keyboardType)
1224 {
1225 CALL_DEBUG_ENTER;
1226 int32_t ret = INPUT_DEV_MGR->GetKeyboardType(deviceId, keyboardType);
1227 if (ret != RET_OK) {
1228 MMI_HILOGD("GetKeyboardType call failed");
1229 return ret;
1230 }
1231 return RET_OK;
1232 }
1233
GetKeyboardType(int32_t deviceId,int32_t & keyboardType)1234 int32_t MMIService::GetKeyboardType(int32_t deviceId, int32_t &keyboardType)
1235 {
1236 CALL_DEBUG_ENTER;
1237 int32_t ret = delegateTasks_.PostSyncTask(
1238 [this, deviceId, &keyboardType] {
1239 return this->OnGetKeyboardType(deviceId, keyboardType);
1240 }
1241 );
1242 if (ret != RET_OK) {
1243 MMI_HILOGD("Get keyboard type failed, ret:%{public}d", ret);
1244 return ret;
1245 }
1246 return ret;
1247 }
1248
SetKeyboardRepeatDelay(int32_t delay)1249 int32_t MMIService::SetKeyboardRepeatDelay(int32_t delay)
1250 {
1251 CALL_INFO_TRACE;
1252 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1253 int32_t ret = delegateTasks_.PostSyncTask(
1254 [delay] {
1255 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->SetKeyboardRepeatDelay(delay);
1256 }
1257 );
1258 if (ret != RET_OK) {
1259 MMI_HILOGE("Set keyboard repeat delay failed, ret:%{public}d", ret);
1260 return ret;
1261 }
1262 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1263 return RET_OK;
1264 }
1265
SetKeyboardRepeatRate(int32_t rate)1266 int32_t MMIService::SetKeyboardRepeatRate(int32_t rate)
1267 {
1268 CALL_INFO_TRACE;
1269 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1270 int32_t ret = delegateTasks_.PostSyncTask(
1271 [rate] {
1272 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->SetKeyboardRepeatRate(rate);
1273 }
1274 );
1275 if (ret != RET_OK) {
1276 MMI_HILOGE("Set keyboard repeat rate failed, ret:%{public}d", ret);
1277 return ret;
1278 }
1279 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1280 return RET_OK;
1281 }
1282
GetKeyboardRepeatDelay(int32_t & delay)1283 int32_t MMIService::GetKeyboardRepeatDelay(int32_t &delay)
1284 {
1285 CALL_INFO_TRACE;
1286 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1287 int32_t ret = delegateTasks_.PostSyncTask(
1288 [&delay] {
1289 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->GetKeyboardRepeatDelay(delay);
1290 }
1291 );
1292 if (ret != RET_OK) {
1293 MMI_HILOGE("Get keyboard repeat delay failed, ret:%{public}d", ret);
1294 return ret;
1295 }
1296 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1297 return RET_OK;
1298 }
1299
GetKeyboardRepeatRate(int32_t & rate)1300 int32_t MMIService::GetKeyboardRepeatRate(int32_t &rate)
1301 {
1302 CALL_INFO_TRACE;
1303 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1304 int32_t ret = delegateTasks_.PostSyncTask(
1305 [&rate] {
1306 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->GetKeyboardRepeatRate(rate);
1307 }
1308 );
1309 if (ret != RET_OK) {
1310 MMI_HILOGE("Get keyboard repeat rate failed, ret:%{public}d", ret);
1311 return ret;
1312 }
1313 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1314 return RET_OK;
1315 }
1316
1317 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
CheckAddInput(int32_t pid,InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags)1318 int32_t MMIService::CheckAddInput(int32_t pid, InputHandlerType handlerType, HandleEventType eventType,
1319 int32_t priority, uint32_t deviceTags)
1320 {
1321 auto sess = GetSessionByPid(pid);
1322 CHKPR(sess, ERROR_NULL_POINTER);
1323 return sMsgHandler_.OnAddInputHandler(sess, handlerType, eventType, priority, deviceTags);
1324 }
1325 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1326
AddInputHandler(InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags)1327 int32_t MMIService::AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority,
1328 uint32_t deviceTags)
1329 {
1330 CALL_INFO_TRACE;
1331 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
1332 int32_t pid = GetCallingPid();
1333 int32_t ret = delegateTasks_.PostSyncTask(
1334 [this, pid, handlerType, eventType, priority, deviceTags] {
1335 return this->CheckAddInput(pid, handlerType, eventType, priority, deviceTags);
1336 }
1337 );
1338 if (ret != RET_OK) {
1339 MMI_HILOGE("Add input handler failed, ret:%{public}d", ret);
1340 return ret;
1341 }
1342 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1343 OHOS::MMI::NapProcess::NapStatusData napData;
1344 napData.pid = GetCallingPid();
1345 napData.uid = GetCallingUid();
1346 auto sess = GetSessionByPid(pid);
1347 CHKPR(sess, ERROR_NULL_POINTER);
1348 napData.bundleName = sess->GetProgramName();
1349 int32_t syncState = SUBSCRIBED;
1350 MMI_HILOGD("AddInputHandler info to observer : pid:%{public}d, uid:%d, bundleName:%{public}s",
1351 napData.pid, napData.uid, napData.bundleName.c_str());
1352 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1353 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1354 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1355 }
1356 }
1357 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1358 return RET_OK;
1359 }
1360
1361 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
CheckRemoveInput(int32_t pid,InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags)1362 int32_t MMIService::CheckRemoveInput(int32_t pid, InputHandlerType handlerType, HandleEventType eventType,
1363 int32_t priority, uint32_t deviceTags)
1364 {
1365 auto sess = GetSessionByPid(pid);
1366 CHKPR(sess, ERROR_NULL_POINTER);
1367 return sMsgHandler_.OnRemoveInputHandler(sess, handlerType, eventType, priority, deviceTags);
1368 }
1369 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1370
RemoveInputHandler(InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags)1371 int32_t MMIService::RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority,
1372 uint32_t deviceTags)
1373 {
1374 CALL_INFO_TRACE;
1375 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
1376 int32_t pid = GetCallingPid();
1377 int32_t ret = delegateTasks_.PostSyncTask(
1378 [this, pid, handlerType, eventType, priority, deviceTags] {
1379 return this->CheckRemoveInput(pid, handlerType, eventType, priority, deviceTags);
1380 }
1381 );
1382 if (ret != RET_OK) {
1383 MMI_HILOGE("Remove input handler failed, ret:%{public}d", ret);
1384 return ret;
1385 }
1386 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1387 OHOS::MMI::NapProcess::NapStatusData napData;
1388 napData.pid = GetCallingPid();
1389 napData.uid = GetCallingUid();
1390 auto sess = GetSessionByPid(pid);
1391 CHKPR(sess, ERROR_NULL_POINTER);
1392 napData.bundleName = sess->GetProgramName();
1393 int32_t syncState = UNSUBSCRIBED;
1394 MMI_HILOGD("RemoveInputHandler info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1395 napData.pid, napData.uid, napData.bundleName.c_str());
1396 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1397 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1398 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1399 }
1400 }
1401 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1402 return RET_OK;
1403 }
1404
AddPreInputHandler(int32_t handlerId,HandleEventType eventType,std::vector<int32_t> keys)1405 int32_t MMIService::AddPreInputHandler(int32_t handlerId, HandleEventType eventType, std::vector<int32_t> keys)
1406 {
1407 CALL_DEBUG_ENTER;
1408 #ifdef OHOS_BUILD_ENABLE_MONITOR
1409 int32_t pid = GetCallingPid();
1410 int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId, eventType, keys] () -> int32_t {
1411 auto sess = GetSessionByPid(pid);
1412 CHKPR(sess, ERROR_NULL_POINTER);
1413 auto preMonitorHandler = InputHandler->GetEventPreMonitorHandler();
1414 CHKPR(preMonitorHandler, RET_ERR);
1415 return preMonitorHandler->AddInputHandler(sess, handlerId, eventType, keys);
1416 });
1417 if (ret != RET_OK) {
1418 MMI_HILOGE("The AddPreInputHandler key event processed failed, ret:%{public}d", ret);
1419 return ret;
1420 }
1421 #endif // OHOS_BUILD_ENABLE_MONITOR
1422 return RET_OK;
1423 }
1424
RemovePreInputHandler(int32_t handlerId)1425 int32_t MMIService::RemovePreInputHandler(int32_t handlerId)
1426 {
1427 CALL_DEBUG_ENTER;
1428 #ifdef OHOS_BUILD_ENABLE_MONITOR
1429 int32_t pid = GetCallingPid();
1430 int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId] () -> int32_t {
1431 auto sess = GetSessionByPid(pid);
1432 CHKPR(sess, ERROR_NULL_POINTER);
1433 auto preMonitorHandler = InputHandler->GetEventPreMonitorHandler();
1434 CHKPR(preMonitorHandler, RET_ERR);
1435 preMonitorHandler->RemoveInputHandler(sess, handlerId);
1436 return RET_OK;
1437 });
1438 if (ret != RET_OK) {
1439 MMI_HILOGE("Remove pre input handler failed, ret:%{public}d", ret);
1440 return ret;
1441 }
1442 #endif // OHOS_BUILD_ENABLE_MONITOR
1443 return RET_OK;
1444 }
1445
1446 #ifdef OHOS_BUILD_ENABLE_MONITOR
CheckMarkConsumed(int32_t pid,int32_t eventId)1447 int32_t MMIService::CheckMarkConsumed(int32_t pid, int32_t eventId)
1448 {
1449 auto sess = GetSessionByPid(pid);
1450 CHKPR(sess, ERROR_NULL_POINTER);
1451 return sMsgHandler_.OnMarkConsumed(sess, eventId);
1452 }
1453 #endif // OHOS_BUILD_ENABLE_MONITOR
1454
MarkEventConsumed(int32_t eventId)1455 int32_t MMIService::MarkEventConsumed(int32_t eventId)
1456 {
1457 CALL_DEBUG_ENTER;
1458 #ifdef OHOS_BUILD_ENABLE_MONITOR
1459 int32_t pid = GetCallingPid();
1460 int32_t ret = delegateTasks_.PostSyncTask(
1461 [this, pid, eventId] {
1462 return this->CheckMarkConsumed(pid, eventId);
1463 }
1464 );
1465 if (ret != RET_OK) {
1466 MMI_HILOGE("Mark event consumed failed, ret:%{public}d", ret);
1467 return ret;
1468 }
1469 #endif // OHOS_BUILD_ENABLE_MONITOR
1470 return RET_OK;
1471 }
1472
MoveMouseEvent(int32_t offsetX,int32_t offsetY)1473 int32_t MMIService::MoveMouseEvent(int32_t offsetX, int32_t offsetY)
1474 {
1475 CALL_DEBUG_ENTER;
1476 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1477 int32_t ret =
1478 delegateTasks_.PostSyncTask(
1479 [this, offsetX, offsetY] {
1480 return sMsgHandler_.OnMoveMouse(offsetX, offsetY);
1481 }
1482 );
1483 if (ret != RET_OK) {
1484 MMI_HILOGE("The movemouse event processed failed, ret:%{public}d", ret);
1485 return ret;
1486 }
1487 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1488 return RET_OK;
1489 }
1490
InjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent,bool isNativeInject)1491 int32_t MMIService::InjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent, bool isNativeInject)
1492 {
1493 CALL_DEBUG_ENTER;
1494 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1495 int32_t ret;
1496 int32_t pid = GetCallingPid();
1497 #ifdef OHOS_BUILD_ENABLE_ANCO
1498 ret = InjectKeyEventExt(keyEvent, pid, isNativeInject);
1499 #else
1500 ret = delegateTasks_.PostSyncTask(
1501 [this, keyEvent, pid, isNativeInject] {
1502 return this->CheckInjectKeyEvent(keyEvent, pid, isNativeInject);
1503 }
1504 );
1505 #endif // OHOS_BUILD_ENABLE_ANCO
1506 if (ret != RET_OK) {
1507 MMI_HILOGE("Inject key event failed, ret:%{public}d", ret);
1508 return ret;
1509 }
1510 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1511 return RET_OK;
1512 }
1513
CheckInjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent,int32_t pid,bool isNativeInject)1514 int32_t MMIService::CheckInjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent, int32_t pid, bool isNativeInject)
1515 {
1516 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1517 CHKPR(keyEvent, ERROR_NULL_POINTER);
1518 LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
1519 return sMsgHandler_.OnInjectKeyEvent(keyEvent, pid, isNativeInject);
1520 #else
1521 return RET_OK;
1522 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1523 }
1524
1525 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnGetKeyState(std::vector<int32_t> & pressedKeys,std::map<int32_t,int32_t> & specialKeysState)1526 int32_t MMIService::OnGetKeyState(std::vector<int32_t> &pressedKeys, std::map<int32_t, int32_t> &specialKeysState)
1527 {
1528 auto keyEvent = KeyEventHdr->GetKeyEvent();
1529 CHKPR(keyEvent, ERROR_NULL_POINTER);
1530 pressedKeys = keyEvent->GetPressedKeys();
1531 for (auto iter = pressedKeys.begin(); iter != pressedKeys.end();) {
1532 if (g_keyCodeValueSet.find(*iter) == g_keyCodeValueSet.end()) {
1533 iter = pressedKeys.erase(iter);
1534 continue;
1535 }
1536 ++iter;
1537 }
1538 specialKeysState[KeyEvent::KEYCODE_CAPS_LOCK] =
1539 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY));
1540 specialKeysState[KeyEvent::KEYCODE_SCROLL_LOCK] =
1541 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY));
1542 specialKeysState[KeyEvent::KEYCODE_NUM_LOCK] =
1543 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY));
1544 return RET_OK;
1545 }
1546 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1547
CheckInjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,int32_t pid,bool isNativeInject,bool isShell)1548 int32_t MMIService::CheckInjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,
1549 int32_t pid, bool isNativeInject, bool isShell)
1550 {
1551 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1552 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1553 LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
1554 return sMsgHandler_.OnInjectPointerEvent(pointerEvent, pid, isNativeInject, isShell);
1555 #else
1556 return RET_OK;
1557 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1558 }
1559
InjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,bool isNativeInject)1560 int32_t MMIService::InjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent, bool isNativeInject)
1561 {
1562 CALL_DEBUG_ENTER;
1563 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1564 int32_t ret;
1565 int32_t pid = GetCallingPid();
1566 bool isShell = PER_HELPER->RequestFromShell();
1567 #ifdef OHOS_BUILD_ENABLE_ANCO
1568 ret = InjectPointerEventExt(pointerEvent, pid, isNativeInject, isShell);
1569 #else
1570 ret = delegateTasks_.PostSyncTask(
1571 [this, pointerEvent, pid, isNativeInject, isShell] {
1572 return this->CheckInjectPointerEvent(pointerEvent, pid, isNativeInject, isShell);
1573 }
1574 );
1575 #endif // OHOS_BUILD_ENABLE_ANCO
1576 if (ret != RET_OK) {
1577 MMI_HILOGE("Inject pointer event failed, ret:%{public}d", ret);
1578 return ret;
1579 }
1580 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1581 return RET_OK;
1582 }
1583
1584 #ifdef OHOS_RSS_CLIENT
OnAddResSchedSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1585 void MMIService::OnAddResSchedSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1586 {
1587 int sleepSeconds = 1;
1588 sleep(sleepSeconds);
1589 uint64_t tid = tid_.load();
1590 int32_t userInteraction = 2;
1591 std::unordered_map<std::string, std::string> payload;
1592 payload["uid"] = std::to_string(getuid());
1593 payload["pid"] = std::to_string(getpid());
1594 payload["extType"] = "10002";
1595 payload["tid"] = std::to_string(tid);
1596 payload["isSa"] = "1";
1597 payload["cgroupPrio"] = "1";
1598 payload["threadName"] = "mmi_service";
1599 ResourceSchedule::ResSchedClient::GetInstance().ReportData(
1600 ResourceSchedule::ResType::RES_TYPE_KEY_PERF_SCENE, userInteraction, payload);
1601 }
1602 #endif // OHOS_RSS_CLIENT
1603
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1604 void MMIService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1605 {
1606 CALL_INFO_TRACE;
1607 MMI_HILOGI("systemAbilityId is %{public}d", systemAbilityId);
1608 #ifdef OHOS_RSS_CLIENT
1609 if (systemAbilityId == RES_SCHED_SYS_ABILITY_ID) {
1610 OnAddResSchedSystemAbility(systemAbilityId, deviceId);
1611 }
1612 #endif // OHOS_RSS_CLIENT
1613 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1614 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
1615 isCesStart_ = true;
1616 }
1617 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1618 if (systemAbilityId == APP_MGR_SERVICE_ID) {
1619 APP_OBSERVER_MGR->InitAppStateObserver();
1620 }
1621 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
1622 DEVICE_MONITOR->InitCommonEventSubscriber();
1623 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER)
1624 DISPLAY_MONITOR->InitCommonEventSubscriber();
1625 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1626 }
1627 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1628 if (systemAbilityId == RENDER_SERVICE) {
1629 IPointerDrawingManager::GetInstance()->InitPointerCallback();
1630 }
1631 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1632 if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) {
1633 WIN_MGR->SetFoldState();
1634 }
1635 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1636 if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) {
1637 if (SettingDataShare::GetInstance(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID).CheckIfSettingsDataReady()) {
1638 IPointerDrawingManager::GetInstance()->InitPointerObserver();
1639 }
1640 }
1641 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1642 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
1643 if (systemAbilityId == PLAYER_DISTRIBUTED_SERVICE_ID) {
1644 auto monitorHandler = InputHandler->GetMonitorHandler();
1645 CHKPV(monitorHandler);
1646 monitorHandler->RegisterScreenCaptureListener();
1647 }
1648 #endif
1649 }
1650
SubscribeKeyEvent(int32_t subscribeId,const std::shared_ptr<KeyOption> option)1651 int32_t MMIService::SubscribeKeyEvent(int32_t subscribeId, const std::shared_ptr<KeyOption> option)
1652 {
1653 CALL_DEBUG_ENTER;
1654 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1655 int32_t pid = GetCallingPid();
1656 int32_t ret = delegateTasks_.PostSyncTask(
1657 [this, pid, subscribeId, option] {
1658 return sMsgHandler_.OnSubscribeKeyEvent(this, pid, subscribeId, option);
1659 }
1660 );
1661 if (ret != RET_OK) {
1662 MMI_HILOGE("The subscribe key event processed failed, ret:%{public}d", ret);
1663 return ret;
1664 }
1665 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1666 OHOS::MMI::NapProcess::NapStatusData napData;
1667 napData.pid = GetCallingPid();
1668 napData.uid = GetCallingUid();
1669 auto sess = GetSessionByPid(pid);
1670 CHKPR(sess, ERROR_NULL_POINTER);
1671 napData.bundleName = sess->GetProgramName();
1672 int32_t syncState = SUBSCRIBED;
1673 MMI_HILOGD("SubscribeKeyEvent info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1674 napData.pid, napData.uid, napData.bundleName.c_str());
1675 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1676 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1677 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1678 }
1679 }
1680 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1681 return RET_OK;
1682 }
1683
UnsubscribeKeyEvent(int32_t subscribeId)1684 int32_t MMIService::UnsubscribeKeyEvent(int32_t subscribeId)
1685 {
1686 CALL_INFO_TRACE;
1687 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1688 int32_t pid = GetCallingPid();
1689 int32_t ret = delegateTasks_.PostSyncTask(
1690 [this, pid, subscribeId] {
1691 return sMsgHandler_.OnUnsubscribeKeyEvent(this, pid, subscribeId);
1692 }
1693 );
1694 if (ret != RET_OK) {
1695 MMI_HILOGE("The unsubscribe key event processed failed, ret:%{public}d", ret);
1696 return ret;
1697 }
1698 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1699 OHOS::MMI::NapProcess::NapStatusData napData;
1700 napData.pid = GetCallingPid();
1701 napData.uid = GetCallingUid();
1702 auto sess = GetSessionByPid(pid);
1703 CHKPR(sess, ERROR_NULL_POINTER);
1704 napData.bundleName = sess->GetProgramName();
1705 int32_t syncState = UNSUBSCRIBED;
1706 MMI_HILOGD("UnsubscribeKeyEvent info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1707 napData.pid, napData.uid, napData.bundleName.c_str());
1708 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1709 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1710 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1711 }
1712 }
1713 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1714 return RET_OK;
1715 }
1716
SubscribeSwitchEvent(int32_t subscribeId,int32_t switchType)1717 int32_t MMIService::SubscribeSwitchEvent(int32_t subscribeId, int32_t switchType)
1718 {
1719 CALL_INFO_TRACE;
1720 #ifdef OHOS_BUILD_ENABLE_SWITCH
1721 int32_t pid = GetCallingPid();
1722 int32_t ret = delegateTasks_.PostSyncTask(
1723 [this, pid, subscribeId, switchType] {
1724 return sMsgHandler_.OnSubscribeSwitchEvent(this, pid, subscribeId, switchType);
1725 }
1726 );
1727 if (ret != RET_OK) {
1728 MMI_HILOGE("The subscribe switch event processed failed, ret:%{public}d", ret);
1729 return ret;
1730 }
1731 #endif // OHOS_BUILD_ENABLE_SWITCH
1732 return RET_OK;
1733 }
1734
UnsubscribeSwitchEvent(int32_t subscribeId)1735 int32_t MMIService::UnsubscribeSwitchEvent(int32_t subscribeId)
1736 {
1737 CALL_INFO_TRACE;
1738 #ifdef OHOS_BUILD_ENABLE_SWITCH
1739 int32_t pid = GetCallingPid();
1740 int32_t ret = delegateTasks_.PostSyncTask(
1741 [this, pid, subscribeId] {
1742 return sMsgHandler_.OnUnsubscribeSwitchEvent(this, pid, subscribeId);
1743 }
1744 );
1745 if (ret != RET_OK) {
1746 MMI_HILOGE("The unsubscribe switch event processed failed, ret:%{public}d", ret);
1747 return ret;
1748 }
1749 #endif // OHOS_BUILD_ENABLE_SWITCH
1750 return RET_OK;
1751 }
1752
SetAnrObserver()1753 int32_t MMIService::SetAnrObserver()
1754 {
1755 CALL_INFO_TRACE;
1756 int32_t pid = GetCallingPid();
1757 int32_t ret = delegateTasks_.PostSyncTask(
1758 [pid] {
1759 return ::OHOS::DelayedSingleton<ANRManager>::GetInstance()->SetANRNoticedPid(pid);
1760 }
1761 );
1762 if (ret != RET_OK) {
1763 MMI_HILOGE("Set ANRNoticed pid failed, ret:%{public}d", ret);
1764 return ret;
1765 }
1766 return RET_OK;
1767 }
1768
GetDisplayBindInfo(DisplayBindInfos & infos)1769 int32_t MMIService::GetDisplayBindInfo(DisplayBindInfos &infos)
1770 {
1771 CALL_INFO_TRACE;
1772 int32_t ret = delegateTasks_.PostSyncTask(
1773 [&infos] {
1774 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->GetDisplayBindInfo(infos);
1775 }
1776 );
1777 if (ret != RET_OK) {
1778 MMI_HILOGE("GetDisplayBindInfo pid failed, ret:%{public}d", ret);
1779 return ret;
1780 }
1781 return RET_OK;
1782 }
1783
GetAllMmiSubscribedEvents(std::map<std::tuple<int32_t,int32_t,std::string>,int32_t> & datas)1784 int32_t MMIService::GetAllMmiSubscribedEvents(std::map<std::tuple<int32_t, int32_t, std::string>, int32_t> &datas)
1785 {
1786 CALL_INFO_TRACE;
1787 NapProcess::GetInstance()->GetAllMmiSubscribedEvents(datas);
1788 return RET_OK;
1789 }
1790
SetDisplayBind(int32_t deviceId,int32_t displayId,std::string & msg)1791 int32_t MMIService::SetDisplayBind(int32_t deviceId, int32_t displayId, std::string &msg)
1792 {
1793 CALL_INFO_TRACE;
1794 int32_t ret = delegateTasks_.PostSyncTask(
1795 [deviceId, displayId, &msg] {
1796 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetDisplayBind(deviceId, displayId, msg);
1797 }
1798 );
1799 if (ret != RET_OK) {
1800 MMI_HILOGE("SetDisplayBind pid failed, ret:%{public}d", ret);
1801 return ret;
1802 }
1803 return RET_OK;
1804 }
1805
GetFunctionKeyState(int32_t funcKey,bool & state)1806 int32_t MMIService::GetFunctionKeyState(int32_t funcKey, bool &state)
1807 {
1808 CALL_INFO_TRACE;
1809 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1810 int32_t ret = delegateTasks_.PostSyncTask(
1811 [this, funcKey, &state] {
1812 return sMsgHandler_.OnGetFunctionKeyState(funcKey, state);
1813 }
1814 );
1815 if (ret != RET_OK) {
1816 MMI_HILOGE("Failed to get the keyboard status, ret:%{public}d", ret);
1817 return ret;
1818 }
1819 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1820 return RET_OK;
1821 }
1822
SetFunctionKeyState(int32_t funcKey,bool enable)1823 int32_t MMIService::SetFunctionKeyState(int32_t funcKey, bool enable)
1824 {
1825 CALL_INFO_TRACE;
1826 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1827 int32_t clientPid = GetCallingPid();
1828 int32_t ret = delegateTasks_.PostSyncTask(
1829 [this, clientPid, funcKey, enable] {
1830 return sMsgHandler_.OnSetFunctionKeyState(clientPid, funcKey, enable);
1831 }
1832 );
1833 if (ret != RET_OK) {
1834 MMI_HILOGE("Failed to update the keyboard status, ret:%{public}d", ret);
1835 return ret;
1836 }
1837 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1838 return RET_OK;
1839 }
1840
SetPointerLocation(int32_t x,int32_t y)1841 int32_t MMIService::SetPointerLocation(int32_t x, int32_t y)
1842 {
1843 CALL_INFO_TRACE;
1844 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1845 int32_t ret = delegateTasks_.PostSyncTask(
1846 [x, y] {
1847 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetPointerLocation(x, y);
1848 }
1849 );
1850 if (ret != RET_OK) {
1851 MMI_HILOGE("Set pointer location failed, ret:%{public}d", ret);
1852 return ret;
1853 }
1854 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1855 return RET_OK;
1856 }
1857
OnDelegateTask(epoll_event & ev)1858 void MMIService::OnDelegateTask(epoll_event &ev)
1859 {
1860 if ((ev.events & EPOLLIN) == 0) {
1861 MMI_HILOGW("Not epollin");
1862 return;
1863 }
1864 DelegateTasks::TaskData data = {};
1865 auto res = read(delegateTasks_.GetReadFd(), &data, sizeof(data));
1866 if (res == -1) {
1867 MMI_HILOGW("Read failed erron:%{public}d", errno);
1868 }
1869 MMI_HILOGD("RemoteRequest notify td:%{public}" PRId64 ",std:%{public}" PRId64 ""
1870 ",taskId:%{public}d",
1871 GetThisThreadId(), data.tid, data.taskId);
1872 delegateTasks_.ProcessTasks();
1873 }
1874
OnThread()1875 void MMIService::OnThread()
1876 {
1877 SetThreadName(std::string("mmi_service"));
1878 uint64_t tid = GetThisThreadId();
1879 delegateTasks_.SetWorkerThreadId(tid);
1880 MMI_HILOGI("Main worker thread start. tid:%{public}" PRId64 "", tid);
1881 #ifdef OHOS_RSS_CLIENT
1882 tid_.store(tid);
1883 #endif
1884 libinputAdapter_.ProcessPendingEvents();
1885 while (state_ == ServiceRunningState::STATE_RUNNING) {
1886 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER) && defined(OHOS_BUILD_ENABLE_KEYBOARD)
1887 if (isCesStart_ && !DISPLAY_MONITOR->IsCommonEventSubscriberInit()) {
1888 DISPLAY_MONITOR->InitCommonEventSubscriber();
1889 }
1890 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER && OHOS_BUILD_ENABLE_KEYBOARD
1891 epoll_event ev[MAX_EVENT_SIZE] = {};
1892 int32_t timeout = TimerMgr->CalcNextDelay();
1893 MMI_HILOGD("timeout:%{public}d", timeout);
1894 int32_t count = EpollWait(ev[0], MAX_EVENT_SIZE, timeout, mmiFd_);
1895 for (int32_t i = 0; i < count && state_ == ServiceRunningState::STATE_RUNNING; i++) {
1896 auto mmiEdIter = epollEventMap_.find(ev[i].data.fd);
1897 if (mmiEdIter == epollEventMap_.end()) {
1898 MMI_HILOGW("Invalid event %{public}d %{public}d", ev[i].data.fd, count);
1899 continue;
1900 }
1901 std::shared_ptr<mmi_epoll_event> mmiEd = mmiEdIter->second;
1902 CHKPC(mmiEd);
1903 epoll_event event = ev[i];
1904 if (mmiEd->event_type == EPOLL_EVENT_INPUT) {
1905 CalculateFuntionRunningTime([this, &mmiEd] () { libinputAdapter_.EventDispatch(mmiEd->fd); },
1906 "EPOLL_EVENT_INPUT");
1907 } else if (mmiEd->event_type == EPOLL_EVENT_SOCKET) {
1908 CalculateFuntionRunningTime([this, &event]() { this->OnEpollEvent(event); }, "EPOLL_EVENT_SOCKET");
1909 } else if (mmiEd->event_type == EPOLL_EVENT_SIGNAL) {
1910 OnSignalEvent(mmiEd->fd);
1911 } else if (mmiEd->event_type == EPOLL_EVENT_ETASK) {
1912 CalculateFuntionRunningTime([this, &event]() { this->OnDelegateTask(event); }, "EPOLL_EVENT_ETASK");
1913 } else {
1914 MMI_HILOGW("Unknown epoll event type:%{public}d", mmiEd->event_type);
1915 }
1916 }
1917 TimerMgr->ProcessTimers();
1918 if (state_ != ServiceRunningState::STATE_RUNNING) {
1919 break;
1920 }
1921 }
1922 MMI_HILOGI("Main worker thread stop. tid:%{public}" PRId64 "", tid);
1923 }
1924
InitSignalHandler()1925 bool MMIService::InitSignalHandler()
1926 {
1927 CALL_DEBUG_ENTER;
1928 sigset_t mask = { 0 };
1929 int32_t retCode = sigfillset(&mask);
1930 if (retCode < 0) {
1931 MMI_HILOGE("Fill signal set failed:%{public}d", errno);
1932 return false;
1933 }
1934
1935 retCode = sigprocmask(SIG_SETMASK, &mask, nullptr);
1936 if (retCode < 0) {
1937 MMI_HILOGE("Sigprocmask failed:%{public}d", errno);
1938 return false;
1939 }
1940
1941 int32_t fdSignal = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
1942 if (fdSignal < 0) {
1943 MMI_HILOGE("Signal fd failed:%{public}d", errno);
1944 return false;
1945 }
1946
1947 retCode = AddEpoll(EPOLL_EVENT_SIGNAL, fdSignal);
1948 if (retCode < 0) {
1949 MMI_HILOGE("AddEpoll signalFd failed:%{public}d", retCode);
1950 close(fdSignal);
1951 return false;
1952 }
1953 return true;
1954 }
1955
OnSignalEvent(int32_t signalFd)1956 void MMIService::OnSignalEvent(int32_t signalFd)
1957 {
1958 CALL_DEBUG_ENTER;
1959 signalfd_siginfo sigInfo;
1960 int32_t size = ::read(signalFd, &sigInfo, sizeof(signalfd_siginfo));
1961 if (size != static_cast<int32_t>(sizeof(signalfd_siginfo))) {
1962 MMI_HILOGE("Read signal info failed, invalid size:%{public}d, errno:%{public}d", size, errno);
1963 return;
1964 }
1965 int32_t signo = static_cast<int32_t>(sigInfo.ssi_signo);
1966 MMI_HILOGD("Receive signal:%{public}d", signo);
1967 switch (signo) {
1968 case SIGINT:
1969 case SIGQUIT:
1970 case SIGILL:
1971 case SIGABRT:
1972 case SIGBUS:
1973 case SIGFPE:
1974 case SIGKILL:
1975 case SIGSEGV:
1976 case SIGTERM: {
1977 state_ = ServiceRunningState::STATE_EXIT;
1978 break;
1979 }
1980 default: {
1981 break;
1982 }
1983 }
1984 }
1985
AddReloadDeviceTimer()1986 void MMIService::AddReloadDeviceTimer()
1987 {
1988 CALL_DEBUG_ENTER;
1989 TimerMgr->AddTimer(RELOAD_DEVICE_TIME, REPEAT_COUNT, [this]() {
1990 auto deviceIds = INPUT_DEV_MGR->GetInputDeviceIds();
1991 if (deviceIds.empty()) {
1992 libinputAdapter_.ReloadDevice();
1993 }
1994 });
1995 }
1996
Dump(int32_t fd,const std::vector<std::u16string> & args)1997 int32_t MMIService::Dump(int32_t fd, const std::vector<std::u16string> &args)
1998 {
1999 CALL_DEBUG_ENTER;
2000 if (fd < 0) {
2001 MMI_HILOGE("The fd is invalid");
2002 return DUMP_PARAM_ERR;
2003 }
2004 if (args.empty()) {
2005 MMI_HILOGE("The args cannot be empty");
2006 mprintf(fd, "args cannot be empty\n");
2007 MMIEventDump->DumpHelp(fd);
2008 return DUMP_PARAM_ERR;
2009 }
2010 std::vector<std::string> argList = { "" };
2011 std::transform(args.begin(), args.end(), std::back_inserter(argList),
2012 [](const std::u16string &arg) { return Str16ToStr8(arg); });
2013 MMIEventDump->ParseCommand(fd, argList);
2014 return RET_OK;
2015 }
2016
SetMouseCaptureMode(int32_t windowId,bool isCaptureMode)2017 int32_t MMIService::SetMouseCaptureMode(int32_t windowId, bool isCaptureMode)
2018 {
2019 CALL_INFO_TRACE;
2020 int32_t ret = delegateTasks_.PostSyncTask(
2021 [windowId, isCaptureMode] {
2022 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetMouseCaptureMode(windowId, isCaptureMode);
2023 }
2024 );
2025 if (ret != RET_OK) {
2026 MMI_HILOGE("Set capture failed, return:%{public}d", ret);
2027 return ret;
2028 }
2029 return RET_OK;
2030 }
2031
OnGetWindowPid(int32_t windowId,int32_t & windowPid)2032 int32_t MMIService::OnGetWindowPid(int32_t windowId, int32_t &windowPid)
2033 {
2034 CALL_DEBUG_ENTER;
2035 windowPid = WIN_MGR->GetWindowPid(windowId);
2036 if (windowPid == RET_ERR) {
2037 MMI_HILOGE("Get window pid failed");
2038 return RET_ERR;
2039 }
2040 MMI_HILOGD("windowpid is %{public}d", windowPid);
2041 return RET_OK;
2042 }
2043
GetWindowPid(int32_t windowId)2044 int32_t MMIService::GetWindowPid(int32_t windowId)
2045 {
2046 CALL_INFO_TRACE;
2047 int32_t windowPid = INVALID_PID;
2048 int32_t ret = delegateTasks_.PostSyncTask(
2049 [this, windowId, &windowPid] {
2050 return this->OnGetWindowPid(windowId, windowPid);
2051 }
2052 );
2053 if (ret != RET_OK) {
2054 MMI_HILOGE("OnGetWindowPid failed, ret:%{public}d", ret);
2055 return ret;
2056 }
2057 MMI_HILOGD("windowpid is %{public}d", windowPid);
2058 return windowPid;
2059 }
2060
AppendExtraData(const ExtraData & extraData)2061 int32_t MMIService::AppendExtraData(const ExtraData &extraData)
2062 {
2063 CALL_DEBUG_ENTER;
2064 int32_t ret = delegateTasks_.PostSyncTask(
2065 [extraData] {
2066 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->AppendExtraData(extraData);
2067 }
2068 );
2069 if (ret != RET_OK) {
2070 MMI_HILOGE("Append extra data failed:%{public}d", ret);
2071 }
2072 return ret;
2073 }
2074
EnableInputDevice(bool enable)2075 int32_t MMIService::EnableInputDevice(bool enable)
2076 {
2077 CALL_DEBUG_ENTER;
2078 int32_t ret = delegateTasks_.PostSyncTask(
2079 [enable] {
2080 return ::OHOS::MMI::InputDeviceManager::GetInstance()->OnEnableInputDevice(enable);
2081 }
2082 );
2083 if (ret != RET_OK) {
2084 MMI_HILOGE("OnEnableInputDevice failed:%{public}d", ret);
2085 }
2086 return ret;
2087 }
2088
2089 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
UpdateCombineKeyState(bool enable)2090 int32_t MMIService::UpdateCombineKeyState(bool enable)
2091 {
2092 auto eventSubscriberHandler = InputHandler->GetSubscriberHandler();
2093 CHKPR(eventSubscriberHandler, RET_ERR);
2094 int32_t ret = eventSubscriberHandler->EnableCombineKey(enable);
2095 if (ret != RET_OK) {
2096 MMI_HILOGE("EnableCombineKey is failed in key command:%{public}d", ret);
2097 }
2098
2099 auto eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();
2100 CHKPR(eventKeyCommandHandler, RET_ERR);
2101 ret = eventKeyCommandHandler->EnableCombineKey(enable);
2102 if (ret != RET_OK) {
2103 MMI_HILOGE("EnableCombineKey is failed in key command:%{public}d", ret);
2104 }
2105 return ret;
2106 }
2107 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2108
CheckPidPermission(int32_t pid)2109 int32_t MMIService::CheckPidPermission(int32_t pid)
2110 {
2111 CALL_DEBUG_ENTER;
2112 int32_t checkingPid = GetCallingPid();
2113 if (checkingPid != pid) {
2114 MMI_HILOGE("check pid failed, input pid:%{public}d, but checking pid:%{public}d", pid, checkingPid);
2115 return RET_ERR;
2116 }
2117 return RET_OK;
2118 }
2119
EnableCombineKey(bool enable)2120 int32_t MMIService::EnableCombineKey(bool enable)
2121 {
2122 CALL_DEBUG_ENTER;
2123 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
2124 int32_t ret = delegateTasks_.PostSyncTask(
2125 [this, enable] {
2126 return this->UpdateCombineKeyState(enable);
2127 }
2128 );
2129 if (ret != RET_OK) {
2130 MMI_HILOGE("Set key down duration failed:%{public}d", ret);
2131 return ret;
2132 }
2133 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2134 return RET_OK;
2135 }
2136
2137 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
UpdateSettingsXml(const std::string & businessId,int32_t delay)2138 int32_t MMIService::UpdateSettingsXml(const std::string &businessId, int32_t delay)
2139 {
2140 std::shared_ptr<KeyCommandHandler> eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();
2141 CHKPR(eventKeyCommandHandler, RET_ERR);
2142 return eventKeyCommandHandler->UpdateSettingsXml(businessId, delay);
2143 }
2144 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2145
SetKeyDownDuration(const std::string & businessId,int32_t delay)2146 int32_t MMIService::SetKeyDownDuration(const std::string &businessId, int32_t delay)
2147 {
2148 CALL_INFO_TRACE;
2149 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
2150 int32_t ret = delegateTasks_.PostSyncTask(
2151 [this, businessId, delay] {
2152 return this->UpdateSettingsXml(businessId, delay);
2153 }
2154 );
2155 if (ret != RET_OK) {
2156 MMI_HILOGE("Set key down duration failed:%{public}d", ret);
2157 return ret;
2158 }
2159 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2160 return RET_OK;
2161 }
2162
2163 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadTouchpadScrollSwich(bool & switchFlag)2164 int32_t MMIService::ReadTouchpadScrollSwich(bool &switchFlag)
2165 {
2166 MouseEventHdr->GetTouchpadScrollSwitch(switchFlag);
2167 return RET_OK;
2168 }
2169
ReadTouchpadScrollDirection(bool & switchFlag)2170 int32_t MMIService::ReadTouchpadScrollDirection(bool &switchFlag)
2171 {
2172 MouseEventHdr->GetTouchpadScrollDirection(switchFlag);
2173 return RET_OK;
2174 }
2175
ReadTouchpadTapSwitch(bool & switchFlag)2176 int32_t MMIService::ReadTouchpadTapSwitch(bool &switchFlag)
2177 {
2178 MouseEventHdr->GetTouchpadTapSwitch(switchFlag);
2179 return RET_OK;
2180 }
2181
ReadTouchpadPointerSpeed(int32_t & speed)2182 int32_t MMIService::ReadTouchpadPointerSpeed(int32_t &speed)
2183 {
2184 MouseEventHdr->GetTouchpadPointerSpeed(speed);
2185 return RET_OK;
2186 }
2187
ReadTouchpadPinchSwitch(bool & switchFlag)2188 int32_t MMIService::ReadTouchpadPinchSwitch(bool &switchFlag)
2189 {
2190 TOUCH_EVENT_HDR->GetTouchpadPinchSwitch(switchFlag);
2191 return RET_OK;
2192 }
2193
ReadTouchpadSwipeSwitch(bool & switchFlag)2194 int32_t MMIService::ReadTouchpadSwipeSwitch(bool &switchFlag)
2195 {
2196 TOUCH_EVENT_HDR->GetTouchpadSwipeSwitch(switchFlag);
2197 return RET_OK;
2198 }
2199
ReadTouchpadRightMenuType(int32_t & type)2200 int32_t MMIService::ReadTouchpadRightMenuType(int32_t &type)
2201 {
2202 MouseEventHdr->GetTouchpadRightClickType(type);
2203 return RET_OK;
2204 }
2205
ReadTouchpadRotateSwitch(bool & rotateSwitch)2206 int32_t MMIService::ReadTouchpadRotateSwitch(bool &rotateSwitch)
2207 {
2208 TOUCH_EVENT_HDR->GetTouchpadRotateSwitch(rotateSwitch);
2209 return RET_OK;
2210 }
2211
ReadTouchpadDoubleTapAndDragState(bool & switchFlag)2212 int32_t MMIService::ReadTouchpadDoubleTapAndDragState(bool &switchFlag)
2213 {
2214 TOUCH_EVENT_HDR->GetTouchpadDoubleTapAndDragState(switchFlag);
2215 return RET_OK;
2216 }
2217
2218 #endif // OHOS_BUILD_ENABLE_POINTER
2219
SetTouchpadScrollSwitch(bool switchFlag)2220 int32_t MMIService::SetTouchpadScrollSwitch(bool switchFlag)
2221 {
2222 CALL_INFO_TRACE;
2223 #if defined OHOS_BUILD_ENABLE_POINTER
2224 int32_t ret = delegateTasks_.PostSyncTask(
2225 [switchFlag] {
2226 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadScrollSwitch(switchFlag);
2227 }
2228 );
2229 if (ret != RET_OK) {
2230 MMI_HILOGE("Set touchpad scroll switch failed, return:%{public}d", ret);
2231 return ret;
2232 }
2233 #endif // OHOS_BUILD_ENABLE_POINTER
2234 return RET_OK;
2235 }
2236
GetTouchpadScrollSwitch(bool & switchFlag)2237 int32_t MMIService::GetTouchpadScrollSwitch(bool &switchFlag)
2238 {
2239 CALL_INFO_TRACE;
2240 #ifdef OHOS_BUILD_ENABLE_POINTER
2241 int32_t ret = delegateTasks_.PostSyncTask(
2242 [this, &switchFlag] {
2243 return this->ReadTouchpadScrollSwich(switchFlag);
2244 }
2245 );
2246 if (ret != RET_OK) {
2247 MMI_HILOGE("Get touchpad scroll switch failed, return:%{public}d", ret);
2248 return ret;
2249 }
2250 #endif // OHOS_BUILD_ENABLE_POINTER
2251 return RET_OK;
2252 }
2253
SetTouchpadScrollDirection(bool state)2254 int32_t MMIService::SetTouchpadScrollDirection(bool state)
2255 {
2256 CALL_INFO_TRACE;
2257 #if defined OHOS_BUILD_ENABLE_POINTER
2258 int32_t ret = delegateTasks_.PostSyncTask(
2259 [state] {
2260 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadScrollDirection(state);
2261 }
2262 );
2263 if (ret != RET_OK) {
2264 MMI_HILOGE("Set touchpad scroll direction switch failed, return:%{public}d", ret);
2265 return ret;
2266 }
2267 #endif // OHOS_BUILD_ENABLE_POINTER
2268 return RET_OK;
2269 }
2270
GetTouchpadScrollDirection(bool & state)2271 int32_t MMIService::GetTouchpadScrollDirection(bool &state)
2272 {
2273 CALL_INFO_TRACE;
2274 #ifdef OHOS_BUILD_ENABLE_POINTER
2275 int32_t ret = delegateTasks_.PostSyncTask(
2276 [this, &state] {
2277 return this->ReadTouchpadScrollDirection(state);
2278 }
2279 );
2280 if (ret != RET_OK) {
2281 MMI_HILOGE("Get touchpad scroll direction switch failed, return:%{public}d", ret);
2282 return ret;
2283 }
2284 #endif // OHOS_BUILD_ENABLE_POINTER
2285 return RET_OK;
2286 }
2287
SetTouchpadTapSwitch(bool switchFlag)2288 int32_t MMIService::SetTouchpadTapSwitch(bool switchFlag)
2289 {
2290 CALL_INFO_TRACE;
2291 #if defined OHOS_BUILD_ENABLE_POINTER
2292 int32_t ret = delegateTasks_.PostSyncTask(
2293 [switchFlag] {
2294 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadTapSwitch(switchFlag);
2295 }
2296 );
2297 if (ret != RET_OK) {
2298 MMI_HILOGE("Set touchpad tap switch failed, return:%{public}d", ret);
2299 return ret;
2300 }
2301 #endif // OHOS_BUILD_ENABLE_POINTER
2302 return RET_OK;
2303 }
2304
GetTouchpadTapSwitch(bool & switchFlag)2305 int32_t MMIService::GetTouchpadTapSwitch(bool &switchFlag)
2306 {
2307 CALL_INFO_TRACE;
2308 #ifdef OHOS_BUILD_ENABLE_POINTER
2309 int32_t ret = delegateTasks_.PostSyncTask(
2310 [this, &switchFlag] {
2311 return this->ReadTouchpadTapSwitch(switchFlag);
2312 }
2313 );
2314 if (ret != RET_OK) {
2315 MMI_HILOGE("Get touchpad tap switch failed, return:%{public}d", ret);
2316 return ret;
2317 }
2318 #endif // OHOS_BUILD_ENABLE_POINTER
2319 return RET_OK;
2320 }
2321
SetTouchpadPointerSpeed(int32_t speed)2322 int32_t MMIService::SetTouchpadPointerSpeed(int32_t speed)
2323 {
2324 CALL_INFO_TRACE;
2325 #if defined OHOS_BUILD_ENABLE_POINTER
2326 int32_t ret = delegateTasks_.PostSyncTask(
2327 [speed] {
2328 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadPointerSpeed(speed);
2329 }
2330 );
2331 if (ret != RET_OK) {
2332 MMI_HILOGE("Set touchpad speed failed, return:%{public}d", ret);
2333 return ret;
2334 }
2335 #endif // OHOS_BUILD_ENABLE_POINTER
2336 return RET_OK;
2337 }
2338
GetTouchpadPointerSpeed(int32_t & speed)2339 int32_t MMIService::GetTouchpadPointerSpeed(int32_t &speed)
2340 {
2341 CALL_INFO_TRACE;
2342 #ifdef OHOS_BUILD_ENABLE_POINTER
2343 int32_t ret = delegateTasks_.PostSyncTask(
2344 [this, &speed] {
2345 return this->ReadTouchpadPointerSpeed(speed);
2346 }
2347 );
2348 if (ret != RET_OK) {
2349 MMI_HILOGE("Get touchpad speed failed, return:%{public}d", ret);
2350 return ret;
2351 }
2352 #endif // OHOS_BUILD_ENABLE_POINTER
2353 return RET_OK;
2354 }
2355
SetTouchpadPinchSwitch(bool switchFlag)2356 int32_t MMIService::SetTouchpadPinchSwitch(bool switchFlag)
2357 {
2358 CALL_INFO_TRACE;
2359 #if defined OHOS_BUILD_ENABLE_POINTER
2360 int32_t ret = delegateTasks_.PostSyncTask(
2361 [switchFlag] {
2362 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadPinchSwitch(switchFlag);
2363 }
2364 );
2365 if (ret != RET_OK) {
2366 MMI_HILOGE("Set touch pad pinch switch failed, return:%{public}d", ret);
2367 return ret;
2368 }
2369 #endif // OHOS_BUILD_ENABLE_POINTER
2370 return RET_OK;
2371 }
2372
GetTouchpadPinchSwitch(bool & switchFlag)2373 int32_t MMIService::GetTouchpadPinchSwitch(bool &switchFlag)
2374 {
2375 CALL_INFO_TRACE;
2376 #ifdef OHOS_BUILD_ENABLE_POINTER
2377 int32_t ret = delegateTasks_.PostSyncTask(
2378 [this, &switchFlag] {
2379 return this->ReadTouchpadPinchSwitch(switchFlag);
2380 }
2381 );
2382 if (ret != RET_OK) {
2383 MMI_HILOGE("Get touch pad pinch switch failed, return:%{public}d", ret);
2384 return ret;
2385 }
2386 #endif // OHOS_BUILD_ENABLE_POINTER
2387 return RET_OK;
2388 }
2389
SetTouchpadSwipeSwitch(bool switchFlag)2390 int32_t MMIService::SetTouchpadSwipeSwitch(bool switchFlag)
2391 {
2392 CALL_INFO_TRACE;
2393 #if defined OHOS_BUILD_ENABLE_POINTER
2394 int32_t ret = delegateTasks_.PostSyncTask(
2395 [switchFlag] {
2396 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadSwipeSwitch(switchFlag);
2397 }
2398 );
2399 if (ret != RET_OK) {
2400 MMI_HILOGE("Set touchpad swipe switch failed, return:%{public}d", ret);
2401 return ret;
2402 }
2403 #endif // OHOS_BUILD_ENABLE_POINTER
2404 return RET_OK;
2405 }
2406
GetTouchpadSwipeSwitch(bool & switchFlag)2407 int32_t MMIService::GetTouchpadSwipeSwitch(bool &switchFlag)
2408 {
2409 CALL_INFO_TRACE;
2410 #ifdef OHOS_BUILD_ENABLE_POINTER
2411 int32_t ret = delegateTasks_.PostSyncTask(
2412 [this, &switchFlag] {
2413 return this->ReadTouchpadSwipeSwitch(switchFlag);
2414 }
2415 );
2416 if (ret != RET_OK) {
2417 MMI_HILOGE("Get touchpad swipe switch failed, return:%{public}d", ret);
2418 return ret;
2419 }
2420 #endif // OHOS_BUILD_ENABLE_POINTER
2421 return RET_OK;
2422 }
2423
SetTouchpadRightClickType(int32_t type)2424 int32_t MMIService::SetTouchpadRightClickType(int32_t type)
2425 {
2426 CALL_INFO_TRACE;
2427 #if defined OHOS_BUILD_ENABLE_POINTER
2428 int32_t ret = delegateTasks_.PostSyncTask(
2429 [type] {
2430 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadRightClickType(type);
2431 }
2432 );
2433 if (ret != RET_OK) {
2434 MMI_HILOGE("Set touchpad right button menu type failed, return:%{public}d", ret);
2435 return ret;
2436 }
2437 #endif // OHOS_BUILD_ENABLE_POINTER
2438 return RET_OK;
2439 }
2440
GetTouchpadRightClickType(int32_t & type)2441 int32_t MMIService::GetTouchpadRightClickType(int32_t &type)
2442 {
2443 CALL_INFO_TRACE;
2444 #ifdef OHOS_BUILD_ENABLE_POINTER
2445 int32_t ret = delegateTasks_.PostSyncTask(
2446 [this, &type] {
2447 return this->ReadTouchpadRightMenuType(type);
2448 }
2449 );
2450 if (ret != RET_OK) {
2451 MMI_HILOGE("Get touchpad right button menu type failed, return:%{public}d", ret);
2452 return ret;
2453 }
2454 #endif // OHOS_BUILD_ENABLE_POINTER
2455 return RET_OK;
2456 }
2457
SetTouchpadRotateSwitch(bool rotateSwitch)2458 int32_t MMIService::SetTouchpadRotateSwitch(bool rotateSwitch)
2459 {
2460 CALL_INFO_TRACE;
2461 #if defined OHOS_BUILD_ENABLE_POINTER
2462 int32_t ret = delegateTasks_.PostSyncTask(
2463 [rotateSwitch] {
2464 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadRotateSwitch(rotateSwitch);
2465 }
2466 );
2467 if (ret != RET_OK) {
2468 MMI_HILOGE("Set touchpad rotate switch failed, ret:%{public}d", ret);
2469 return ret;
2470 }
2471 #endif // OHOS_BUILD_ENABLE_POINTER
2472 return RET_OK;
2473 }
2474
GetTouchpadRotateSwitch(bool & rotateSwitch)2475 int32_t MMIService::GetTouchpadRotateSwitch(bool &rotateSwitch)
2476 {
2477 CALL_INFO_TRACE;
2478 #ifdef OHOS_BUILD_ENABLE_POINTER
2479 int32_t ret = delegateTasks_.PostSyncTask(
2480 [this, &rotateSwitch] {
2481 return this->ReadTouchpadRotateSwitch(rotateSwitch);
2482 }
2483 );
2484 if (ret != RET_OK) {
2485 MMI_HILOGE("Get touchpad rotate switch failed, ret:%{public}d", ret);
2486 return RET_ERR;
2487 }
2488 #endif // OHOS_BUILD_ENABLE_POINTER
2489 return RET_OK;
2490 }
2491
SetTouchpadDoubleTapAndDragState(bool switchFlag)2492 int32_t MMIService::SetTouchpadDoubleTapAndDragState(bool switchFlag)
2493 {
2494 CALL_INFO_TRACE;
2495 #ifdef OHOS_BUILD_ENABLE_POINTER
2496 int32_t ret = delegateTasks_.PostSyncTask(
2497 [switchFlag] {
2498 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadDoubleTapAndDragState(
2499 switchFlag);
2500 }
2501 );
2502 if (ret != RET_OK) {
2503 MMI_HILOGE("Failed to SetTouchpadDoubleTapAndDragState status, ret:%{public}d", ret);
2504 return ret;
2505 }
2506 #endif // OHOS_BUILD_ENABLE_POINTER
2507 return RET_OK;
2508 }
2509
GetTouchpadDoubleTapAndDragState(bool & switchFlag)2510 int32_t MMIService::GetTouchpadDoubleTapAndDragState(bool &switchFlag)
2511 {
2512 CALL_INFO_TRACE;
2513 #ifdef OHOS_BUILD_ENABLE_POINTER
2514 int32_t ret = delegateTasks_.PostSyncTask(
2515 [this, &switchFlag] {
2516 return this->ReadTouchpadDoubleTapAndDragState(switchFlag);
2517 }
2518 );
2519 if (ret != RET_OK) {
2520 MMI_HILOGE("Failed to GetTouchpadDoubleTapAndDragState status, ret:%{public}d", ret);
2521 return ret;
2522 }
2523 #endif // OHOS_BUILD_ENABLE_POINTER
2524 return RET_OK;
2525 }
2526
SetShieldStatus(int32_t shieldMode,bool isShield)2527 int32_t MMIService::SetShieldStatus(int32_t shieldMode, bool isShield)
2528 {
2529 CALL_INFO_TRACE;
2530 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2531 int32_t ret = delegateTasks_.PostSyncTask(
2532 [this, shieldMode, isShield] {
2533 return sMsgHandler_.SetShieldStatus(shieldMode, isShield);
2534 }
2535 );
2536 if (ret != RET_OK) {
2537 MMI_HILOGE("Set shield event interception state failed, return %{public}d", ret);
2538 return ret;
2539 }
2540 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2541 return RET_OK;
2542 }
2543
GetShieldStatus(int32_t shieldMode,bool & isShield)2544 int32_t MMIService::GetShieldStatus(int32_t shieldMode, bool &isShield)
2545 {
2546 CALL_INFO_TRACE;
2547 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2548 int32_t ret = delegateTasks_.PostSyncTask(
2549 [this, shieldMode, &isShield] {
2550 return sMsgHandler_.GetShieldStatus(shieldMode, isShield);
2551 }
2552 );
2553 if (ret != RET_OK) {
2554 MMI_HILOGE("Failed to set shield event interception status, ret:%{public}d", ret);
2555 return ret;
2556 }
2557 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2558 return RET_OK;
2559 }
2560
GetKeyState(std::vector<int32_t> & pressedKeys,std::map<int32_t,int32_t> & specialKeysState)2561 int32_t MMIService::GetKeyState(std::vector<int32_t> &pressedKeys, std::map<int32_t, int32_t> &specialKeysState)
2562 {
2563 CALL_DEBUG_ENTER;
2564 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2565 int32_t ret = delegateTasks_.PostSyncTask(
2566 [this, &pressedKeys, &specialKeysState] {
2567 return this->OnGetKeyState(pressedKeys, specialKeysState);
2568 }
2569 );
2570 if (ret != RET_OK) {
2571 MMI_HILOGE("Get pressed keys failed, return:%{public}d", ret);
2572 return ret;
2573 }
2574 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2575 return RET_OK;
2576 }
2577
Authorize(bool isAuthorize)2578 int32_t MMIService::Authorize(bool isAuthorize)
2579 {
2580 CALL_DEBUG_ENTER;
2581 int32_t ret = delegateTasks_.PostSyncTask(
2582 [this, isAuthorize] {
2583 return this->OnAuthorize(isAuthorize);
2584 }
2585 );
2586 if (ret != RET_OK) {
2587 MMI_HILOGE("OnAuthorize failed, ret:%{public}d", ret);
2588 return ret;
2589 }
2590 return RET_OK;
2591 }
2592
OnAuthorize(bool isAuthorize)2593 int32_t MMIService::OnAuthorize(bool isAuthorize)
2594 {
2595 return sMsgHandler_.OnAuthorize(isAuthorize);
2596 }
2597
CancelInjection()2598 int32_t MMIService::CancelInjection()
2599 {
2600 CALL_DEBUG_ENTER;
2601 int32_t callPid = GetCallingPid();
2602 int32_t ret = delegateTasks_.PostSyncTask(
2603 [this, callPid] {
2604 return this->OnCancelInjection(callPid);
2605 }
2606 );
2607 if (ret != RET_OK) {
2608 MMI_HILOGE("OnCancelInjection failed, ret:%{public}d", ret);
2609 return ret;
2610 }
2611 return RET_OK;
2612 }
2613
OnCancelInjection(int32_t callPid)2614 int32_t MMIService::OnCancelInjection(int32_t callPid)
2615 {
2616 return sMsgHandler_.OnCancelInjection(callPid);
2617 }
2618
HasIrEmitter(bool & hasIrEmitter)2619 int32_t MMIService::HasIrEmitter(bool &hasIrEmitter)
2620 {
2621 CALL_DEBUG_ENTER;
2622 int32_t ret = delegateTasks_.PostSyncTask(
2623 [this, &hasIrEmitter] {
2624 return this->OnHasIrEmitter(hasIrEmitter);
2625 }
2626 );
2627 if (ret != RET_OK) {
2628 MMI_HILOGE("OnHasIrEmitter failed, ret:%{public}d", ret);
2629 return ret;
2630 }
2631 return RET_OK;
2632 }
2633
GetInfraredFrequencies(std::vector<InfraredFrequency> & requencys)2634 int32_t MMIService::GetInfraredFrequencies(std::vector<InfraredFrequency>& requencys)
2635 {
2636 CALL_DEBUG_ENTER;
2637 int32_t ret = delegateTasks_.PostSyncTask(
2638 [this, &requencys] {
2639 return this->OnGetInfraredFrequencies(requencys);
2640 }
2641 );
2642 if (ret != RET_OK) {
2643 MMI_HILOGE("OnGetInfraredFrequencies failed, returnCode:%{public}d", ret);
2644 return ret;
2645 }
2646 return RET_OK;
2647 }
2648
TransmitInfrared(int64_t number,std::vector<int64_t> & pattern)2649 int32_t MMIService::TransmitInfrared(int64_t number, std::vector<int64_t>& pattern)
2650 {
2651 CALL_DEBUG_ENTER;
2652 int32_t ret = delegateTasks_.PostSyncTask(
2653 [this, number, &pattern] {
2654 return this->OnTransmitInfrared(number, pattern);
2655 }
2656 );
2657 if (ret != RET_OK) {
2658 MMI_HILOGE("OnTransmitInfrared failed, returnCode:%{public}d", ret);
2659 return ret;
2660 }
2661 return RET_OK;
2662 }
2663
OnHasIrEmitter(bool & hasIrEmitter)2664 int32_t MMIService::OnHasIrEmitter(bool &hasIrEmitter)
2665 {
2666 hasIrEmitter = false;
2667 return RET_OK;
2668 }
2669
OnGetInfraredFrequencies(std::vector<InfraredFrequency> & frequencies)2670 int32_t MMIService::OnGetInfraredFrequencies(std::vector<InfraredFrequency> &frequencies)
2671 {
2672 MMI_HILOGI("start get infrared frequency");
2673 std::vector<InfraredFrequencyInfo> infos;
2674 InfraredEmitterController::GetInstance()->GetFrequencies(infos);
2675 for (auto &item : infos) {
2676 InfraredFrequency info;
2677 info.min_ = item.min_;
2678 info.max_ = item.max_;
2679 frequencies.push_back(info);
2680 }
2681 std::string context = "";
2682 int32_t size = static_cast<int32_t>(frequencies.size());
2683 for (int32_t i = 0; i < size; i++) {
2684 context = context + "frequencies[" + std::to_string(i) + "]. max=" + std::to_string(frequencies[i].max_) +
2685 ",min=" + std::to_string(frequencies[i].min_) + ";";
2686 }
2687 MMI_HILOGD("data from hdf context:%{public}s", context.c_str());
2688 return RET_OK;
2689 }
2690
OnTransmitInfrared(int64_t infraredFrequency,std::vector<int64_t> & pattern)2691 int32_t MMIService::OnTransmitInfrared(int64_t infraredFrequency, std::vector<int64_t> &pattern)
2692 {
2693 std::string context = "infraredFrequency:" + std::to_string(infraredFrequency) + ";";
2694 int32_t size = static_cast<int32_t>(pattern.size());
2695 for (int32_t i = 0; i < size; i++) {
2696 context = context + "index:" + std::to_string(i) + ": pattern:" + std::to_string(pattern[i]) + ";";
2697 }
2698 InfraredEmitterController::GetInstance()->Transmit(infraredFrequency, pattern);
2699 MMI_HILOGI("TransmitInfrared para context:%{public}s", context.c_str());
2700 return RET_OK;
2701 }
2702
SetPixelMapData(int32_t infoId,void * pixelMap)2703 int32_t MMIService::SetPixelMapData(int32_t infoId, void* pixelMap)
2704 {
2705 CALL_DEBUG_ENTER;
2706 CHKPR(pixelMap, ERROR_NULL_POINTER);
2707 int32_t ret = delegateTasks_.PostSyncTask(
2708 [this, infoId, pixelMap] {
2709 return sMsgHandler_.SetPixelMapData(infoId, pixelMap);
2710 }
2711 );
2712 if (ret != RET_OK) {
2713 MMI_HILOGE("Failed to set pixelmap, ret:%{public}d", ret);
2714 return ret;
2715 }
2716 return RET_OK;
2717 }
2718
SetCurrentUser(int32_t userId)2719 int32_t MMIService::SetCurrentUser(int32_t userId)
2720 {
2721 CALL_DEBUG_ENTER;
2722 int32_t ret = delegateTasks_.PostSyncTask(
2723 [userId] {
2724 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetCurrentUser(userId);
2725 }
2726 );
2727 if (ret != RET_OK) {
2728 MMI_HILOGE("Failed to set current user, ret:%{public}d", ret);
2729 return ret;
2730 }
2731 return RET_OK;
2732 }
2733
AddVirtualInputDevice(std::shared_ptr<InputDevice> device,int32_t & deviceId)2734 int32_t MMIService::AddVirtualInputDevice(std::shared_ptr<InputDevice> device, int32_t &deviceId)
2735 {
2736 CALL_DEBUG_ENTER;
2737 CHKPR(device, ERROR_NULL_POINTER);
2738 int32_t ret = delegateTasks_.PostSyncTask(
2739 [device, &deviceId] {
2740 return ::OHOS::MMI::InputDeviceManager::GetInstance()->AddVirtualInputDevice(device, deviceId);
2741 }
2742 );
2743 if (ret != RET_OK) {
2744 MMI_HILOGE("AddVirtualInputDevice failed:%{public}d", ret);
2745 }
2746 return ret;
2747 }
2748
RemoveVirtualInputDevice(int32_t deviceId)2749 int32_t MMIService::RemoveVirtualInputDevice(int32_t deviceId)
2750 {
2751 CALL_DEBUG_ENTER;
2752 int32_t ret = delegateTasks_.PostSyncTask(
2753 [deviceId] {
2754 return ::OHOS::MMI::InputDeviceManager::GetInstance()->RemoveVirtualInputDevice(deviceId);
2755 }
2756 );
2757 if (ret != RET_OK) {
2758 MMI_HILOGE("RemoveVirtualInputDevice failed:%{public}d", ret);
2759 }
2760 return ret;
2761 }
2762
EnableHardwareCursorStats(bool enable)2763 int32_t MMIService::EnableHardwareCursorStats(bool enable)
2764 {
2765 CALL_DEBUG_ENTER;
2766 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
2767 int32_t pid = GetCallingPid();
2768 int32_t ret = delegateTasks_.PostSyncTask(
2769 [pid, enable] {
2770 return IPointerDrawingManager::GetInstance()->EnableHardwareCursorStats(pid, enable);
2771 }
2772 );
2773 if (ret != RET_OK) {
2774 MMI_HILOGE("Enable hardware cursor stats failed, ret:%{public}d", ret);
2775 return ret;
2776 }
2777 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
2778 return RET_OK;
2779 }
2780
GetHardwareCursorStats(uint32_t & frameCount,uint32_t & vsyncCount)2781 int32_t MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsyncCount)
2782 {
2783 CALL_DEBUG_ENTER;
2784 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
2785 int32_t pid = GetCallingPid();
2786 int32_t ret = delegateTasks_.PostSyncTask(
2787 [pid, &frameCount, &vsyncCount] {
2788 return IPointerDrawingManager::GetInstance()->GetHardwareCursorStats(pid, frameCount, vsyncCount);
2789 }
2790 );
2791 if (ret != RET_OK) {
2792 MMI_HILOGE("Get hardware cursor stats failed, ret:%{public}d", ret);
2793 return ret;
2794 }
2795 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
2796 return RET_OK;
2797 }
2798
2799 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
GetPointerSnapshot(void * pixelMapPtr)2800 int32_t MMIService::GetPointerSnapshot(void *pixelMapPtr)
2801 {
2802 CALL_INFO_TRACE;
2803 #if defined OHOS_BUILD_ENABLE_POINTER
2804 MMI_HILOGI("Get pointer snapshot from process(%{public}d)", GetCallingPid());
2805 int32_t ret = delegateTasks_.PostSyncTask(std::bind(
2806 std::bind(&IPointerDrawingManager::GetPointerSnapshot, IPointerDrawingManager::GetInstance(), pixelMapPtr)));
2807 if (ret != RET_OK) {
2808 MMI_HILOGE("Get the pointer snapshot failed, ret: %{public}d", ret);
2809 return ret;
2810 }
2811 #endif // OHOS_BUILD_ENABLE_POINTER
2812 return RET_OK;
2813 }
2814 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
2815
2816 #ifdef OHOS_BUILD_ENABLE_ANCO
AncoAddChannel(sptr<IAncoChannel> channel)2817 int32_t MMIService::AncoAddChannel(sptr<IAncoChannel> channel)
2818 {
2819 int32_t ret = delegateTasks_.PostSyncTask([channel]() {
2820 return WIN_MGR->AncoAddChannel(channel);
2821 });
2822 if (ret != RET_OK) {
2823 MMI_HILOGE("AncoAddChannel fail, error:%{public}d", ret);
2824 }
2825 return ret;
2826 }
2827
AncoRemoveChannel(sptr<IAncoChannel> channel)2828 int32_t MMIService::AncoRemoveChannel(sptr<IAncoChannel> channel)
2829 {
2830 int32_t ret = delegateTasks_.PostSyncTask([channel]() {
2831 return WIN_MGR->AncoRemoveChannel(channel);
2832 });
2833 if (ret != RET_OK) {
2834 MMI_HILOGE("AncoRemoveChannel fail, error:%{public}d", ret);
2835 }
2836 return ret;
2837 }
2838 #endif // OHOS_BUILD_ENABLE_ANCO
2839
TransferBinderClientSrv(const sptr<IRemoteObject> & binderClientObject)2840 int32_t MMIService::TransferBinderClientSrv(const sptr<IRemoteObject> &binderClientObject)
2841 {
2842 CALL_DEBUG_ENTER;
2843 int32_t pid = GetCallingPid();
2844 int32_t ret =
2845 delegateTasks_.PostSyncTask(
2846 [this, pid, binderClientObject] {
2847 return sMsgHandler_.OnTransferBinderClientSrv(binderClientObject, pid);
2848 }
2849 );
2850 MMI_HILOGI("TransferBinderClientSrv result:%{public}d", ret);
2851 return ret;
2852 }
2853
CalculateFuntionRunningTime(std::function<void ()> func,const std::string & flag)2854 void MMIService::CalculateFuntionRunningTime(std::function<void()> func, const std::string &flag)
2855 {
2856 std::function<void (void *)> printLog = std::bind(&MMIService::PrintLog, this, flag, THREAD_BLOCK_TIMER_SPAN_S,
2857 getpid(), gettid());
2858 int32_t id = HiviewDFX::XCollie::GetInstance().SetTimer(flag, THREAD_BLOCK_TIMER_SPAN_S, printLog, nullptr,
2859 HiviewDFX::XCOLLIE_FLAG_NOOP);
2860 func();
2861 HiviewDFX::XCollie::GetInstance().CancelTimer(id);
2862 }
2863
PrintLog(const std::string & flag,int32_t duration,int32_t pid,int32_t tid)2864 void MMIService::PrintLog(const std::string &flag, int32_t duration, int32_t pid, int32_t tid)
2865 {
2866 std::string dfxThreadBlockMsg { "MMIBlockTask name:" };
2867 dfxThreadBlockMsg += flag;
2868 dfxThreadBlockMsg += ", duration time:";
2869 dfxThreadBlockMsg += std::to_string(duration);
2870 dfxThreadBlockMsg += ", pid:";
2871 dfxThreadBlockMsg += std::to_string(pid);
2872 dfxThreadBlockMsg += ", tid:";
2873 dfxThreadBlockMsg += std::to_string(tid);
2874 MMI_HILOGW("DfxThreadBlockMsg:%{public}s", dfxThreadBlockMsg.c_str());
2875 OHOS::HiviewDFX::DfxDumpCatcher dumpCatcher;
2876 dumpCatcher.DumpCatch(pid, tid, dfxThreadBlockMsg, MAX_FRAME_NUMS, false);
2877 }
2878
SkipPointerLayer(bool isSkip)2879 int32_t MMIService::SkipPointerLayer(bool isSkip)
2880 {
2881 CALL_INFO_TRACE;
2882 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
2883 int32_t ret = delegateTasks_.PostSyncTask(
2884 [isSkip] {
2885 return IPointerDrawingManager::GetInstance()->SkipPointerLayer(isSkip);
2886 }
2887 );
2888 if (ret != RET_OK) {
2889 MMI_HILOGE("Skip pointer layerfailed, return:%{public}d", ret);
2890 return ret;
2891 }
2892 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
2893 return RET_OK;
2894 }
2895
GetIntervalSinceLastInput(int64_t & timeInterval)2896 int32_t MMIService::GetIntervalSinceLastInput(int64_t &timeInterval)
2897 {
2898 CALL_INFO_TRACE;
2899 int32_t ret = delegateTasks_.PostSyncTask(std::bind(&InputEventHandler::GetIntervalSinceLastInput,
2900 InputHandler, std::ref(timeInterval)));
2901 MMI_HILOGD("timeInterval:%{public}" PRId64, timeInterval);
2902 if (ret != RET_OK) {
2903 MMI_HILOGE("Failed to GetIntervalSinceLastInput, ret:%{public}d", ret);
2904 }
2905 return ret;
2906 }
2907
SetCustomCursor(int32_t windowId,CustomCursor cursor,CursorOptions options)2908 int32_t MMIService::SetCustomCursor(int32_t windowId, CustomCursor cursor, CursorOptions options)
2909 {
2910 CALL_INFO_TRACE;
2911 #if defined OHOS_BUILD_ENABLE_POINTER
2912 int32_t pid = GetCallingPid();
2913 int32_t ret = delegateTasks_.PostSyncTask(std::bind(
2914 [pid, windowId, cursor, options] {
2915 return IPointerDrawingManager::GetInstance()->SetCustomCursor(pid, windowId, cursor, options);
2916 }
2917 ));
2918 if (ret != RET_OK) {
2919 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
2920 return ret;
2921 }
2922 #endif // OHOS_BUILD_ENABLE_POINTER
2923 return RET_OK;
2924 }
2925
ShiftAppPointerEvent(const ShiftWindowParam & param,bool autoGenDown)2926 int32_t MMIService::ShiftAppPointerEvent(const ShiftWindowParam ¶m, bool autoGenDown)
2927 {
2928 CALL_DEBUG_ENTER;
2929 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
2930 int32_t ret = delegateTasks_.PostSyncTask(
2931 [param, autoGenDown]() {
2932 return WIN_MGR->ShiftAppPointerEvent(param, autoGenDown);
2933 }
2934 );
2935 if (ret != RET_OK) {
2936 MMI_HILOGE("Shift AppPointerEvent failed, return:%{public}d", ret);
2937 return ret;
2938 }
2939 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
2940 return RET_OK;
2941 }
2942 } // namespace MMI
2943 } // namespace OHOS
2944