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 #ifdef OHOS_BUILD_PC_PRIORITY
19 #include <sched.h>
20 #endif // OHOS_BUILD_PC_PRIORITY
21 #include <sys/signalfd.h>
22 #include <csignal>
23 #ifdef OHOS_RSS_CLIENT
24 #include <unordered_map>
25 #endif // OHOS_RSS_CLIENT
26
27 #include "ability_manager_client.h"
28 #include "anr_manager.h"
29 #include "app_state_observer.h"
30 #include "device_event_monitor.h"
31 #include "dfx_dump_catcher.h"
32 #include "dfx_hisysevent.h"
33
34 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
35 #include "display_event_monitor.h"
36 #endif // OHOS_BUILD_ENABLE_KEYBOARD
37 #include "event_dump.h"
38 #include "event_statistic.h"
39 #include "event_log_helper.h"
40 #include "ffrt.h"
41 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
42 #include "fingersense_wrapper.h"
43 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
44 #ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
45 #include "gesturesense_wrapper.h"
46 #endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
47 #ifndef OHOS_BUILD_ENABLE_WATCH
48 #include "infrared_emitter_controller.h"
49 #endif // OHOS_BUILD_ENABLE_WATCH
50 #include "ipc_skeleton.h"
51 #include "i_pointer_drawing_manager.h"
52 #include "i_preference_manager.h"
53 #include "key_auto_repeat.h"
54 #ifdef SHORTCUT_KEY_MANAGER_ENABLED
55 #include "key_shortcut_manager.h"
56 #endif // SHORTCUT_KEY_MANAGER_ENABLED
57 #include "permission_helper.h"
58 #include "touch_event_normalize.h"
59 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
60 #include "touch_gesture_manager.h"
61 #endif // defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
62 #include "util_ex.h"
63 #include "xcollie/xcollie.h"
64
65 #ifdef OHOS_RSS_CLIENT
66 #include "res_sched_client.h"
67 #include "res_type.h"
68 #include "system_ability_definition.h"
69 #endif // OHOS_RSS_CLIENT
70 #include "setting_datashare.h"
71 #include "touch_drawing_manager.h"
72 #ifdef OHOS_BUILD_ENABLE_ANCO
73 #include "app_mgr_client.h"
74 #include "running_process_info.h"
75 #endif // OHOS_BUILD_ENABLE_ANCO
76
77 #ifdef PLAYER_FRAMEWORK_EXISTS
78 #include "input_screen_capture_agent.h"
79 #endif // PLAYER_FRAMEWORK_EXISTS
80 #include "tablet_subscriber_handler.h"
81 #undef MMI_LOG_TAG
82 #define MMI_LOG_TAG "MMIService"
83 #undef MMI_LOG_DOMAIN
84 #define MMI_LOG_DOMAIN MMI_LOG_SERVER
85
86 namespace OHOS {
87 namespace MMI {
88 namespace {
89 std::mutex g_instanceMutex;
90 MMIService* g_MMIService;
91 const std::string DEF_INPUT_SEAT { "seat0" };
92 const char* THREAD_NAME { "mmi_service" };
93 constexpr int32_t WATCHDOG_INTERVAL_TIME { 30000 };
94 [[ maybe_unused ]] constexpr int32_t WATCHDOG_DELAY_TIME { 40000 };
95 constexpr int32_t RELOAD_DEVICE_TIME { 2000 };
96 [[ maybe_unused ]] constexpr int32_t WATCHDOG_WARNTIME { 6000 };
97 [[ maybe_unused ]] constexpr int32_t WATCHDOG_BLOCKTIME { 3000 };
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 [[ maybe_unused ]] 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 constexpr int32_t PRINT_INTERVAL_TIME { 30000 };
108 constexpr int32_t RETRY_CHECK_TIMES { 5 };
109 constexpr int32_t CHECK_EEVENT_INTERVAL_TIME { 4000 };
110 const int32_t ERROR_WINDOW_ID_PERMISSION_DENIED = 26500001;
111 const std::set<int32_t> g_keyCodeValueSet = {
112 #ifndef OHOS_BUILD_ENABLE_WATCH
113 KeyEvent::KEYCODE_FN, KeyEvent::KEYCODE_DPAD_UP, KeyEvent::KEYCODE_DPAD_DOWN, KeyEvent::KEYCODE_DPAD_LEFT,
114 KeyEvent::KEYCODE_DPAD_RIGHT, KeyEvent::KEYCODE_ALT_LEFT, KeyEvent::KEYCODE_ALT_RIGHT,
115 KeyEvent::KEYCODE_SHIFT_LEFT, KeyEvent::KEYCODE_SHIFT_RIGHT, KeyEvent::KEYCODE_TAB, KeyEvent::KEYCODE_ENTER,
116 KeyEvent::KEYCODE_DEL, KeyEvent::KEYCODE_MENU, KeyEvent::KEYCODE_PAGE_UP, KeyEvent::KEYCODE_PAGE_DOWN,
117 KeyEvent::KEYCODE_ESCAPE, KeyEvent::KEYCODE_FORWARD_DEL, KeyEvent::KEYCODE_CTRL_LEFT, KeyEvent::KEYCODE_CTRL_RIGHT,
118 KeyEvent::KEYCODE_CAPS_LOCK, KeyEvent::KEYCODE_SCROLL_LOCK, KeyEvent::KEYCODE_META_LEFT,
119 KeyEvent::KEYCODE_META_RIGHT, KeyEvent::KEYCODE_SYSRQ, KeyEvent::KEYCODE_BREAK, KeyEvent::KEYCODE_MOVE_HOME,
120 KeyEvent::KEYCODE_MOVE_END, KeyEvent::KEYCODE_INSERT, KeyEvent::KEYCODE_F1, KeyEvent::KEYCODE_F2,
121 KeyEvent::KEYCODE_F3, KeyEvent::KEYCODE_F4, KeyEvent::KEYCODE_F5, KeyEvent::KEYCODE_F6, KeyEvent::KEYCODE_F7,
122 KeyEvent::KEYCODE_F8, KeyEvent::KEYCODE_F9, KeyEvent::KEYCODE_F10, KeyEvent::KEYCODE_F11, KeyEvent::KEYCODE_F12,
123 KeyEvent::KEYCODE_NUM_LOCK
124 #endif // OHOS_BUILD_ENABLE_WATCH
125 };
126 #ifdef OHOS_BUILD_ENABLE_ANCO
127 constexpr int32_t DEFAULT_USER_ID { 100 };
128 #endif // OHOS_BUILD_ENABLE_ANCO
129 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
130 const std::string DEVICE_TYPE_HPR { "HPR" };
131 const std::string PRODUCT_TYPE = OHOS::system::GetParameter("const.build.product", "HYM");
132 // Define vkeyboard functions from vendor
133 const std::string VKEYBOARD_PATH { "libvkeyboard_device.z.so" };
134 void* g_VKeyboardHandle = nullptr;
135 typedef int32_t (*HANDLE_TOUCHPOINT_TYPE)(
136 double screenX, double screenY, int touchId, int32_t eventType, double touchPressure,
137 int32_t longAxis, int32_t shortAxis);
138 HANDLE_TOUCHPOINT_TYPE handleTouchPoint_ = nullptr;
139 typedef int32_t (*STATEMACINEMESSAGQUEUE_GETLIBINPUTMESSAGE_TYPE)(
140 int& toggleCodeFirst, int& toggleCodeSecond, int& keyCode);
141 STATEMACINEMESSAGQUEUE_GETLIBINPUTMESSAGE_TYPE statemachineMessageQueue_getLibinputMessage_ = nullptr;
142 typedef void (*TRACKPADENGINE_GETALLTOUCHMESSAGE_TYPE)(
143 std::vector<std::vector<int32_t>>& retMsgList);
144 TRACKPADENGINE_GETALLTOUCHMESSAGE_TYPE trackPadEngine_getAllTouchMessage_ = nullptr;
145 typedef void (*TRACKPADENGINE_CLEARTOUCHMESSAGE_TYPE)();
146 TRACKPADENGINE_CLEARTOUCHMESSAGE_TYPE trackPadEngine_clearTouchMessage_ = nullptr;
147 typedef void (*TRACKPADENGINE_GETALLKEYMESSAGE_TYPE)(
148 std::vector<std::vector<int32_t>>& retMsgList);
149 TRACKPADENGINE_GETALLKEYMESSAGE_TYPE trackPadEngine_getAllKeyMessage_ = nullptr;
150 typedef void (*TRACKPADENGINE_CLEARKEYMESSAGE_TYPE)();
151 TRACKPADENGINE_CLEARKEYMESSAGE_TYPE trackPadEngine_clearKeyMessage_ = nullptr;
152 typedef int32_t (*VKEYBOARD_CREATEVKEYBOARDDEVICE_TYPE)(IRemoteObject* &vkeyboardDevice);
153 VKEYBOARD_CREATEVKEYBOARDDEVICE_TYPE vkeyboard_createVKeyboardDevice_ = nullptr;
154 typedef int32_t (*VKEYBOARD_ONFUNCKEYEVENT_TYPE)(std::shared_ptr<KeyEvent> funcKeyEvent);
155 VKEYBOARD_ONFUNCKEYEVENT_TYPE vkeyboard_onFuncKeyEvent_ = nullptr;
156 typedef void (*VKEYBOARD_HARDWAREKEYEVENTDETECTED_TYPE)();
157 VKEYBOARD_HARDWAREKEYEVENTDETECTED_TYPE vkeyboard_hardwareKeyEventDetected_ = nullptr;
158 typedef int32_t (*VKEYBOARD_GETKEYBOARDACTIVATIONSTATE_TYPE)();
159 VKEYBOARD_GETKEYBOARDACTIVATIONSTATE_TYPE vkeyboard_getKeyboardActivationState_ = nullptr;
160
161 #endif // OHOS_BUILD_ENABLE_VKEYBOARD
162 #ifdef OHOS_BUILD_PC_PRIORITY
163 constexpr int32_t PC_PRIORITY { 2 };
164 #endif // OHOS_BUILD_PC_PRIORITY
165 } // namespace
166
167 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(MMIService::GetInstance());
168
CheckDefineOutput(const char * fmt,Ts...args)169 template <class... Ts> void CheckDefineOutput(const char *fmt, Ts... args)
170 {
171 CHKPV(fmt);
172 char buf[MAX_PACKET_BUF_SIZE] = {};
173 int32_t ret = snprintf_s(buf, MAX_PACKET_BUF_SIZE, MAX_PACKET_BUF_SIZE - 1, fmt, args...);
174 if (ret == -1) {
175 KMSG_LOGE("Call snprintf_s failed.ret = %d", ret);
176 return;
177 }
178 KMSG_LOGI("%s", buf);
179 MMI_HILOGI("%{public}s", buf);
180 }
181
CheckDefine()182 static void CheckDefine()
183 {
184 CheckDefineOutput("ChkDefs:");
185 #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
186 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_POINTER_DRAWING");
187 #endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
188 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
189 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_INTERCEPTOR");
190 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
191 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
192 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_KEYBOARD");
193 #endif // OHOS_BUILD_ENABLE_KEYBOARD
194 #ifdef OHOS_BUILD_ENABLE_POINTER
195 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_POINTER");
196 #endif // OHOS_BUILD_ENABLE_POINTER
197 #ifdef OHOS_BUILD_ENABLE_TOUCH
198 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_TOUCH");
199 #endif // OHOS_BUILD_ENABLE_TOUCH
200 #ifdef OHOS_BUILD_ENABLE_MONITOR
201 CheckDefineOutput("%-40s", "OHOS_BUILD_ENABLE_MONITOR");
202 #endif // OHOS_BUILD_ENABLE_MONITOR
203 }
204
MMIService()205 MMIService::MMIService() : SystemAbility(MULTIMODAL_INPUT_CONNECT_SERVICE_ID, true) {}
206
~MMIService()207 MMIService::~MMIService()
208 {
209 if (g_MMIService != nullptr) {
210 g_MMIService = nullptr;
211 }
212 MMI_HILOGI("~MMIService");
213 }
214
GetInstance()215 MMIService* MMIService::GetInstance()
216 {
217 if (g_MMIService == nullptr) {
218 std::lock_guard<std::mutex> lock(g_instanceMutex);
219 if (g_MMIService == nullptr) {
220 MMI_HILOGI("New MMIService");
221 g_MMIService = new MMIService();
222 }
223 }
224 return g_MMIService;
225 }
226
AddEpoll(EpollEventType type,int32_t fd,bool readOnly)227 int32_t MMIService::AddEpoll(EpollEventType type, int32_t fd, bool readOnly)
228 {
229 if (type < EPOLL_EVENT_BEGIN || type >= EPOLL_EVENT_END) {
230 MMI_HILOGE("Invalid param type");
231 return RET_ERR;
232 }
233 if (fd < 0) {
234 MMI_HILOGE("Invalid param fd_");
235 return RET_ERR;
236 }
237 if (mmiFd_ < 0) {
238 MMI_HILOGE("Invalid param mmiFd_");
239 return RET_ERR;
240 }
241 auto eventData = std::make_shared<mmi_epoll_event>();
242 eventData->fd = fd;
243 eventData->event_type = type;
244 MMI_HILOGI("The userdata:[fd:%{public}d, type:%{public}d]", eventData->fd, eventData->event_type);
245
246 struct epoll_event ev = {};
247 if (readOnly) {
248 ev.events = 0;
249 } else {
250 ev.events = EPOLLIN;
251 }
252 ev.data.fd = fd;
253 auto ret = EpollCtl(fd, EPOLL_CTL_ADD, ev, mmiFd_);
254 if (ret < 0) {
255 eventData = nullptr;
256 ev.data.ptr = nullptr;
257 return ret;
258 }
259 AddEpollEvent(fd, eventData);
260 return RET_OK;
261 }
262
DelEpoll(EpollEventType type,int32_t fd)263 int32_t MMIService::DelEpoll(EpollEventType type, int32_t fd)
264 {
265 if (type < EPOLL_EVENT_BEGIN || type >= EPOLL_EVENT_END) {
266 MMI_HILOGE("Invalid param type");
267 return RET_ERR;
268 }
269 if (fd < 0) {
270 MMI_HILOGE("Invalid param fd_");
271 return RET_ERR;
272 }
273 if (mmiFd_ < 0) {
274 MMI_HILOGE("Invalid param mmiFd_");
275 return RET_ERR;
276 }
277 struct epoll_event ev = {};
278 auto ret = EpollCtl(fd, EPOLL_CTL_DEL, ev, mmiFd_);
279 if (ret < 0) {
280 MMI_HILOGE("DelEpoll failed");
281 return ret;
282 }
283 return RET_OK;
284 }
285
IsRunning() const286 bool MMIService::IsRunning() const
287 {
288 return (state_ == ServiceRunningState::STATE_RUNNING);
289 }
290
InitLibinputService()291 bool MMIService::InitLibinputService()
292 {
293 if (!(libinputAdapter_.Init([](void *event, int64_t frameTime) { InputHandler->OnEvent(event, frameTime); }))) {
294 MMI_HILOGE("Libinput init, bind failed");
295 return false;
296 }
297 auto inputFds = libinputAdapter_.GetInputFds();
298 for (auto fd : inputFds) {
299 auto ret = AddEpoll(EPOLL_EVENT_INPUT, fd);
300 if (ret < 0) {
301 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
302 EpollClose();
303 return false;
304 }
305 MMI_HILOGD("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, fd);
306 }
307 return true;
308 }
309
InitService()310 bool MMIService::InitService()
311 {
312 MMI_HILOGD("Server msg handler Init");
313 sMsgHandler_.Init(*this);
314 if (state_ != ServiceRunningState::STATE_NOT_START) {
315 MMI_HILOGE("Service running status is not enabled");
316 return false;
317 }
318 if (EpollCreate(MAX_EVENT_SIZE) < 0) {
319 MMI_HILOGE("Create epoll failed");
320 return false;
321 }
322 auto ret = AddEpoll(EPOLL_EVENT_SOCKET, epollFd_);
323 if (ret < 0) {
324 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
325 EpollClose();
326 return false;
327 }
328 state_ = ServiceRunningState::STATE_RUNNING;
329 if (!(Publish(this))) {
330 state_ = ServiceRunningState::STATE_NOT_START;
331 MMI_HILOGE("Service initialization failed");
332 EpollClose();
333 return false;
334 }
335 MMI_HILOGI("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, epollFd_);
336 return true;
337 }
338
InitDelegateTasks()339 bool MMIService::InitDelegateTasks()
340 {
341 CALL_DEBUG_ENTER;
342 if (!delegateTasks_.Init()) {
343 MMI_HILOGE("The delegate task init failed");
344 return false;
345 }
346 auto ret = AddEpoll(EPOLL_EVENT_ETASK, delegateTasks_.GetReadFd());
347 if (ret < 0) {
348 MMI_HILOGE("AddEpoll error ret:%{public}d", ret);
349 EpollClose();
350 return false;
351 }
352 std::function<int32_t(DTaskCallback)> fun = [this](DTaskCallback cb) -> int32_t {
353 return delegateTasks_.PostSyncTask(cb);
354 };
355 std::function<int32_t(DTaskCallback)> asyncFun = [this](DTaskCallback cb) -> int32_t {
356 return delegateTasks_.PostAsyncTask(cb);
357 };
358 delegateInterface_ = std::make_shared<DelegateInterface>(fun, asyncFun);
359 delegateInterface_->Init();
360 MMI_HILOGI("AddEpoll, epollfd:%{public}d, fd:%{public}d", mmiFd_, delegateTasks_.GetReadFd());
361 return true;
362 }
363 __attribute__((no_sanitize("cfi")))
Init()364 int32_t MMIService::Init()
365 {
366 CheckDefine();
367 MMI_HILOGD("WindowsManager Init");
368 WIN_MGR->Init(*this);
369 MMI_HILOGD("NapProcess Init");
370 NapProcess::GetInstance()->Init(*this);
371 MMI_HILOGD("ANRManager Init");
372 ANRMgr->Init(*this);
373 MMI_HILOGI("PointerDrawingManager Init");
374 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
375 if (!IPointerDrawingManager::GetInstance()->Init()) {
376 MMI_HILOGE("Pointer draw init failed");
377 return POINTER_DRAW_INIT_FAIL;
378 }
379 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
380 mmiFd_ = EpollCreate(MAX_EVENT_SIZE);
381 if (mmiFd_ < 0) {
382 MMI_HILOGE("Create epoll failed");
383 return EPOLL_CREATE_FAIL;
384 }
385 MMI_HILOGD("Input msg handler init");
386 InputHandler->Init(*this);
387 MMI_HILOGD("Init DelegateTasks init");
388 if (!InitDelegateTasks()) {
389 MMI_HILOGE("Delegate tasks init failed");
390 return ETASKS_INIT_FAIL;
391 }
392 MMI_HILOGD("Libinput service init");
393 if (!InitLibinputService()) {
394 MMI_HILOGE("Libinput init failed");
395 return LIBINPUT_INIT_FAIL;
396 }
397 SetRecvFun([this] (SessionPtr sess, NetPacket& pkt) {sMsgHandler_.OnMsgHandler(sess, pkt);});
398 KeyMapMgr->GetConfigKeyValue("default_keymap", KeyMapMgr->GetDefaultKeyId());
399 OHOS::system::SetParameter(INPUT_POINTER_DEVICES, "false");
400 if (!InitService()) {
401 MMI_HILOGE("Saservice init failed");
402 return SASERVICE_INIT_FAIL;
403 }
404 MMI_HILOGI("Set para input.pointer.device false");
405 return RET_OK;
406 }
407
OnStart()408 void MMIService::OnStart()
409 {
410 CHK_PID_AND_TID();
411 int32_t ret = Init();
412 CHKNOKRV(ret, "Init mmi_service failed");
413 MMI_HILOGD("Started successfully");
414 AddReloadDeviceTimer();
415 auto keyHandler = InputHandler->GetKeyCommandHandler();
416 if (keyHandler != nullptr) {
417 keyHandler->PreHandleEvent();
418 }
419 t_ = std::thread([this] {this->OnThread();});
420 pthread_setname_np(t_.native_handle(), THREAD_NAME);
421 eventMonitorThread_ = std::thread(&EventStatistic::WriteEventFile);
422 pthread_setname_np(eventMonitorThread_.native_handle(), "event-monitor");
423 #ifdef OHOS_RSS_CLIENT
424 MMI_HILOGI("Add system ability listener start");
425 AddSystemAbilityListener(RES_SCHED_SYS_ABILITY_ID);
426 MMI_HILOGI("Add system ability listener success");
427 #endif // OHOS_RSS_CLIENT
428 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
429 MMI_HILOGI("Add SA listener COMMON_EVENT_SERVICE_ID start");
430 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
431 MMI_HILOGI("Add SA listener COMMON_EVENT_SERVICE_ID success");
432 #endif // OHOS_BUILD_ENABLE_KEYBOARD
433 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER) && defined(OHOS_BUILD_ENABLE_KEYBOARD)
434 FINGERSENSE_WRAPPER->InitFingerSenseWrapper();
435 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER && OHOS_BUILD_ENABLE_KEYBOARD
436 #ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
437 GESTURESENSE_WRAPPER->InitGestureSenseWrapper();
438 #endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
439 MMI_HILOGI("Add app manager service listener start");
440 AddSystemAbilityListener(APP_MGR_SERVICE_ID);
441 APP_OBSERVER_MGR->InitAppStateObserver();
442 MMI_HILOGI("Add app manager service listener end");
443 AddSystemAbilityListener(RENDER_SERVICE);
444 AddAppDebugListener();
445 AddSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID);
446 #ifdef OHOS_BUILD_ENABLE_ANCO
447 InitAncoUds();
448 #endif // OHOS_BUILD_ENABLE_ANCO
449 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
450 IPointerDrawingManager::GetInstance()->InitPointerObserver();
451 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
452 InitPreferences();
453 #if OHOS_BUILD_ENABLE_POINTER
454 bool switchFlag = false;
455 TOUCH_EVENT_HDR->GetTouchpadDoubleTapAndDragState(switchFlag);
456 TOUCH_EVENT_HDR->SetTouchpadDoubleTapAndDragState(switchFlag);
457 #endif
458 TimerMgr->AddTimer(WATCHDOG_INTERVAL_TIME, -1, [this]() {
459 MMI_HILOGI("Set thread status flag to true");
460 threadStatusFlag_ = true;
461 });
462 [[ maybe_unused ]] auto taskFunc = [this]() {
463 if (threadStatusFlag_) {
464 MMI_HILOGI("Set thread status flag to false");
465 threadStatusFlag_ = false;
466 } else {
467 MMI_HILOGI("Mmi-server Timeout");
468 }
469 };
470 MMI_HILOGI("Run periodical task success");
471 InitPrintClientInfo();
472 }
473
OnStop()474 void MMIService::OnStop()
475 {
476 CHK_PID_AND_TID();
477 UdsStop();
478 libinputAdapter_.Stop();
479 state_ = ServiceRunningState::STATE_NOT_START;
480 #ifdef OHOS_RSS_CLIENT
481 MMI_HILOGI("Remove system ability listener start");
482 RemoveSystemAbilityListener(RES_SCHED_SYS_ABILITY_ID);
483 MMI_HILOGI("Remove system ability listener success");
484 #endif // OHOS_RSS_CLIENT
485 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
486 RemoveSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
487 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
488 RemoveSystemAbilityListener(APP_MGR_SERVICE_ID);
489 RemoveSystemAbilityListener(RENDER_SERVICE);
490 RemoveAppDebugListener();
491 RemoveSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID);
492 #ifdef OHOS_BUILD_ENABLE_ANCO
493 StopAncoUds();
494 #endif // OHOS_BUILD_ENABLE_ANCO
495 }
496
AddAppDebugListener()497 void MMIService::AddAppDebugListener()
498 {
499 CALL_DEBUG_ENTER;
500 appDebugListener_ = AppDebugListener::GetInstance();
501 auto begin = std::chrono::high_resolution_clock::now();
502 auto errCode =
503 AAFwk::AbilityManagerClient::GetInstance()->RegisterAppDebugListener(appDebugListener_);
504 auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
505 std::chrono::high_resolution_clock::now() - begin).count();
506 #ifdef OHOS_BUILD_ENABLE_DFX_RADAR
507 DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::REGISTER_APP_DEBUG_LISTENER, durationMS);
508 #endif // OHOS_BUILD_ENABLE_DFX_RADAR
509 if (errCode != RET_OK) {
510 MMI_HILOGE("Call RegisterAppDebugListener failed, errCode:%{public}d", errCode);
511 }
512 }
513
RemoveAppDebugListener()514 void MMIService::RemoveAppDebugListener()
515 {
516 CALL_DEBUG_ENTER;
517 CHKPV(appDebugListener_);
518 auto begin = std::chrono::high_resolution_clock::now();
519 auto errCode = AAFwk::AbilityManagerClient::GetInstance()->UnregisterAppDebugListener(appDebugListener_);
520 auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
521 std::chrono::high_resolution_clock::now() - begin).count();
522 #ifdef OHOS_BUILD_ENABLE_DFX_RADAR
523 DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::REGISTER_APP_DEBUG_LISTENER, durationMS);
524 #endif // OHOS_BUILD_ENABLE_DFX_RADAR
525 if (errCode != RET_OK) {
526 MMI_HILOGE("Call UnregisterAppDebugListener failed, errCode:%{public}d", errCode);
527 }
528 }
529
AllocSocketFd(const std::string & programName,const int32_t moduleType,int32_t & toReturnClientFd,int32_t & tokenType)530 int32_t MMIService::AllocSocketFd(const std::string &programName, const int32_t moduleType, int32_t &toReturnClientFd,
531 int32_t &tokenType)
532 {
533 toReturnClientFd = IMultimodalInputConnect::INVALID_SOCKET_FD;
534 int32_t serverFd = IMultimodalInputConnect::INVALID_SOCKET_FD;
535 int32_t pid = GetCallingPid();
536 int32_t uid = GetCallingUid();
537 MMI_HILOGI("Enter, programName:%{public}s, moduleType:%{public}d, pid:%{public}d",
538 programName.c_str(), moduleType, pid);
539 int32_t ret = delegateTasks_.PostSyncTask(
540 [this, &programName, moduleType, uid, pid, &serverFd, &toReturnClientFd, &tokenType] {
541 return this->AddSocketPairInfo(programName, moduleType, uid, pid, serverFd, toReturnClientFd, tokenType);
542 }
543 );
544 DfxHisysevent::ClientConnectData data = {
545 .pid = pid,
546 .uid = uid,
547 .moduleType = moduleType,
548 .programName = programName,
549 .serverFd = serverFd
550 };
551 if (ret != RET_OK) {
552 MMI_HILOGE("Call AddSocketPairInfo failed, return:%{public}d", ret);
553 DfxHisysevent::OnClientConnect(data, OHOS::HiviewDFX::HiSysEvent::EventType::FAULT);
554 return ret;
555 }
556 MMI_HILOGIK("Leave, programName:%{public}s, moduleType:%{public}d, alloc success", programName.c_str(),
557 moduleType);
558 DfxHisysevent::OnClientConnect(data, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR);
559 return RET_OK;
560 }
561
AddInputEventFilter(sptr<IEventFilter> filter,int32_t filterId,int32_t priority,uint32_t deviceTags)562 int32_t MMIService::AddInputEventFilter(sptr<IEventFilter> filter, int32_t filterId, int32_t priority,
563 uint32_t deviceTags)
564 {
565 CALL_INFO_TRACE;
566 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) || defined(OHOS_BUILD_ENABLE_KEYBOARD)
567 CHKPR(filter, ERROR_NULL_POINTER);
568 int32_t clientPid = GetCallingPid();
569 int32_t ret = delegateTasks_.PostSyncTask(
570 [this, filter, filterId, priority, deviceTags, clientPid] {
571 return sMsgHandler_.AddInputEventFilter(filter, filterId, priority, deviceTags, clientPid);
572 }
573 );
574 if (ret != RET_OK) {
575 MMI_HILOGE("Add event filter failed, return:%{public}d", ret);
576 return ret;
577 }
578 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH || OHOS_BUILD_ENABLE_KEYBOARD
579 return RET_OK;
580 }
581
RemoveInputEventFilter(int32_t filterId)582 int32_t MMIService::RemoveInputEventFilter(int32_t filterId)
583 {
584 CALL_INFO_TRACE;
585 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) || defined(OHOS_BUILD_ENABLE_KEYBOARD)
586 int32_t clientPid = GetCallingPid();
587 int32_t ret = delegateTasks_.PostSyncTask(
588 [this, filterId, clientPid] {
589 return sMsgHandler_.RemoveInputEventFilter(filterId, clientPid);
590 }
591 );
592 if (ret != RET_OK) {
593 MMI_HILOGE("Remove event filter failed, return:%{public}d", ret);
594 return ret;
595 }
596 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH || OHOS_BUILD_ENABLE_KEYBOARD
597 return RET_OK;
598 }
599
OnConnected(SessionPtr s)600 void MMIService::OnConnected(SessionPtr s)
601 {
602 CHKPV(s);
603 MMI_HILOGI("Get fd:%{public}d", s->GetFd());
604 #ifdef OHOS_BUILD_ENABLE_ANCO
605 if (s->GetProgramName() != SHELL_ASSISTANT) {
606 return;
607 }
608 auto appMgrClient = DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance();
609 if (appMgrClient == nullptr) {
610 return;
611 }
612 int32_t userid = WIN_MGR->GetCurrentUserId();
613 if (userid < 0) {
614 userid = DEFAULT_USER_ID;
615 }
616 std::vector<AppExecFwk::RunningProcessInfo> info;
617 auto begin = std::chrono::high_resolution_clock::now();
618 appMgrClient->GetProcessRunningInfosByUserId(info, userid);
619 auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
620 std::chrono::high_resolution_clock::now() - begin).count();
621 #ifdef OHOS_BUILD_ENABLE_DFX_RADAR
622 DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::GET_PROC_RUNNING_INFOS_BY_UID, durationMS);
623 #endif // OHOS_BUILD_ENABLE_DFX_RADAR
624 for (auto &item : info) {
625 if (item.bundleNames.empty()) {
626 continue;
627 }
628 if (SHELL_ASSISTANT == item.bundleNames[0].c_str()) {
629 MMI_HILOGW("Record client processes pid %{public}d", item.pid_);
630 shellAssitentPid_ = item.pid_;
631 }
632 }
633 #endif // OHOS_BUILD_ENABLE_ANCO
634 }
635
OnDisconnected(SessionPtr s)636 void MMIService::OnDisconnected(SessionPtr s)
637 {
638 CHKPV(s);
639 MMI_HILOGW("Enter, session desc:%{public}s, fd:%{public}d", s->GetDescript().c_str(), s->GetFd());
640 auto ret = RemoveInputEventFilter(-1);
641 if (ret != RET_OK) {
642 MMI_HILOGF("Remove all filter failed, ret:%{public}d", ret);
643 }
644 #ifdef OHOS_BUILD_ENABLE_ANCO
645 if (s->GetProgramName() == SHELL_ASSISTANT && shellAssitentPid_ == s->GetPid()) {
646 MMI_HILOGW("Clean all shell windows pid:%{public}d", s->GetPid());
647 shellAssitentPid_ = -1;
648 IInputWindowsManager::GetInstance()->CleanShellWindowIds();
649 }
650 #endif // OHOS_BUILD_ENABLE_ANCO
651 #ifdef OHOS_BUILD_ENABLE_POINTER
652 IPointerDrawingManager::GetInstance()->DeletePointerVisible(s->GetPid());
653 #endif // OHOS_BUILD_ENABLE_POINTER
654 }
655
SetMouseScrollRows(int32_t rows)656 int32_t MMIService::SetMouseScrollRows(int32_t rows)
657 {
658 CALL_INFO_TRACE;
659 #if defined OHOS_BUILD_ENABLE_POINTER
660 int32_t ret = delegateTasks_.PostSyncTask(
661 [rows] {
662 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetMouseScrollRows(rows);
663 }
664 );
665 if (ret != RET_OK) {
666 MMI_HILOGE("Set the number of mouse scrolling rows failed, return:%{public}d", ret);
667 return ret;
668 }
669 #endif // OHOS_BUILD_ENABLE_POINTER
670 return RET_OK;
671 }
672
SetCustomCursor(int32_t windowId,int32_t focusX,int32_t focusY,void * pixelMap)673 int32_t MMIService::SetCustomCursor(int32_t windowId, int32_t focusX, int32_t focusY, void* pixelMap)
674 {
675 CALL_INFO_TRACE;
676 int32_t pid = GetCallingPid();
677 int32_t ret = delegateTasks_.PostSyncTask(std::bind(
678 [pid, windowId] {
679 return WIN_MGR->CheckWindowIdPermissionByPid(windowId, pid);
680 })
681 );
682 if (windowId > 0 && ret != RET_OK) {
683 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
684 return ERROR_WINDOW_ID_PERMISSION_DENIED;
685 }
686 #if defined OHOS_BUILD_ENABLE_POINTER
687 auto type = PER_HELPER->GetTokenType();
688 if (windowId < 0 && (type == OHOS::Security::AccessToken::TOKEN_HAP ||
689 type == OHOS::Security::AccessToken::TOKEN_NATIVE)) {
690 // The windowID of the application must be greater than 0
691 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", RET_ERR);
692 return RET_ERR;
693 }
694 if (windowId >= 0) {
695 int32_t ret = CheckPidPermission(pid);
696 if (ret != RET_OK) {
697 MMI_HILOGE("Check pid permission failed");
698 return ret;
699 }
700 }
701 ret = delegateTasks_.PostSyncTask(std::bind(
702 [pixelMap, pid, windowId, focusX, focusY] {
703 return IPointerDrawingManager::GetInstance()->SetCustomCursor(pixelMap, pid, windowId, focusX, focusY);
704 }
705 ));
706 if (ret != RET_OK) {
707 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
708 return ret;
709 }
710 #endif // OHOS_BUILD_ENABLE_POINTER
711 return RET_OK;
712 }
713
SetMouseIcon(int32_t windowId,void * pixelMap)714 int32_t MMIService::SetMouseIcon(int32_t windowId, void* pixelMap)
715 {
716 CALL_INFO_TRACE;
717 #if defined OHOS_BUILD_ENABLE_POINTER
718 int32_t pid = GetCallingPid();
719 int32_t ret = CheckPidPermission(pid);
720 if (ret != RET_OK) {
721 MMI_HILOGE("Check pid permission failed");
722 return ret;
723 }
724 ret = delegateTasks_.PostSyncTask(std::bind(
725 [pid, windowId, pixelMap] {
726 return IPointerDrawingManager::GetInstance()->SetMouseIcon(pid, windowId, pixelMap);
727 }
728 ));
729 if (ret != RET_OK) {
730 MMI_HILOGE("Set the mouse icon failed, return:%{public}d", ret);
731 return ret;
732 }
733 #endif // OHOS_BUILD_ENABLE_POINTER
734 return RET_OK;
735 }
736
SetMouseHotSpot(int32_t pid,int32_t windowId,int32_t hotSpotX,int32_t hotSpotY)737 int32_t MMIService::SetMouseHotSpot(int32_t pid, int32_t windowId, int32_t hotSpotX, int32_t hotSpotY)
738 {
739 CALL_INFO_TRACE;
740 #if defined OHOS_BUILD_ENABLE_POINTER
741 int32_t ret = CheckPidPermission(pid);
742 if (ret != RET_OK) {
743 MMI_HILOGE("Check pid permission failed");
744 return ret;
745 }
746 ret = delegateTasks_.PostSyncTask(
747 [pid, windowId, hotSpotX, hotSpotY] {
748 return IPointerDrawingManager::GetInstance()->SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
749 }
750 );
751 if (ret != RET_OK) {
752 MMI_HILOGE("Set the mouse hot spot failed, return:%{public}d", ret);
753 return ret;
754 }
755 #endif // OHOS_BUILD_ENABLE_POINTER
756 return RET_OK;
757 }
758
SetNapStatus(int32_t pid,int32_t uid,std::string bundleName,int32_t napStatus)759 int32_t MMIService::SetNapStatus(int32_t pid, int32_t uid, std::string bundleName, int32_t napStatus)
760 {
761 CALL_INFO_TRACE;
762 int32_t ret = CheckPidPermission(pid);
763 if (ret != RET_OK) {
764 MMI_HILOGE("Check pid permission failed");
765 return ret;
766 }
767 NapProcess::GetInstance()->SetNapStatus(pid, uid, bundleName, napStatus);
768 return RET_OK;
769 }
770
771 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadMouseScrollRows(int32_t & rows)772 int32_t MMIService::ReadMouseScrollRows(int32_t &rows)
773 {
774 rows = MouseEventHdr->GetMouseScrollRows();
775 return RET_OK;
776 }
777 #endif // OHOS_BUILD_ENABLE_POINTER
778
GetMouseScrollRows(int32_t & rows)779 int32_t MMIService::GetMouseScrollRows(int32_t &rows)
780 {
781 CALL_INFO_TRACE;
782 #ifdef OHOS_BUILD_ENABLE_POINTER
783 int32_t ret = delegateTasks_.PostSyncTask(
784 [this, &rows] {
785 return this->ReadMouseScrollRows(rows);
786 }
787 );
788 if (ret != RET_OK) {
789 MMI_HILOGE("Get the number of mouse scrolling rows failed, ret:%{public}d", ret);
790 return ret;
791 }
792 #endif // OHOS_BUILD_ENABLE_POINTER
793 return RET_OK;
794 }
795
SetPointerSize(int32_t size)796 int32_t MMIService::SetPointerSize(int32_t size)
797 {
798 CALL_INFO_TRACE;
799 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
800 int32_t ret = delegateTasks_.PostSyncTask(
801 [size] {
802 return IPointerDrawingManager::GetInstance()->SetPointerSize(size);
803 }
804 );
805 if (ret != RET_OK) {
806 MMI_HILOGE("Set pointer size failed, return:%{public}d", ret);
807 return ret;
808 }
809 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
810 return RET_OK;
811 }
812
813 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
ReadPointerSize(int32_t & size)814 int32_t MMIService::ReadPointerSize(int32_t &size)
815 {
816 size = IPointerDrawingManager::GetInstance()->GetPointerSize();
817 return RET_OK;
818 }
819 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
820
GetPointerSize(int32_t & size)821 int32_t MMIService::GetPointerSize(int32_t &size)
822 {
823 CALL_INFO_TRACE;
824 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
825 int32_t ret = delegateTasks_.PostSyncTask(
826 [this, &size] {
827 return this->ReadPointerSize(size);
828 }
829 );
830 if (ret != RET_OK) {
831 MMI_HILOGE("Get pointer size failed, return:%{public}d", ret);
832 return ret;
833 }
834 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
835 return RET_OK;
836 }
837
GetCursorSurfaceId(uint64_t & surfaceId)838 int32_t MMIService::GetCursorSurfaceId(uint64_t &surfaceId)
839 {
840 CALL_INFO_TRACE;
841 #ifdef OHOS_BUILD_ENABLE_POINTER
842 auto ret = delegateTasks_.PostSyncTask(
843 [&surfaceId] {
844 return IPointerDrawingManager::GetInstance()->GetCursorSurfaceId(surfaceId);
845 });
846 if (ret != RET_OK) {
847 MMI_HILOGE("GetCursorSurfaceId fail, error:%{public}d", ret);
848 return ret;
849 }
850 #endif // OHOS_BUILD_ENABLE_POINTER
851 return RET_OK;
852 }
853
SetMousePrimaryButton(int32_t primaryButton)854 int32_t MMIService::SetMousePrimaryButton(int32_t primaryButton)
855 {
856 CALL_INFO_TRACE;
857 #if defined OHOS_BUILD_ENABLE_POINTER
858 int32_t ret = delegateTasks_.PostSyncTask(
859 [primaryButton] {
860 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetMousePrimaryButton(primaryButton);
861 }
862 );
863 if (ret != RET_OK) {
864 MMI_HILOGE("Set mouse primary button failed, return:%{public}d", ret);
865 return ret;
866 }
867 #endif // OHOS_BUILD_ENABLE_POINTER
868 return RET_OK;
869 }
870
871 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadMousePrimaryButton(int32_t & primaryButton)872 int32_t MMIService::ReadMousePrimaryButton(int32_t &primaryButton)
873 {
874 primaryButton = MouseEventHdr->GetMousePrimaryButton();
875 return RET_OK;
876 }
877 #endif // OHOS_BUILD_ENABLE_POINTER
878
GetMousePrimaryButton(int32_t & primaryButton)879 int32_t MMIService::GetMousePrimaryButton(int32_t &primaryButton)
880 {
881 CALL_INFO_TRACE;
882 #ifdef OHOS_BUILD_ENABLE_POINTER
883 int32_t ret = delegateTasks_.PostSyncTask(
884 [this, &primaryButton] {
885 return this->ReadMousePrimaryButton(primaryButton);
886 }
887 );
888 if (ret != RET_OK) {
889 MMI_HILOGE("Get mouse primary button failed, return:%{public}d", ret);
890 return ret;
891 }
892 #endif // OHOS_BUILD_ENABLE_POINTER
893 return RET_OK;
894 }
895
SetPointerVisible(bool visible,int32_t priority)896 int32_t MMIService::SetPointerVisible(bool visible, int32_t priority)
897 {
898 CALL_INFO_TRACE;
899 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
900 auto tokenId = IPCSkeleton::GetCallingTokenID();
901 auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
902 bool isHap = false;
903 if (tokenType == OHOS::Security::AccessToken::TOKEN_HAP) {
904 isHap = true;
905 }
906 int32_t clientPid = GetCallingPid();
907 int32_t ret = delegateTasks_.PostSyncTask(
908 [clientPid, visible, priority, isHap] {
909 return IPointerDrawingManager::GetInstance()->SetPointerVisible(clientPid, visible, priority, isHap);
910 }
911 );
912 if (ret != RET_OK) {
913 MMI_HILOGE("Set pointer visible failed, return:%{public}d", ret);
914 return ret;
915 }
916 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
917 return RET_OK;
918 }
919
920 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
CheckPointerVisible(bool & visible)921 int32_t MMIService::CheckPointerVisible(bool &visible)
922 {
923 WIN_MGR->UpdatePointerDrawingManagerWindowInfo();
924 visible = IPointerDrawingManager::GetInstance()->IsPointerVisible();
925 return RET_OK;
926 }
927 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
928
IsPointerVisible(bool & visible)929 int32_t MMIService::IsPointerVisible(bool &visible)
930 {
931 CALL_DEBUG_ENTER;
932 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
933 int32_t ret = delegateTasks_.PostSyncTask(
934 [this, &visible] {
935 return this->CheckPointerVisible(visible);
936 }
937 );
938 if (ret != RET_OK) {
939 MMI_HILOGE("Is pointer visible failed, return:%{public}d", ret);
940 return ret;
941 }
942 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
943 return RET_OK;
944 }
945
MarkProcessed(int32_t eventType,int32_t eventId)946 int32_t MMIService::MarkProcessed(int32_t eventType, int32_t eventId)
947 {
948 CALL_DEBUG_ENTER;
949 CHKPR(ANRMgr, RET_ERR);
950 int32_t clientPid = GetCallingPid();
951 int32_t ret = delegateTasks_.PostSyncTask(
952 [clientPid, eventType, eventId] {
953 return ::OHOS::DelayedSingleton<ANRManager>::GetInstance()->MarkProcessed(clientPid, eventType, eventId);
954 }
955 );
956 if (ret != RET_OK) {
957 MMI_HILOGD("Mark event processed failed, ret:%{public}d", ret);
958 return ret;
959 }
960 return RET_OK;
961 }
962
SetPointerColor(int32_t color)963 int32_t MMIService::SetPointerColor(int32_t color)
964 {
965 CALL_INFO_TRACE;
966 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
967 int32_t ret = delegateTasks_.PostSyncTask(
968 [color] {
969 return IPointerDrawingManager::GetInstance()->SetPointerColor(color);
970 }
971 );
972 if (ret != RET_OK) {
973 MMI_HILOGE("Set pointer color failed, return:%{public}d", ret);
974 return ret;
975 }
976 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
977 return RET_OK;
978 }
979
980 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
ReadPointerColor(int32_t & color)981 int32_t MMIService::ReadPointerColor(int32_t &color)
982 {
983 color = IPointerDrawingManager::GetInstance()->GetPointerColor();
984 return RET_OK;
985 }
986 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
987
GetPointerColor(int32_t & color)988 int32_t MMIService::GetPointerColor(int32_t &color)
989 {
990 CALL_INFO_TRACE;
991 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
992 int32_t ret = delegateTasks_.PostSyncTask(
993 [this, &color] {
994 return this->ReadPointerColor(color);
995 }
996 );
997 if (ret != RET_OK) {
998 MMI_HILOGE("Get pointer color failed, return:%{public}d", ret);
999 return ret;
1000 }
1001 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1002 return RET_OK;
1003 }
1004
SetPointerSpeed(int32_t speed)1005 int32_t MMIService::SetPointerSpeed(int32_t speed)
1006 {
1007 CALL_INFO_TRACE;
1008 #ifdef OHOS_BUILD_ENABLE_POINTER
1009 int32_t ret = delegateTasks_.PostSyncTask(
1010 [speed] {
1011 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetPointerSpeed(speed);
1012 }
1013 );
1014 if (ret != RET_OK) {
1015 MMI_HILOGE("Set pointer speed failed, return:%{public}d", ret);
1016 return ret;
1017 }
1018 #endif // OHOS_BUILD_ENABLE_POINTER
1019 return RET_OK;
1020 }
1021
1022 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadPointerSpeed(int32_t & speed)1023 int32_t MMIService::ReadPointerSpeed(int32_t &speed)
1024 {
1025 speed = MouseEventHdr->GetPointerSpeed();
1026 return RET_OK;
1027 }
1028 #endif // OHOS_BUILD_ENABLE_POINTER
1029
GetPointerSpeed(int32_t & speed)1030 int32_t MMIService::GetPointerSpeed(int32_t &speed)
1031 {
1032 CALL_INFO_TRACE;
1033 #ifdef OHOS_BUILD_ENABLE_POINTER
1034 int32_t ret = delegateTasks_.PostSyncTask(
1035 [this, &speed] {
1036 return this->ReadPointerSpeed(speed);
1037 }
1038 );
1039 if (ret != RET_OK) {
1040 MMI_HILOGE("Get pointer speed failed, return:%{public}d", ret);
1041 return ret;
1042 }
1043 #endif // OHOS_BUILD_ENABLE_POINTER
1044 return RET_OK;
1045 }
1046
NotifyNapOnline()1047 int32_t MMIService::NotifyNapOnline()
1048 {
1049 CALL_DEBUG_ENTER;
1050 NapProcess::GetInstance()->NotifyNapOnline();
1051 return RET_OK;
1052 }
1053
RemoveInputEventObserver()1054 int32_t MMIService::RemoveInputEventObserver()
1055 {
1056 CALL_DEBUG_ENTER;
1057 NapProcess::GetInstance()->RemoveInputEventObserver();
1058 return RET_OK;
1059 }
1060
SetPointerStyle(int32_t windowId,PointerStyle pointerStyle,bool isUiExtension)1061 int32_t MMIService::SetPointerStyle(int32_t windowId, PointerStyle pointerStyle, bool isUiExtension)
1062 {
1063 CALL_INFO_TRACE;
1064 #ifdef OHOS_BUILD_ENABLE_POINTER
1065 int32_t clientPid = GetCallingPid();
1066 int32_t ret = delegateTasks_.PostSyncTask(
1067 [clientPid, windowId, pointerStyle, isUiExtension] {
1068 return IPointerDrawingManager::GetInstance()->SetPointerStyle(
1069 clientPid, windowId, pointerStyle, isUiExtension);
1070 }
1071 );
1072 if (ret != RET_OK) {
1073 MMI_HILOGE("Set pointer style failed, return:%{public}d", ret);
1074 return ret;
1075 }
1076 #endif // OHOS_BUILD_ENABLE_POINTER
1077 return RET_OK;
1078 }
1079
ClearWindowPointerStyle(int32_t pid,int32_t windowId)1080 int32_t MMIService::ClearWindowPointerStyle(int32_t pid, int32_t windowId)
1081 {
1082 CALL_DEBUG_ENTER;
1083 #ifdef OHOS_BUILD_ENABLE_POINTER
1084 int32_t ret = CheckPidPermission(pid);
1085 if (ret != RET_OK) {
1086 MMI_HILOGE("Check pid permission failed");
1087 return ret;
1088 }
1089 ret = delegateTasks_.PostSyncTask(
1090 [pid, windowId] {
1091 return IPointerDrawingManager::GetInstance()->ClearWindowPointerStyle(pid, windowId);
1092 }
1093 );
1094 if (ret != RET_OK) {
1095 MMI_HILOGE("Set pointer style failed, return:%{public}d", ret);
1096 return ret;
1097 }
1098 #endif // OHOS_BUILD_ENABLE_POINTER
1099 return RET_OK;
1100 }
1101
GetPointerStyle(int32_t windowId,PointerStyle & pointerStyle,bool isUiExtension)1102 int32_t MMIService::GetPointerStyle(int32_t windowId, PointerStyle &pointerStyle, bool isUiExtension)
1103 {
1104 CALL_DEBUG_ENTER;
1105 #ifdef OHOS_BUILD_ENABLE_POINTER
1106 int32_t clientPid = GetCallingPid();
1107 int32_t ret = delegateTasks_.PostSyncTask(
1108 [clientPid, windowId, &pointerStyle, isUiExtension] {
1109 return IPointerDrawingManager::GetInstance()->GetPointerStyle(
1110 clientPid, windowId, pointerStyle, isUiExtension);
1111 }
1112 );
1113 if (ret != RET_OK) {
1114 MMI_HILOGE("Get pointer style failed, return:%{public}d", ret);
1115 return ret;
1116 }
1117 #endif // OHOS_BUILD_ENABLE_POINTER
1118 return RET_OK;
1119 }
1120
SetHoverScrollState(bool state)1121 int32_t MMIService::SetHoverScrollState(bool state)
1122 {
1123 CALL_INFO_TRACE;
1124 #if defined OHOS_BUILD_ENABLE_POINTER
1125 int32_t ret = delegateTasks_.PostSyncTask(
1126 [state] {
1127 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetHoverScrollState(state);
1128 }
1129 );
1130 if (ret != RET_OK) {
1131 MMI_HILOGE("Set mouse hover scroll state failed, return:%{public}d", ret);
1132 return ret;
1133 }
1134 #endif // OHOS_BUILD_ENABLE_POINTER
1135 return RET_OK;
1136 }
1137
1138 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadHoverScrollState(bool & state)1139 int32_t MMIService::ReadHoverScrollState(bool &state)
1140 {
1141 state = WIN_MGR->GetHoverScrollState();
1142 return RET_OK;
1143 }
1144 #endif // OHOS_BUILD_ENABLE_POINTER
1145
GetHoverScrollState(bool & state)1146 int32_t MMIService::GetHoverScrollState(bool &state)
1147 {
1148 CALL_INFO_TRACE;
1149 #ifdef OHOS_BUILD_ENABLE_POINTER
1150 int32_t ret = delegateTasks_.PostSyncTask(
1151 [this, &state] {
1152 return this->ReadHoverScrollState(state);
1153 }
1154 );
1155 if (ret != RET_OK) {
1156 MMI_HILOGE("Get mouse hover scroll state, return:%{public}d", ret);
1157 return ret;
1158 }
1159 #endif // OHOS_BUILD_ENABLE_POINTER
1160 return RET_OK;
1161 }
1162
OnSupportKeys(int32_t deviceId,std::vector<int32_t> & keys,std::vector<bool> & keystroke)1163 int32_t MMIService::OnSupportKeys(int32_t deviceId, std::vector<int32_t> &keys, std::vector<bool> &keystroke)
1164 {
1165 CALL_DEBUG_ENTER;
1166 int32_t ret = INPUT_DEV_MGR->SupportKeys(deviceId, keys, keystroke);
1167 if (ret != RET_OK) {
1168 MMI_HILOGE("Device id not support");
1169 return ret;
1170 }
1171 if (keystroke.size() > MAX_SUPPORT_KEY) {
1172 MMI_HILOGE("Device exceeds the max range");
1173 return RET_ERR;
1174 }
1175 return RET_OK;
1176 }
1177
SupportKeys(int32_t deviceId,std::vector<int32_t> & keys,std::vector<bool> & keystroke)1178 int32_t MMIService::SupportKeys(int32_t deviceId, std::vector<int32_t> &keys, std::vector<bool> &keystroke)
1179 {
1180 CALL_DEBUG_ENTER;
1181 int32_t ret = delegateTasks_.PostSyncTask(
1182 [this, deviceId, &keys, &keystroke] {
1183 return this->OnSupportKeys(deviceId, keys, keystroke);
1184 }
1185 );
1186 if (ret != RET_OK) {
1187 MMI_HILOGE("Support keys info process failed, ret:%{public}d", ret);
1188 return ret;
1189 }
1190 return RET_OK;
1191 }
1192
OnGetDeviceIds(std::vector<int32_t> & ids)1193 int32_t MMIService::OnGetDeviceIds(std::vector<int32_t> &ids)
1194 {
1195 CALL_DEBUG_ENTER;
1196 ids = INPUT_DEV_MGR->GetInputDeviceIds();
1197 return RET_OK;
1198 }
1199
GetDeviceIds(std::vector<int32_t> & ids)1200 int32_t MMIService::GetDeviceIds(std::vector<int32_t> &ids)
1201 {
1202 CALL_DEBUG_ENTER;
1203 int32_t ret = delegateTasks_.PostSyncTask(
1204 [this, &ids] {
1205 return this->OnGetDeviceIds(ids);
1206 }
1207 );
1208 if (ret != RET_OK) {
1209 MMI_HILOGE("Get deviceids failed, ret:%{public}d", ret);
1210 return ret;
1211 }
1212 return RET_OK;
1213 }
1214
OnGetDevice(int32_t deviceId,std::shared_ptr<InputDevice> inputDevice)1215 int32_t MMIService::OnGetDevice(int32_t deviceId, std::shared_ptr<InputDevice> inputDevice)
1216 {
1217 CALL_DEBUG_ENTER;
1218 if (INPUT_DEV_MGR->GetInputDevice(deviceId) == nullptr) {
1219 MMI_HILOGE("Input device not found");
1220 return COMMON_PARAMETER_ERROR;
1221 }
1222 auto tmpDevice = INPUT_DEV_MGR->GetInputDevice(deviceId);
1223 inputDevice->SetId(tmpDevice->GetId());
1224 inputDevice->SetType(tmpDevice->GetType());
1225 inputDevice->SetName(tmpDevice->GetName());
1226 inputDevice->SetBus(tmpDevice->GetBus());
1227 inputDevice->SetVersion(tmpDevice->GetVersion());
1228 inputDevice->SetProduct(tmpDevice->GetProduct());
1229 inputDevice->SetVendor(tmpDevice->GetVendor());
1230 inputDevice->SetPhys(tmpDevice->GetPhys());
1231 inputDevice->SetUniq(tmpDevice->GetUniq());
1232 inputDevice->SetCapabilities(tmpDevice->GetCapabilities());
1233 inputDevice->SetAxisInfo(tmpDevice->GetAxisInfo());
1234
1235 return RET_OK;
1236 }
1237
GetDevice(int32_t deviceId,std::shared_ptr<InputDevice> & inputDevice)1238 int32_t MMIService::GetDevice(int32_t deviceId, std::shared_ptr<InputDevice> &inputDevice)
1239 {
1240 CALL_DEBUG_ENTER;
1241 int32_t ret = delegateTasks_.PostSyncTask(
1242 [this, deviceId, inputDevice] {
1243 return this->OnGetDevice(deviceId, inputDevice);
1244 }
1245 );
1246 if (ret != RET_OK) {
1247 MMI_HILOGE("Get input device info failed, ret:%{public}d", ret);
1248 return ret;
1249 }
1250 return RET_OK;
1251 }
1252
OnRegisterDevListener(int32_t pid)1253 int32_t MMIService::OnRegisterDevListener(int32_t pid)
1254 {
1255 auto sess = GetSession(GetClientFd(pid));
1256 CHKPR(sess, RET_ERR);
1257 INPUT_DEV_MGR->AddDevListener(sess);
1258 return RET_OK;
1259 }
1260
RegisterDevListener()1261 int32_t MMIService::RegisterDevListener()
1262 {
1263 CALL_DEBUG_ENTER;
1264 int32_t pid = GetCallingPid();
1265 int32_t ret = delegateTasks_.PostSyncTask(
1266 [this, pid] {
1267 return this->OnRegisterDevListener(pid);
1268 }
1269 );
1270 if (ret != RET_OK) {
1271 MMI_HILOGE("Register device listener failed, ret:%{public}d", ret);
1272 return ret;
1273 }
1274 return RET_OK;
1275 }
1276
OnUnregisterDevListener(int32_t pid)1277 int32_t MMIService::OnUnregisterDevListener(int32_t pid)
1278 {
1279 auto sess = GetSession(GetClientFd(pid));
1280 INPUT_DEV_MGR->RemoveDevListener(sess);
1281 return RET_OK;
1282 }
1283
UnregisterDevListener()1284 int32_t MMIService::UnregisterDevListener()
1285 {
1286 CALL_DEBUG_ENTER;
1287 int32_t pid = GetCallingPid();
1288 int32_t ret = delegateTasks_.PostSyncTask(
1289 [this, pid] {
1290 return this->OnUnregisterDevListener(pid);
1291 }
1292 );
1293 if (ret != RET_OK) {
1294 MMI_HILOGE("Unregister device listener failed failed, ret:%{public}d", ret);
1295 return ret;
1296 }
1297 return RET_OK;
1298 }
1299
OnGetKeyboardType(int32_t deviceId,int32_t & keyboardType)1300 int32_t MMIService::OnGetKeyboardType(int32_t deviceId, int32_t &keyboardType)
1301 {
1302 CALL_DEBUG_ENTER;
1303 int32_t ret = INPUT_DEV_MGR->GetKeyboardType(deviceId, keyboardType);
1304 if (ret != RET_OK) {
1305 MMI_HILOGD("GetKeyboardType call failed");
1306 return ret;
1307 }
1308 return RET_OK;
1309 }
1310
GetKeyboardType(int32_t deviceId,int32_t & keyboardType)1311 int32_t MMIService::GetKeyboardType(int32_t deviceId, int32_t &keyboardType)
1312 {
1313 CALL_DEBUG_ENTER;
1314 int32_t ret = delegateTasks_.PostSyncTask(
1315 [this, deviceId, &keyboardType] {
1316 return this->OnGetKeyboardType(deviceId, keyboardType);
1317 }
1318 );
1319 if (ret != RET_OK) {
1320 MMI_HILOGD("Get keyboard type failed, ret:%{public}d", ret);
1321 return ret;
1322 }
1323 return ret;
1324 }
1325
SetKeyboardRepeatDelay(int32_t delay)1326 int32_t MMIService::SetKeyboardRepeatDelay(int32_t delay)
1327 {
1328 CALL_INFO_TRACE;
1329 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1330 int32_t ret = delegateTasks_.PostSyncTask(
1331 [delay] {
1332 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->SetKeyboardRepeatDelay(delay);
1333 }
1334 );
1335 if (ret != RET_OK) {
1336 MMI_HILOGE("Set keyboard repeat delay failed, ret:%{public}d", ret);
1337 return ret;
1338 }
1339 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1340 return RET_OK;
1341 }
1342
SetKeyboardRepeatRate(int32_t rate)1343 int32_t MMIService::SetKeyboardRepeatRate(int32_t rate)
1344 {
1345 CALL_INFO_TRACE;
1346 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1347 int32_t ret = delegateTasks_.PostSyncTask(
1348 [rate] {
1349 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->SetKeyboardRepeatRate(rate);
1350 }
1351 );
1352 if (ret != RET_OK) {
1353 MMI_HILOGE("Set keyboard repeat rate failed, ret:%{public}d", ret);
1354 return ret;
1355 }
1356 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1357 return RET_OK;
1358 }
1359
GetKeyboardRepeatDelay(int32_t & delay)1360 int32_t MMIService::GetKeyboardRepeatDelay(int32_t &delay)
1361 {
1362 CALL_INFO_TRACE;
1363 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1364 int32_t ret = delegateTasks_.PostSyncTask(
1365 [&delay] {
1366 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->GetKeyboardRepeatDelay(delay);
1367 }
1368 );
1369 if (ret != RET_OK) {
1370 MMI_HILOGE("Get keyboard repeat delay failed, ret:%{public}d", ret);
1371 return ret;
1372 }
1373 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1374 return RET_OK;
1375 }
1376
GetKeyboardRepeatRate(int32_t & rate)1377 int32_t MMIService::GetKeyboardRepeatRate(int32_t &rate)
1378 {
1379 CALL_INFO_TRACE;
1380 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1381 int32_t ret = delegateTasks_.PostSyncTask(
1382 [&rate] {
1383 return ::OHOS::DelayedSingleton<KeyAutoRepeat>::GetInstance()->GetKeyboardRepeatRate(rate);
1384 }
1385 );
1386 if (ret != RET_OK) {
1387 MMI_HILOGE("Get keyboard repeat rate failed, ret:%{public}d", ret);
1388 return ret;
1389 }
1390 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1391 return RET_OK;
1392 }
1393
1394 #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)1395 int32_t MMIService::CheckAddInput(int32_t pid, InputHandlerType handlerType, HandleEventType eventType,
1396 int32_t priority, uint32_t deviceTags)
1397 {
1398 auto sess = GetSessionByPid(pid);
1399 CHKPR(sess, ERROR_NULL_POINTER);
1400 return sMsgHandler_.OnAddInputHandler(sess, handlerType, eventType, priority, deviceTags);
1401 }
1402
1403 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1404
AddInputHandler(InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags,std::vector<int32_t> actionsType)1405 int32_t MMIService::AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority,
1406 uint32_t deviceTags, std::vector<int32_t> actionsType)
1407 {
1408 CALL_INFO_TRACE;
1409 bool isRegisterCaptureCb = false;
1410 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
1411 if (!PER_HELPER->VerifySystemApp() && handlerType == InputHandlerType::MONITOR) {
1412 isRegisterCaptureCb = true;
1413 }
1414 #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS
1415 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
1416 int32_t pid = GetCallingPid();
1417 int32_t ret = delegateTasks_.PostSyncTask(
1418 [this, pid, handlerType, eventType, priority, deviceTags, isRegisterCaptureCb] {
1419 if (isRegisterCaptureCb) {
1420 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
1421 RegisterScreenCaptureCallback();
1422 #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS
1423 }
1424 return this->CheckAddInput(pid, handlerType, eventType, priority, deviceTags);
1425 });
1426 if (ret != RET_OK) {
1427 MMI_HILOGE("Add input handler failed, ret:%{public}d", ret);
1428 return ret;
1429 }
1430 ret = ObserverAddInputHandler(pid);
1431 if (ret != RET_OK) {
1432 MMI_HILOGE("AddInputHandler info to observer failed, ret:%{public}d", ret);
1433 return ret;
1434 }
1435 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1436 return RET_OK;
1437 }
1438
AddPreInputHandler(int32_t handlerId,HandleEventType eventType,std::vector<int32_t> keys)1439 int32_t MMIService::AddPreInputHandler(int32_t handlerId, HandleEventType eventType, std::vector<int32_t> keys)
1440 {
1441 CALL_DEBUG_ENTER;
1442 #ifdef OHOS_BUILD_ENABLE_MONITOR
1443 int32_t pid = GetCallingPid();
1444 int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId, eventType, keys] () -> int32_t {
1445 auto sess = GetSessionByPid(pid);
1446 CHKPR(sess, ERROR_NULL_POINTER);
1447 auto preMonitorHandler = InputHandler->GetEventPreMonitorHandler();
1448 CHKPR(preMonitorHandler, RET_ERR);
1449 return preMonitorHandler->AddInputHandler(sess, handlerId, eventType, keys);
1450 });
1451 if (ret != RET_OK) {
1452 MMI_HILOGE("The AddPreInputHandler key event processed failed, ret:%{public}d", ret);
1453 return ret;
1454 }
1455 #endif // OHOS_BUILD_ENABLE_MONITOR
1456 return RET_OK;
1457 }
1458
RemovePreInputHandler(int32_t handlerId)1459 int32_t MMIService::RemovePreInputHandler(int32_t handlerId)
1460 {
1461 CALL_DEBUG_ENTER;
1462 #ifdef OHOS_BUILD_ENABLE_MONITOR
1463 int32_t pid = GetCallingPid();
1464 int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId] () -> int32_t {
1465 auto sess = GetSessionByPid(pid);
1466 CHKPR(sess, ERROR_NULL_POINTER);
1467 auto preMonitorHandler = InputHandler->GetEventPreMonitorHandler();
1468 CHKPR(preMonitorHandler, RET_ERR);
1469 preMonitorHandler->RemoveInputHandler(sess, handlerId);
1470 return RET_OK;
1471 });
1472 if (ret != RET_OK) {
1473 MMI_HILOGE("Remove pre input handler failed, ret:%{public}d", ret);
1474 return ret;
1475 }
1476 #endif // OHOS_BUILD_ENABLE_MONITOR
1477 return RET_OK;
1478 }
1479
1480 #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)1481 int32_t MMIService::CheckRemoveInput(int32_t pid, InputHandlerType handlerType, HandleEventType eventType,
1482 int32_t priority, uint32_t deviceTags)
1483 {
1484 auto sess = GetSessionByPid(pid);
1485 CHKPR(sess, ERROR_NULL_POINTER);
1486 return sMsgHandler_.OnRemoveInputHandler(sess, handlerType, eventType, priority, deviceTags);
1487 }
1488
ObserverAddInputHandler(int32_t pid)1489 int32_t MMIService::ObserverAddInputHandler(int32_t pid)
1490 {
1491 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1492 OHOS::MMI::NapProcess::NapStatusData napData;
1493 napData.pid = GetCallingPid();
1494 napData.uid = GetCallingUid();
1495 auto sess = GetSessionByPid(pid);
1496 CHKPR(sess, ERROR_NULL_POINTER);
1497 napData.bundleName = sess->GetProgramName();
1498 int32_t syncState = SUBSCRIBED;
1499 MMI_HILOGD("AddInputHandler info to observer : pid:%{public}d, uid:%d, bundleName:%{public}s",
1500 napData.pid, napData.uid, napData.bundleName.c_str());
1501 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1502 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1503 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1504 }
1505 }
1506 return RET_OK;
1507 }
1508 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1509
RemoveInputHandler(InputHandlerType handlerType,HandleEventType eventType,int32_t priority,uint32_t deviceTags,std::vector<int32_t> actionsType)1510 int32_t MMIService::RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority,
1511 uint32_t deviceTags, std::vector<int32_t> actionsType)
1512 {
1513 CALL_INFO_TRACE;
1514 #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR)
1515 int32_t pid = GetCallingPid();
1516 int32_t ret = delegateTasks_.PostSyncTask(
1517 [this, pid, handlerType, eventType, priority, deviceTags] {
1518 return this->CheckRemoveInput(pid, handlerType, eventType, priority, deviceTags);
1519 }
1520 );
1521 if (ret != RET_OK) {
1522 MMI_HILOGE("Remove input handler failed, ret:%{public}d", ret);
1523 return ret;
1524 }
1525 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1526 OHOS::MMI::NapProcess::NapStatusData napData;
1527 napData.pid = GetCallingPid();
1528 napData.uid = GetCallingUid();
1529 auto sess = GetSessionByPid(pid);
1530 CHKPR(sess, ERROR_NULL_POINTER);
1531 napData.bundleName = sess->GetProgramName();
1532 int32_t syncState = UNSUBSCRIBED;
1533 MMI_HILOGD("RemoveInputHandler info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1534 napData.pid, napData.uid, napData.bundleName.c_str());
1535 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1536 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1537 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1538 }
1539 }
1540 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR
1541 return RET_OK;
1542 }
1543
AddGestureMonitor(InputHandlerType handlerType,HandleEventType eventType,TouchGestureType gestureType,int32_t fingers)1544 int32_t MMIService::AddGestureMonitor(InputHandlerType handlerType,
1545 HandleEventType eventType, TouchGestureType gestureType, int32_t fingers)
1546 {
1547 CALL_INFO_TRACE;
1548 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
1549 int32_t pid = GetCallingPid();
1550 int32_t ret = delegateTasks_.PostSyncTask(
1551 [this, pid, handlerType, eventType, gestureType, fingers]() -> int32_t {
1552 if (((eventType & HANDLE_EVENT_TYPE_TOUCH_GESTURE) != HANDLE_EVENT_TYPE_TOUCH_GESTURE)) {
1553 MMI_HILOGE("Illegal type:%{public}d", eventType);
1554 return RET_ERR;
1555 }
1556 if (!GestureMonitorHandler::CheckMonitorValid(gestureType, fingers)) {
1557 MMI_HILOGE("Wrong number of fingers:%{public}d", fingers);
1558 return RET_ERR;
1559 }
1560 if (touchGestureMgr_ == nullptr) {
1561 touchGestureMgr_ = std::make_shared<TouchGestureManager>(delegateInterface_);
1562 }
1563 touchGestureMgr_->AddHandler(pid, gestureType, fingers);
1564
1565 auto sess = GetSessionByPid(pid);
1566 CHKPR(sess, ERROR_NULL_POINTER);
1567 return sMsgHandler_.OnAddGestureMonitor(sess, handlerType, eventType, gestureType, fingers);
1568 });
1569 if (ret != RET_OK) {
1570 MMI_HILOGE("Add gesture handler failed, ret:%{public}d", ret);
1571 return ret;
1572 }
1573 #endif // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
1574 return RET_OK;
1575 }
1576
RemoveGestureMonitor(InputHandlerType handlerType,HandleEventType eventType,TouchGestureType gestureType,int32_t fingers)1577 int32_t MMIService::RemoveGestureMonitor(InputHandlerType handlerType,
1578 HandleEventType eventType, TouchGestureType gestureType, int32_t fingers)
1579 {
1580 CALL_INFO_TRACE;
1581 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
1582 int32_t pid = GetCallingPid();
1583 int32_t ret = delegateTasks_.PostSyncTask(
1584 [this, pid, handlerType, eventType, gestureType, fingers]() -> int32_t {
1585 auto sess = GetSessionByPid(pid);
1586 CHKPR(sess, ERROR_NULL_POINTER);
1587 int32_t ret = sMsgHandler_.OnRemoveGestureMonitor(sess, handlerType, eventType, gestureType, fingers);
1588 if (ret != RET_OK) {
1589 MMI_HILOGE("Failed to remove gesture recognizer, ret:%{public}d", ret);
1590 return ret;
1591 }
1592 if (touchGestureMgr_ != nullptr) {
1593 touchGestureMgr_->RemoveHandler(pid, gestureType, fingers);
1594 }
1595 return RET_OK;
1596 });
1597 if (ret != RET_OK) {
1598 MMI_HILOGE("Remove gesture handler failed, ret:%{public}d", ret);
1599 return ret;
1600 }
1601 #endif // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
1602 return RET_OK;
1603 }
1604
1605 #ifdef OHOS_BUILD_ENABLE_MONITOR
CheckMarkConsumed(int32_t pid,int32_t eventId)1606 int32_t MMIService::CheckMarkConsumed(int32_t pid, int32_t eventId)
1607 {
1608 auto sess = GetSessionByPid(pid);
1609 CHKPR(sess, ERROR_NULL_POINTER);
1610 return sMsgHandler_.OnMarkConsumed(sess, eventId);
1611 }
1612 #endif // OHOS_BUILD_ENABLE_MONITOR
1613
MarkEventConsumed(int32_t eventId)1614 int32_t MMIService::MarkEventConsumed(int32_t eventId)
1615 {
1616 CALL_DEBUG_ENTER;
1617 #ifdef OHOS_BUILD_ENABLE_MONITOR
1618 int32_t pid = GetCallingPid();
1619 int32_t ret = delegateTasks_.PostSyncTask(
1620 [this, pid, eventId] {
1621 return this->CheckMarkConsumed(pid, eventId);
1622 }
1623 );
1624 if (ret != RET_OK) {
1625 MMI_HILOGE("Mark event consumed failed, ret:%{public}d", ret);
1626 return ret;
1627 }
1628 #endif // OHOS_BUILD_ENABLE_MONITOR
1629 return RET_OK;
1630 }
1631
MoveMouseEvent(int32_t offsetX,int32_t offsetY)1632 int32_t MMIService::MoveMouseEvent(int32_t offsetX, int32_t offsetY)
1633 {
1634 CALL_DEBUG_ENTER;
1635 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1636 int32_t ret =
1637 delegateTasks_.PostSyncTask(
1638 [this, offsetX, offsetY] {
1639 return sMsgHandler_.OnMoveMouse(offsetX, offsetY);
1640 }
1641 );
1642 if (ret != RET_OK) {
1643 MMI_HILOGE("The movemouse event processed failed, ret:%{public}d", ret);
1644 return ret;
1645 }
1646 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1647 return RET_OK;
1648 }
1649
InjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent,bool isNativeInject)1650 int32_t MMIService::InjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent, bool isNativeInject)
1651 {
1652 CALL_DEBUG_ENTER;
1653 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1654 int32_t ret;
1655 int32_t pid = GetCallingPid();
1656 #ifdef OHOS_BUILD_ENABLE_ANCO
1657 ret = InjectKeyEventExt(keyEvent, pid, isNativeInject);
1658 #else
1659 ret = delegateTasks_.PostSyncTask(
1660 [this, keyEvent, pid, isNativeInject] {
1661 return this->CheckInjectKeyEvent(keyEvent, pid, isNativeInject);
1662 }
1663 );
1664 #endif // OHOS_BUILD_ENABLE_ANCO
1665 if (ret != RET_OK) {
1666 MMI_HILOGE("Inject key event failed, ret:%{public}d", ret);
1667 return ret;
1668 }
1669 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1670 return RET_OK;
1671 }
1672
CheckInjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent,int32_t pid,bool isNativeInject)1673 int32_t MMIService::CheckInjectKeyEvent(const std::shared_ptr<KeyEvent> keyEvent, int32_t pid, bool isNativeInject)
1674 {
1675 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1676 CHKPR(keyEvent, ERROR_NULL_POINTER);
1677 LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
1678 return sMsgHandler_.OnInjectKeyEvent(keyEvent, pid, isNativeInject);
1679 #else
1680 return RET_OK;
1681 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1682 }
1683
1684 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
OnGetKeyState(std::vector<int32_t> & pressedKeys,std::map<int32_t,int32_t> & specialKeysState)1685 int32_t MMIService::OnGetKeyState(std::vector<int32_t> &pressedKeys, std::map<int32_t, int32_t> &specialKeysState)
1686 {
1687 auto keyEvent = KeyEventHdr->GetKeyEvent();
1688 CHKPR(keyEvent, ERROR_NULL_POINTER);
1689 pressedKeys = keyEvent->GetPressedKeys();
1690 for (auto iter = pressedKeys.begin(); iter != pressedKeys.end();) {
1691 if (g_keyCodeValueSet.find(*iter) == g_keyCodeValueSet.end()) {
1692 iter = pressedKeys.erase(iter);
1693 continue;
1694 }
1695 ++iter;
1696 }
1697 specialKeysState[KeyEvent::KEYCODE_CAPS_LOCK] =
1698 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY));
1699 specialKeysState[KeyEvent::KEYCODE_SCROLL_LOCK] =
1700 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY));
1701 specialKeysState[KeyEvent::KEYCODE_NUM_LOCK] =
1702 static_cast<int32_t>(keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY));
1703 return RET_OK;
1704 }
1705 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1706
CheckInjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,int32_t pid,bool isNativeInject,bool isShell)1707 int32_t MMIService::CheckInjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,
1708 int32_t pid, bool isNativeInject, bool isShell)
1709 {
1710 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1711 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1712 LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
1713 return sMsgHandler_.OnInjectPointerEvent(pointerEvent, pid, isNativeInject, isShell);
1714 #else
1715 return RET_OK;
1716 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1717 }
1718
CheckTouchPadEvent(const std::shared_ptr<PointerEvent> pointerEvent,int32_t pid,const TouchpadCDG & touchpadCDG,bool isNativeInject,bool isShell)1719 int32_t MMIService::CheckTouchPadEvent(const std::shared_ptr<PointerEvent> pointerEvent,
1720 int32_t pid, const TouchpadCDG &touchpadCDG, bool isNativeInject, bool isShell)
1721 {
1722 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1723 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1724 LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
1725 return sMsgHandler_.OnInjectTouchPadEvent(pointerEvent, pid, touchpadCDG, isNativeInject, isShell);
1726 #else
1727 return RET_OK;
1728 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1729 }
1730
InjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent,bool isNativeInject)1731 int32_t MMIService::InjectPointerEvent(const std::shared_ptr<PointerEvent> pointerEvent, bool isNativeInject)
1732 {
1733 CALL_DEBUG_ENTER;
1734 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1735 int32_t ret;
1736 int32_t pid = GetCallingPid();
1737 bool isShell = PER_HELPER->RequestFromShell();
1738 #ifdef OHOS_BUILD_ENABLE_ANCO
1739 ret = InjectPointerEventExt(pointerEvent, pid, isNativeInject, isShell);
1740 #else
1741 ret = delegateTasks_.PostSyncTask(
1742 [this, pointerEvent, pid, isNativeInject, isShell] {
1743 return this->CheckInjectPointerEvent(pointerEvent, pid, isNativeInject, isShell);
1744 }
1745 );
1746 #endif // OHOS_BUILD_ENABLE_ANCO
1747 if (ret != RET_OK) {
1748 MMI_HILOGE("Inject pointer event failed, ret:%{public}d", ret);
1749 return ret;
1750 }
1751 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1752 return RET_OK;
1753 }
1754
InjectTouchPadEvent(const std::shared_ptr<PointerEvent> pointerEvent,const TouchpadCDG & touchpadCDG,bool isNativeInject)1755 int32_t MMIService::InjectTouchPadEvent(const std::shared_ptr<PointerEvent> pointerEvent,
1756 const TouchpadCDG &touchpadCDG, bool isNativeInject)
1757 {
1758 CALL_DEBUG_ENTER;
1759 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
1760 int32_t ret;
1761 int32_t pid = GetCallingPid();
1762 bool isShell = PER_HELPER->RequestFromShell();
1763 ret = delegateTasks_.PostSyncTask(
1764 [this, pointerEvent, pid, touchpadCDG, isNativeInject, isShell] {
1765 return sMsgHandler_.OnInjectTouchPadEvent(pointerEvent, pid, touchpadCDG, isNativeInject, isShell);
1766 }
1767 );
1768 if (ret != RET_OK) {
1769 MMI_HILOGE("Inject touchpad event failed, ret:%{public}d", ret);
1770 return ret;
1771 }
1772 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1773 return RET_OK;
1774 }
1775
1776 #if defined(OHOS_RSS_CLIENT) && !defined(OHOS_BUILD_PC_PRIORITY)
OnAddResSchedSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1777 void MMIService::OnAddResSchedSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1778 {
1779 int sleepSeconds = 1;
1780 sleep(sleepSeconds);
1781 uint64_t tid = tid_.load();
1782 int32_t userInteraction = 2;
1783 std::unordered_map<std::string, std::string> payload;
1784 payload["uid"] = std::to_string(getuid());
1785 payload["pid"] = std::to_string(getpid());
1786 payload["extType"] = "10002";
1787 payload["tid"] = std::to_string(tid);
1788 payload["isSa"] = "1";
1789 payload["cgroupPrio"] = "1";
1790 payload["threadName"] = "mmi_service";
1791 auto begin = std::chrono::high_resolution_clock::now();
1792 ResourceSchedule::ResSchedClient::GetInstance().ReportData(
1793 ResourceSchedule::ResType::RES_TYPE_KEY_PERF_SCENE, userInteraction, payload);
1794 auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
1795 std::chrono::high_resolution_clock::now() - begin).count();
1796 #ifdef OHOS_BUILD_ENABLE_DFX_RADAR
1797 DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::RESOURCE_SCHEDULE_REPORT_DATA, durationMS);
1798 #endif // OHOS_BUILD_ENABLE_DFX_RADAR
1799 }
1800 #endif // defined(OHOS_RSS_CLIENT) && !defined(OHOS_BUILD_PC_PRIORITY)
1801
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1802 void MMIService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1803 {
1804 CALL_INFO_TRACE;
1805 MMI_HILOGI("The systemAbilityId is %{public}d", systemAbilityId);
1806 #if defined(OHOS_RSS_CLIENT) && !defined(OHOS_BUILD_PC_PRIORITY)
1807 if (systemAbilityId == RES_SCHED_SYS_ABILITY_ID) {
1808 OnAddResSchedSystemAbility(systemAbilityId, deviceId);
1809 }
1810 #endif // defined(OHOS_RSS_CLIENT) && !defined(OHOS_BUILD_PC_PRIORITY)
1811 #ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1812 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
1813 isCesStart_ = true;
1814 }
1815 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1816 if (systemAbilityId == APP_MGR_SERVICE_ID) {
1817 APP_OBSERVER_MGR->InitAppStateObserver();
1818 }
1819 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
1820 DEVICE_MONITOR->InitCommonEventSubscriber();
1821 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER)
1822 DISPLAY_MONITOR->InitCommonEventSubscriber();
1823 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
1824 }
1825 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1826 if (systemAbilityId == RENDER_SERVICE) {
1827 IPointerDrawingManager::GetInstance()->InitPointerCallback();
1828 }
1829 if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) {
1830 IPointerDrawingManager::GetInstance()->InitScreenInfo();
1831 }
1832 if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) {
1833 IPointerDrawingManager::GetInstance()->SubscribeScreenModeChange();
1834 }
1835 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1836 if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) {
1837 WIN_MGR->SetFoldState();
1838 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1839 KeyEventHdr->Init();
1840 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1841 }
1842 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
1843 if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) {
1844 if (SettingDataShare::GetInstance(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID).CheckIfSettingsDataReady()) {
1845 IPointerDrawingManager::GetInstance()->InitPointerObserver();
1846 }
1847 }
1848 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
1849 }
1850
1851 #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS)
ScreenCaptureCallback(int32_t pid,bool isStart)1852 void MMIService::ScreenCaptureCallback(int32_t pid, bool isStart)
1853 {
1854 auto service = MMIService::GetInstance();
1855 CHKPV(service);
1856 int32_t ret = service->delegateTasks_.PostSyncTask(
1857 [pid, isStart] {
1858 auto monitorHandler = InputHandler->GetMonitorHandler();
1859 CHKPR(monitorHandler, RET_ERR);
1860 monitorHandler->ProcessScreenCapture(pid, isStart);
1861 return RET_OK;
1862 });
1863 }
1864
RegisterScreenCaptureCallback()1865 void MMIService::RegisterScreenCaptureCallback()
1866 {
1867 if (hasRegisterListener_) {
1868 return;
1869 }
1870 InputScreenCaptureAgent::GetInstance().RegisterListener(ScreenCaptureCallback);
1871 hasRegisterListener_ = true;
1872 }
1873 #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS
1874
SubscribeKeyEvent(int32_t subscribeId,const std::shared_ptr<KeyOption> option)1875 int32_t MMIService::SubscribeKeyEvent(int32_t subscribeId, const std::shared_ptr<KeyOption> option)
1876 {
1877 CALL_DEBUG_ENTER;
1878 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1879 int32_t pid = GetCallingPid();
1880 int32_t ret = delegateTasks_.PostSyncTask(
1881 [this, pid, subscribeId, option] {
1882 return sMsgHandler_.OnSubscribeKeyEvent(this, pid, subscribeId, option);
1883 });
1884 if (ret != RET_OK) {
1885 MMI_HILOGE("The subscribe key event processed failed, ret:%{public}d", ret);
1886 return ret;
1887 }
1888 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1889 OHOS::MMI::NapProcess::NapStatusData napData;
1890 napData.pid = GetCallingPid();
1891 napData.uid = GetCallingUid();
1892 auto sess = GetSessionByPid(pid);
1893 CHKPR(sess, ERROR_NULL_POINTER);
1894 napData.bundleName = sess->GetProgramName();
1895 int32_t syncState = SUBSCRIBED;
1896 MMI_HILOGD("SubscribeKeyEvent info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1897 napData.pid, napData.uid, napData.bundleName.c_str());
1898 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1899 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1900 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1901 }
1902 }
1903 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1904 return RET_OK;
1905 }
1906
UnsubscribeKeyEvent(int32_t subscribeId)1907 int32_t MMIService::UnsubscribeKeyEvent(int32_t subscribeId)
1908 {
1909 CALL_INFO_TRACE;
1910 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1911 int32_t pid = GetCallingPid();
1912 int32_t ret = delegateTasks_.PostSyncTask(
1913 [this, pid, subscribeId] {
1914 return sMsgHandler_.OnUnsubscribeKeyEvent(this, pid, subscribeId);
1915 });
1916 if (ret != RET_OK) {
1917 MMI_HILOGE("The unsubscribe key event processed failed, ret:%{public}d", ret);
1918 return ret;
1919 }
1920 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1921 OHOS::MMI::NapProcess::NapStatusData napData;
1922 napData.pid = GetCallingPid();
1923 napData.uid = GetCallingUid();
1924 auto sess = GetSessionByPid(pid);
1925 CHKPR(sess, ERROR_NULL_POINTER);
1926 napData.bundleName = sess->GetProgramName();
1927 int32_t syncState = UNSUBSCRIBED;
1928 MMI_HILOGD("UnsubscribeKeyEvent info to observer : pid:%{public}d, uid:%{public}d, bundleName:%{public}s",
1929 napData.pid, napData.uid, napData.bundleName.c_str());
1930 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1931 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1932 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1933 }
1934 }
1935 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1936 return RET_OK;
1937 }
1938
SubscribeHotkey(int32_t subscribeId,const std::shared_ptr<KeyOption> option)1939 int32_t MMIService::SubscribeHotkey(int32_t subscribeId, const std::shared_ptr<KeyOption> option)
1940 {
1941 CALL_DEBUG_ENTER;
1942 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1943 int32_t pid = GetCallingPid();
1944 int32_t ret = delegateTasks_.PostSyncTask(
1945 [this, pid, subscribeId, option] {
1946 return sMsgHandler_.OnSubscribeHotkey(this, pid, subscribeId, option);
1947 });
1948 if (ret != RET_OK) {
1949 MMI_HILOGE("ServerMsgHandler::OnSubscribeHotkey fail, error:%{public}d", ret);
1950 return ret;
1951 }
1952 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1953 OHOS::MMI::NapProcess::NapStatusData napData;
1954 napData.pid = GetCallingPid();
1955 napData.uid = GetCallingUid();
1956 auto sess = GetSessionByPid(pid);
1957 CHKPR(sess, ERROR_NULL_POINTER);
1958 napData.bundleName = sess->GetProgramName();
1959 int32_t syncState = SUBSCRIBED;
1960 MMI_HILOGD("SubscribeHotkey info to observer : pid:%{public}d, bundleName:%{public}s",
1961 napData.pid, napData.bundleName.c_str());
1962 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1963 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1964 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1965 }
1966 }
1967 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1968 return RET_OK;
1969 }
1970
UnsubscribeHotkey(int32_t subscribeId)1971 int32_t MMIService::UnsubscribeHotkey(int32_t subscribeId)
1972 {
1973 CALL_INFO_TRACE;
1974 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1975 int32_t pid = GetCallingPid();
1976 int32_t ret = delegateTasks_.PostSyncTask(
1977 [this, pid, subscribeId] {
1978 return sMsgHandler_.OnUnsubscribeHotkey(this, pid, subscribeId);
1979 });
1980 if (ret != RET_OK) {
1981 MMI_HILOGE("ServerMsgHandler::OnUnsubscribeHotkey fail, error:%{public}d", ret);
1982 return ret;
1983 }
1984 if (NapProcess::GetInstance()->GetNapClientPid() != REMOVE_OBSERVER) {
1985 OHOS::MMI::NapProcess::NapStatusData napData;
1986 napData.pid = GetCallingPid();
1987 napData.uid = GetCallingUid();
1988 auto sess = GetSessionByPid(pid);
1989 CHKPR(sess, ERROR_NULL_POINTER);
1990 napData.bundleName = sess->GetProgramName();
1991 int32_t syncState = UNSUBSCRIBED;
1992 MMI_HILOGD("UnsubscribeHotkey info to observer : pid:%{public}d, bundleName:%{public}s",
1993 napData.pid, napData.bundleName.c_str());
1994 NapProcess::GetInstance()->AddMmiSubscribedEventData(napData, syncState);
1995 if (NapProcess::GetInstance()->GetNapClientPid() != UNOBSERVED) {
1996 NapProcess::GetInstance()->NotifyBundleName(napData, syncState);
1997 }
1998 }
1999 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2000 return RET_OK;
2001 }
2002
SubscribeKeyMonitor(const KeyMonitorOption & keyOption)2003 int32_t MMIService::SubscribeKeyMonitor(const KeyMonitorOption &keyOption)
2004 {
2005 CALL_INFO_TRACE;
2006 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2007 int32_t pid = GetCallingPid();
2008 int32_t ret = delegateTasks_.PostSyncTask(
2009 [this, pid, keyOption] {
2010 return sMsgHandler_.SubscribeKeyMonitor(pid, keyOption);
2011 });
2012 if (ret != RET_OK) {
2013 MMI_HILOGE("ServerMsgHandler::SubscribeKeyMonitor fail, error:%{public}d", ret);
2014 return ret;
2015 }
2016 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2017 return RET_OK;
2018 }
2019
UnsubscribeKeyMonitor(const KeyMonitorOption & keyOption)2020 int32_t MMIService::UnsubscribeKeyMonitor(const KeyMonitorOption &keyOption)
2021 {
2022 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2023 int32_t pid = GetCallingPid();
2024 int32_t ret = delegateTasks_.PostSyncTask(
2025 [this, pid, keyOption] {
2026 return sMsgHandler_.UnsubscribeKeyMonitor(pid, keyOption);
2027 });
2028 if (ret != RET_OK) {
2029 MMI_HILOGE("ServerMsgHandler::UnsubscribeKeyMonitor fail, error:%{public}d", ret);
2030 return ret;
2031 }
2032 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2033 return RET_OK;
2034 }
2035
SubscribeSwitchEvent(int32_t subscribeId,int32_t switchType)2036 int32_t MMIService::SubscribeSwitchEvent(int32_t subscribeId, int32_t switchType)
2037 {
2038 CALL_INFO_TRACE;
2039 #ifdef OHOS_BUILD_ENABLE_SWITCH
2040 int32_t pid = GetCallingPid();
2041 int32_t ret = delegateTasks_.PostSyncTask(
2042 [this, pid, subscribeId, switchType] {
2043 return sMsgHandler_.OnSubscribeSwitchEvent(this, pid, subscribeId, switchType);
2044 }
2045 );
2046 if (ret != RET_OK) {
2047 MMI_HILOGE("The subscribe switch event processed failed, ret:%{public}d", ret);
2048 return ret;
2049 }
2050 #endif // OHOS_BUILD_ENABLE_SWITCH
2051 return RET_OK;
2052 }
2053
UnsubscribeSwitchEvent(int32_t subscribeId)2054 int32_t MMIService::UnsubscribeSwitchEvent(int32_t subscribeId)
2055 {
2056 CALL_INFO_TRACE;
2057 #ifdef OHOS_BUILD_ENABLE_SWITCH
2058 int32_t pid = GetCallingPid();
2059 int32_t ret = delegateTasks_.PostSyncTask(
2060 [this, pid, subscribeId] {
2061 return sMsgHandler_.OnUnsubscribeSwitchEvent(this, pid, subscribeId);
2062 }
2063 );
2064 if (ret != RET_OK) {
2065 MMI_HILOGE("The unsubscribe switch event processed failed, ret:%{public}d", ret);
2066 return ret;
2067 }
2068 #endif // OHOS_BUILD_ENABLE_SWITCH
2069 return RET_OK;
2070 }
2071
SubscribeTabletProximity(int32_t subscribeId)2072 int32_t MMIService::SubscribeTabletProximity(int32_t subscribeId)
2073 {
2074 CALL_INFO_TRACE;
2075 int32_t pid = GetCallingPid();
2076 int32_t ret = delegateTasks_.PostSyncTask(
2077 [this, pid, subscribeId] {
2078 auto sess = this->GetSessionByPid(pid);
2079 CHKPR(sess, RET_ERR);
2080 return TABLET_SCRIBER_HANDLER->SubscribeTabletProximity(sess, subscribeId);
2081 }
2082 );
2083 if (ret != RET_OK) {
2084 MMI_HILOGE("The subscribe tablet event processed failed, ret:%{public}d", ret);
2085 return ret;
2086 }
2087 return RET_OK;
2088 }
2089
UnsubscribetabletProximity(int32_t subscribeId)2090 int32_t MMIService::UnsubscribetabletProximity(int32_t subscribeId)
2091 {
2092 CALL_INFO_TRACE;
2093 int32_t pid = GetCallingPid();
2094 int32_t ret = delegateTasks_.PostSyncTask(
2095 [this, pid, subscribeId] {
2096 auto sess = this->GetSessionByPid(pid);
2097 CHKPR(sess, RET_ERR);
2098 return TABLET_SCRIBER_HANDLER->UnsubscribetabletProximity(sess, subscribeId);
2099 }
2100 );
2101 if (ret != RET_OK) {
2102 MMI_HILOGE("The unsubscribe tablet event processed failed, ret:%{public}d", ret);
2103 return ret;
2104 }
2105 return RET_OK;
2106 }
2107
SubscribeLongPressEvent(int32_t subscribeId,const LongPressRequest & longPressRequest)2108 int32_t MMIService::SubscribeLongPressEvent(int32_t subscribeId, const LongPressRequest &longPressRequest)
2109 {
2110 CALL_INFO_TRACE;
2111 int32_t pid = GetCallingPid();
2112 int32_t ret = delegateTasks_.PostSyncTask(
2113 [this, pid, subscribeId, longPressRequest] {
2114 return sMsgHandler_.OnSubscribeLongPressEvent(this, pid, subscribeId, longPressRequest);
2115 }
2116 );
2117 if (ret != RET_OK) {
2118 MMI_HILOGE("The subscribe long press event processed failed, ret:%{public}d", ret);
2119 return ret;
2120 }
2121 return RET_OK;
2122 }
2123
UnsubscribeLongPressEvent(int32_t subscribeId)2124 int32_t MMIService::UnsubscribeLongPressEvent(int32_t subscribeId)
2125 {
2126 CALL_INFO_TRACE;
2127 int32_t pid = GetCallingPid();
2128 int32_t ret = delegateTasks_.PostSyncTask(
2129 [this, pid, subscribeId] {
2130 return sMsgHandler_.OnUnsubscribeLongPressEvent(this, pid, subscribeId);
2131 }
2132 );
2133 if (ret != RET_OK) {
2134 MMI_HILOGE("The unsubscribe long press event processed failed, ret:%{public}d", ret);
2135 return ret;
2136 }
2137 return RET_OK;
2138 }
2139
SetAnrObserver()2140 int32_t MMIService::SetAnrObserver()
2141 {
2142 CALL_INFO_TRACE;
2143 int32_t pid = GetCallingPid();
2144 int32_t ret = delegateTasks_.PostSyncTask(
2145 [pid] {
2146 return ::OHOS::DelayedSingleton<ANRManager>::GetInstance()->SetANRNoticedPid(pid);
2147 }
2148 );
2149 if (ret != RET_OK) {
2150 MMI_HILOGE("Set ANRNoticed pid failed, ret:%{public}d", ret);
2151 return ret;
2152 }
2153 return RET_OK;
2154 }
2155
GetDisplayBindInfo(DisplayBindInfos & infos)2156 int32_t MMIService::GetDisplayBindInfo(DisplayBindInfos &infos)
2157 {
2158 CALL_INFO_TRACE;
2159 int32_t ret = delegateTasks_.PostSyncTask(
2160 [&infos] {
2161 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->GetDisplayBindInfo(infos);
2162 }
2163 );
2164 if (ret != RET_OK) {
2165 MMI_HILOGE("GetDisplayBindInfo pid failed, ret:%{public}d", ret);
2166 return ret;
2167 }
2168 return RET_OK;
2169 }
2170
GetAllMmiSubscribedEvents(std::map<std::tuple<int32_t,int32_t,std::string>,int32_t> & datas)2171 int32_t MMIService::GetAllMmiSubscribedEvents(std::map<std::tuple<int32_t, int32_t, std::string>, int32_t> &datas)
2172 {
2173 CALL_INFO_TRACE;
2174 NapProcess::GetInstance()->GetAllMmiSubscribedEvents(datas);
2175 return RET_OK;
2176 }
2177
SetDisplayBind(int32_t deviceId,int32_t displayId,std::string & msg)2178 int32_t MMIService::SetDisplayBind(int32_t deviceId, int32_t displayId, std::string &msg)
2179 {
2180 CALL_INFO_TRACE;
2181 int32_t ret = delegateTasks_.PostSyncTask(
2182 [deviceId, displayId, &msg] {
2183 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetDisplayBind(deviceId, displayId, msg);
2184 }
2185 );
2186 if (ret != RET_OK) {
2187 MMI_HILOGE("SetDisplayBind pid failed, ret:%{public}d", ret);
2188 return ret;
2189 }
2190 return RET_OK;
2191 }
2192
GetFunctionKeyState(int32_t funcKey,bool & state)2193 int32_t MMIService::GetFunctionKeyState(int32_t funcKey, bool &state)
2194 {
2195 CALL_INFO_TRACE;
2196 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2197 int32_t ret = delegateTasks_.PostSyncTask(
2198 [this, funcKey, &state] {
2199 return sMsgHandler_.OnGetFunctionKeyState(funcKey, state);
2200 }
2201 );
2202 if (ret != RET_OK) {
2203 MMI_HILOGE("Failed to get the keyboard status, ret:%{public}d", ret);
2204 return ret;
2205 }
2206 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2207 return RET_OK;
2208 }
2209
SetFunctionKeyState(int32_t funcKey,bool enable)2210 int32_t MMIService::SetFunctionKeyState(int32_t funcKey, bool enable)
2211 {
2212 CALL_INFO_TRACE;
2213 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2214 int32_t clientPid = GetCallingPid();
2215 int32_t ret = delegateTasks_.PostSyncTask(
2216 [this, clientPid, funcKey, enable] {
2217 return sMsgHandler_.OnSetFunctionKeyState(clientPid, funcKey, enable);
2218 }
2219 );
2220 if (ret != RET_OK) {
2221 MMI_HILOGE("Failed to update the keyboard status, ret:%{public}d", ret);
2222 return ret;
2223 }
2224 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2225 return RET_OK;
2226 }
2227
SetPointerLocation(int32_t x,int32_t y,int32_t displayId)2228 int32_t MMIService::SetPointerLocation(int32_t x, int32_t y, int32_t displayId)
2229 {
2230 CALL_INFO_TRACE;
2231 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
2232 int32_t ret = delegateTasks_.PostSyncTask(
2233 [x, y, displayId] {
2234 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetPointerLocation(x, y, displayId);
2235 }
2236 );
2237 if (ret != RET_OK) {
2238 MMI_HILOGE("Set pointer location failed, ret:%{public}d", ret);
2239 return ret;
2240 }
2241 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
2242 return RET_OK;
2243 }
2244
OnDelegateTask(epoll_event & ev)2245 void MMIService::OnDelegateTask(epoll_event &ev)
2246 {
2247 if ((ev.events & EPOLLIN) == 0) {
2248 MMI_HILOGW("Not epollin");
2249 return;
2250 }
2251 DelegateTasks::TaskData data = {};
2252 auto res = read(delegateTasks_.GetReadFd(), &data, sizeof(data));
2253 if (res == -1) {
2254 MMI_HILOGW("Read failed erron:%{public}d", errno);
2255 }
2256 MMI_HILOGD("RemoteRequest notify td:%{public}" PRId64 ",std:%{public}" PRId64 ""
2257 ",taskId:%{public}d",
2258 GetThisThreadId(), data.tid, data.taskId);
2259 delegateTasks_.ProcessTasks();
2260 }
2261
OnThread()2262 void MMIService::OnThread()
2263 {
2264 SetThreadName(std::string("mmi_service"));
2265 uint64_t tid = GetThisThreadId();
2266 delegateTasks_.SetWorkerThreadId(tid);
2267 MMI_HILOGI("Main worker thread start. tid:%{public}" PRId64 "", tid);
2268 #ifdef OHOS_BUILD_PC_PRIORITY
2269 SetMmiServicePriority();
2270 #endif // OHOS_BUILD_PC_PRIORITY
2271 #ifdef OHOS_RSS_CLIENT
2272 tid_.store(tid);
2273 #endif // OHOS_RSS_CLIENT
2274 PreEventLoop();
2275
2276 while (state_ == ServiceRunningState::STATE_RUNNING) {
2277 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER) && defined(OHOS_BUILD_ENABLE_KEYBOARD)
2278 if (isCesStart_ && !DISPLAY_MONITOR->IsCommonEventSubscriberInit()) {
2279 DISPLAY_MONITOR->InitCommonEventSubscriber();
2280 }
2281 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER && OHOS_BUILD_ENABLE_KEYBOARD
2282 epoll_event ev[MAX_EVENT_SIZE] = {};
2283 int32_t timeout = TimerMgr->CalcNextDelay();
2284 MMI_HILOGD("timeout:%{public}d", timeout);
2285 int32_t count = EpollWait(ev[0], MAX_EVENT_SIZE, timeout, mmiFd_);
2286 for (int32_t i = 0; i < count && state_ == ServiceRunningState::STATE_RUNNING; i++) {
2287 auto mmiEdIter = epollEventMap_.find(ev[i].data.fd);
2288 if (mmiEdIter == epollEventMap_.end()) {
2289 MMI_HILOGW("Invalid event %{public}d %{public}d", ev[i].data.fd, count);
2290 continue;
2291 }
2292 std::shared_ptr<mmi_epoll_event> mmiEd = mmiEdIter->second;
2293 CHKPC(mmiEd);
2294 epoll_event event = ev[i];
2295 if (mmiEd->event_type == EPOLL_EVENT_INPUT) {
2296 CalculateFuntionRunningTime([this, &mmiEd] () { libinputAdapter_.EventDispatch(mmiEd->fd); },
2297 "EPOLL_EVENT_INPUT");
2298 } else if (mmiEd->event_type == EPOLL_EVENT_SOCKET) {
2299 CalculateFuntionRunningTime([this, &event]() { this->OnEpollEvent(event); }, "MMI:EPOLL_EVENT_SOCKET");
2300 } else if (mmiEd->event_type == EPOLL_EVENT_SIGNAL) {
2301 OnSignalEvent(mmiEd->fd);
2302 } else if (mmiEd->event_type == EPOLL_EVENT_ETASK) {
2303 CalculateFuntionRunningTime([this, &event]() { this->OnDelegateTask(event); }, "MMI:EPOLL_EVENT_ETASK");
2304 } else {
2305 MMI_HILOGW("Unknown epoll event type:%{public}d", mmiEd->event_type);
2306 }
2307 }
2308 TimerMgr->ProcessTimers();
2309 if (state_ != ServiceRunningState::STATE_RUNNING) {
2310 break;
2311 }
2312 }
2313 MMI_HILOGI("Main worker thread stop. tid:%{public}" PRId64 "", tid);
2314 }
2315
2316 #ifdef OHOS_BUILD_PC_PRIORITY
SetMmiServicePriority()2317 void MMIService::SetMmiServicePriority()
2318 {
2319 struct sched_param param = {0};
2320 param.sched_priority = PC_PRIORITY;
2321 int32_t schRet = sched_setscheduler(0, SCHED_FIFO, ¶m);
2322 if (schRet != 0) {
2323 MMI_HILOGE("mmi_service Couldn't set SCHED_FIFO, schRet:%{public}d", schRet);
2324 } else {
2325 MMI_HILOGI("The mmi_service set SCHED_FIFO succeed, schRet:%{public}d", schRet);
2326 }
2327 }
2328 #endif // OHOS_BUILD_PC_PRIORITY
2329
PreEventLoop()2330 void MMIService::PreEventLoop()
2331 {
2332 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
2333 SetupTouchGestureHandler();
2334 #endif // defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
2335 libinputAdapter_.ProcessPendingEvents();
2336 }
2337
InitSignalHandler()2338 bool MMIService::InitSignalHandler()
2339 {
2340 CALL_DEBUG_ENTER;
2341 sigset_t mask = { 0 };
2342 int32_t retCode = sigfillset(&mask);
2343 if (retCode < 0) {
2344 MMI_HILOGE("Fill signal set failed:%{public}d", errno);
2345 return false;
2346 }
2347
2348 retCode = sigprocmask(SIG_SETMASK, &mask, nullptr);
2349 if (retCode < 0) {
2350 MMI_HILOGE("Sigprocmask failed:%{public}d", errno);
2351 return false;
2352 }
2353
2354 int32_t fdSignal = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
2355 if (fdSignal < 0) {
2356 MMI_HILOGE("Signal fd failed:%{public}d", errno);
2357 return false;
2358 }
2359
2360 retCode = AddEpoll(EPOLL_EVENT_SIGNAL, fdSignal);
2361 if (retCode < 0) {
2362 MMI_HILOGE("AddEpoll signalFd failed:%{public}d", retCode);
2363 close(fdSignal);
2364 return false;
2365 }
2366 return true;
2367 }
2368
OnSignalEvent(int32_t signalFd)2369 void MMIService::OnSignalEvent(int32_t signalFd)
2370 {
2371 CALL_DEBUG_ENTER;
2372 signalfd_siginfo sigInfo;
2373 int32_t size = ::read(signalFd, &sigInfo, sizeof(signalfd_siginfo));
2374 if (size != static_cast<int32_t>(sizeof(signalfd_siginfo))) {
2375 MMI_HILOGE("Read signal info failed, invalid size:%{public}d, errno:%{public}d", size, errno);
2376 return;
2377 }
2378 int32_t signo = static_cast<int32_t>(sigInfo.ssi_signo);
2379 MMI_HILOGD("Receive signal:%{public}d", signo);
2380 switch (signo) {
2381 case SIGINT:
2382 case SIGQUIT:
2383 case SIGILL:
2384 case SIGABRT:
2385 case SIGBUS:
2386 case SIGFPE:
2387 case SIGKILL:
2388 case SIGSEGV:
2389 case SIGTERM: {
2390 state_ = ServiceRunningState::STATE_EXIT;
2391 break;
2392 }
2393 default: {
2394 break;
2395 }
2396 }
2397 }
2398
AddReloadDeviceTimer()2399 void MMIService::AddReloadDeviceTimer()
2400 {
2401 CALL_DEBUG_ENTER;
2402 TimerMgr->AddTimer(RELOAD_DEVICE_TIME, REPEAT_COUNT, [this]() {
2403 auto deviceIds = INPUT_DEV_MGR->GetInputDeviceIds();
2404 if (deviceIds.empty()) {
2405 libinputAdapter_.ReloadDevice();
2406 }
2407 });
2408 }
2409
Dump(int32_t fd,const std::vector<std::u16string> & args)2410 int32_t MMIService::Dump(int32_t fd, const std::vector<std::u16string> &args)
2411 {
2412 CALL_DEBUG_ENTER;
2413 if (fd < 0) {
2414 MMI_HILOGE("The fd is invalid");
2415 return DUMP_PARAM_ERR;
2416 }
2417 if (args.empty()) {
2418 MMI_HILOGE("The args cannot be empty");
2419 mprintf(fd, "args cannot be empty\n");
2420 MMIEventDump->DumpHelp(fd);
2421 return DUMP_PARAM_ERR;
2422 }
2423 std::vector<std::string> argList = { "" };
2424 std::transform(args.begin(), args.end(), std::back_inserter(argList),
2425 [](const std::u16string &arg) { return Str16ToStr8(arg); });
2426 MMIEventDump->ParseCommand(fd, argList);
2427 return RET_OK;
2428 }
2429
SetMouseCaptureMode(int32_t windowId,bool isCaptureMode)2430 int32_t MMIService::SetMouseCaptureMode(int32_t windowId, bool isCaptureMode)
2431 {
2432 CALL_INFO_TRACE;
2433 int32_t ret = delegateTasks_.PostSyncTask(
2434 [windowId, isCaptureMode] {
2435 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetMouseCaptureMode(windowId, isCaptureMode);
2436 }
2437 );
2438 if (ret != RET_OK) {
2439 MMI_HILOGE("Set capture failed, return:%{public}d", ret);
2440 return ret;
2441 }
2442 return RET_OK;
2443 }
2444
OnGetWindowPid(int32_t windowId,int32_t & windowPid)2445 int32_t MMIService::OnGetWindowPid(int32_t windowId, int32_t &windowPid)
2446 {
2447 CALL_DEBUG_ENTER;
2448 windowPid = WIN_MGR->GetWindowPid(windowId);
2449 if (windowPid == RET_ERR) {
2450 MMI_HILOGE("Get window pid failed");
2451 return RET_ERR;
2452 }
2453 MMI_HILOGD("The windowpid is:%{public}d", windowPid);
2454 return RET_OK;
2455 }
2456
GetWindowPid(int32_t windowId)2457 int32_t MMIService::GetWindowPid(int32_t windowId)
2458 {
2459 CALL_INFO_TRACE;
2460 int32_t windowPid = INVALID_PID;
2461 int32_t ret = delegateTasks_.PostSyncTask(
2462 [this, windowId, &windowPid] {
2463 return this->OnGetWindowPid(windowId, windowPid);
2464 }
2465 );
2466 if (ret != RET_OK) {
2467 MMI_HILOGE("OnGetWindowPid failed, ret:%{public}d", ret);
2468 return ret;
2469 }
2470 MMI_HILOGD("The windowpid is:%{public}d", windowPid);
2471 return windowPid;
2472 }
2473
AppendExtraData(const ExtraData & extraData)2474 int32_t MMIService::AppendExtraData(const ExtraData &extraData)
2475 {
2476 CALL_DEBUG_ENTER;
2477 int32_t ret = delegateTasks_.PostSyncTask(
2478 [extraData] {
2479 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->AppendExtraData(extraData);
2480 }
2481 );
2482 if (ret != RET_OK) {
2483 MMI_HILOGE("Append extra data failed:%{public}d", ret);
2484 }
2485 return ret;
2486 }
2487
EnableInputDevice(bool enable)2488 int32_t MMIService::EnableInputDevice(bool enable)
2489 {
2490 CALL_DEBUG_ENTER;
2491 int32_t ret = delegateTasks_.PostSyncTask(
2492 [enable] {
2493 return ::OHOS::MMI::InputDeviceManager::GetInstance()->OnEnableInputDevice(enable);
2494 }
2495 );
2496 if (ret != RET_OK) {
2497 MMI_HILOGE("OnEnableInputDevice failed:%{public}d", ret);
2498 }
2499 return ret;
2500 }
2501
2502 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
UpdateCombineKeyState(bool enable)2503 int32_t MMIService::UpdateCombineKeyState(bool enable)
2504 {
2505 auto eventSubscriberHandler = InputHandler->GetSubscriberHandler();
2506 CHKPR(eventSubscriberHandler, RET_ERR);
2507 int32_t ret = eventSubscriberHandler->EnableCombineKey(enable);
2508 if (ret != RET_OK) {
2509 MMI_HILOGE("EnableCombineKey is failed in key command:%{public}d", ret);
2510 }
2511
2512 auto eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();
2513 CHKPR(eventKeyCommandHandler, RET_ERR);
2514 ret = eventKeyCommandHandler->EnableCombineKey(enable);
2515 if (ret != RET_OK) {
2516 MMI_HILOGE("EnableCombineKey is failed in key command:%{public}d", ret);
2517 }
2518 return ret;
2519 }
2520 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2521
CheckPidPermission(int32_t pid)2522 int32_t MMIService::CheckPidPermission(int32_t pid)
2523 {
2524 CALL_DEBUG_ENTER;
2525 int32_t checkingPid = GetCallingPid();
2526 if (checkingPid != pid) {
2527 MMI_HILOGE("Check pid failed, input pid:%{public}d, but checking pid:%{public}d", pid, checkingPid);
2528 return RET_ERR;
2529 }
2530 return RET_OK;
2531 }
2532
EnableCombineKey(bool enable)2533 int32_t MMIService::EnableCombineKey(bool enable)
2534 {
2535 CALL_DEBUG_ENTER;
2536 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
2537 int32_t ret = delegateTasks_.PostSyncTask(
2538 [this, enable] {
2539 return this->UpdateCombineKeyState(enable);
2540 }
2541 );
2542 if (ret != RET_OK) {
2543 MMI_HILOGE("Set key down duration failed:%{public}d", ret);
2544 return ret;
2545 }
2546 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2547 return RET_OK;
2548 }
2549
2550 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
UpdateSettingsXml(const std::string & businessId,int32_t delay)2551 int32_t MMIService::UpdateSettingsXml(const std::string &businessId, int32_t delay)
2552 {
2553 std::shared_ptr<KeyCommandHandler> eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();
2554 CHKPR(eventKeyCommandHandler, RET_ERR);
2555 return eventKeyCommandHandler->UpdateSettingsXml(businessId, delay);
2556 }
2557 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2558
SetKeyDownDuration(const std::string & businessId,int32_t delay)2559 int32_t MMIService::SetKeyDownDuration(const std::string &businessId, int32_t delay)
2560 {
2561 CALL_INFO_TRACE;
2562 #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
2563 int32_t ret = delegateTasks_.PostSyncTask(
2564 [this, businessId, delay] {
2565 return this->UpdateSettingsXml(businessId, delay);
2566 }
2567 );
2568 if (ret != RET_OK) {
2569 MMI_HILOGE("Set key down duration failed:%{public}d", ret);
2570 return ret;
2571 }
2572 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
2573 return RET_OK;
2574 }
2575
2576 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadTouchpadScrollSwich(bool & switchFlag)2577 int32_t MMIService::ReadTouchpadScrollSwich(bool &switchFlag)
2578 {
2579 MouseEventHdr->GetTouchpadScrollSwitch(switchFlag);
2580 return RET_OK;
2581 }
2582
ReadTouchpadScrollDirection(bool & switchFlag)2583 int32_t MMIService::ReadTouchpadScrollDirection(bool &switchFlag)
2584 {
2585 MouseEventHdr->GetTouchpadScrollDirection(switchFlag);
2586 return RET_OK;
2587 }
2588
ReadTouchpadTapSwitch(bool & switchFlag)2589 int32_t MMIService::ReadTouchpadTapSwitch(bool &switchFlag)
2590 {
2591 MouseEventHdr->GetTouchpadTapSwitch(switchFlag);
2592 return RET_OK;
2593 }
2594
ReadTouchpadPointerSpeed(int32_t & speed)2595 int32_t MMIService::ReadTouchpadPointerSpeed(int32_t &speed)
2596 {
2597 MouseEventHdr->GetTouchpadPointerSpeed(speed);
2598 return RET_OK;
2599 }
2600
ReadTouchpadCDG(TouchpadCDG & touchpadCDG)2601 int32_t MMIService::ReadTouchpadCDG(TouchpadCDG &touchpadCDG)
2602 {
2603 MouseEventHdr->GetTouchpadCDG(touchpadCDG);
2604 return RET_OK;
2605 }
2606
ReadTouchpadPinchSwitch(bool & switchFlag)2607 int32_t MMIService::ReadTouchpadPinchSwitch(bool &switchFlag)
2608 {
2609 TOUCH_EVENT_HDR->GetTouchpadPinchSwitch(switchFlag);
2610 return RET_OK;
2611 }
2612
ReadTouchpadSwipeSwitch(bool & switchFlag)2613 int32_t MMIService::ReadTouchpadSwipeSwitch(bool &switchFlag)
2614 {
2615 TOUCH_EVENT_HDR->GetTouchpadSwipeSwitch(switchFlag);
2616 return RET_OK;
2617 }
2618
ReadTouchpadRightMenuType(int32_t & type)2619 int32_t MMIService::ReadTouchpadRightMenuType(int32_t &type)
2620 {
2621 MouseEventHdr->GetTouchpadRightClickType(type);
2622 return RET_OK;
2623 }
2624
ReadTouchpadRotateSwitch(bool & rotateSwitch)2625 int32_t MMIService::ReadTouchpadRotateSwitch(bool &rotateSwitch)
2626 {
2627 TOUCH_EVENT_HDR->GetTouchpadRotateSwitch(rotateSwitch);
2628 return RET_OK;
2629 }
2630
ReadTouchpadDoubleTapAndDragState(bool & switchFlag)2631 int32_t MMIService::ReadTouchpadDoubleTapAndDragState(bool &switchFlag)
2632 {
2633 TOUCH_EVENT_HDR->GetTouchpadDoubleTapAndDragState(switchFlag);
2634 return RET_OK;
2635 }
2636
2637 #endif // OHOS_BUILD_ENABLE_POINTER
2638
SetTouchpadScrollSwitch(bool switchFlag)2639 int32_t MMIService::SetTouchpadScrollSwitch(bool switchFlag)
2640 {
2641 CALL_INFO_TRACE;
2642 #if defined OHOS_BUILD_ENABLE_POINTER
2643 int32_t clientPid = GetCallingPid();
2644 int32_t ret = delegateTasks_.PostSyncTask(
2645 [clientPid, switchFlag] {
2646 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadScrollSwitch(clientPid,
2647 switchFlag);
2648 }
2649 );
2650 if (ret != RET_OK) {
2651 MMI_HILOGE("Set touchpad scroll switch failed, return:%{public}d", ret);
2652 return ret;
2653 }
2654 #endif // OHOS_BUILD_ENABLE_POINTER
2655 return RET_OK;
2656 }
2657
GetTouchpadScrollSwitch(bool & switchFlag)2658 int32_t MMIService::GetTouchpadScrollSwitch(bool &switchFlag)
2659 {
2660 CALL_INFO_TRACE;
2661 #ifdef OHOS_BUILD_ENABLE_POINTER
2662 int32_t ret = delegateTasks_.PostSyncTask(
2663 [this, &switchFlag] {
2664 return this->ReadTouchpadScrollSwich(switchFlag);
2665 }
2666 );
2667 if (ret != RET_OK) {
2668 MMI_HILOGE("Get touchpad scroll switch failed, return:%{public}d", ret);
2669 return ret;
2670 }
2671 #endif // OHOS_BUILD_ENABLE_POINTER
2672 return RET_OK;
2673 }
2674
SetTouchpadScrollDirection(bool state)2675 int32_t MMIService::SetTouchpadScrollDirection(bool state)
2676 {
2677 CALL_INFO_TRACE;
2678 #if defined OHOS_BUILD_ENABLE_POINTER
2679 int32_t ret = delegateTasks_.PostSyncTask(
2680 [state] {
2681 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadScrollDirection(state);
2682 }
2683 );
2684 if (ret != RET_OK) {
2685 MMI_HILOGE("Set touchpad scroll direction switch failed, return:%{public}d", ret);
2686 return ret;
2687 }
2688 #endif // OHOS_BUILD_ENABLE_POINTER
2689 return RET_OK;
2690 }
2691
GetTouchpadScrollDirection(bool & state)2692 int32_t MMIService::GetTouchpadScrollDirection(bool &state)
2693 {
2694 CALL_INFO_TRACE;
2695 #ifdef OHOS_BUILD_ENABLE_POINTER
2696 int32_t ret = delegateTasks_.PostSyncTask(
2697 [this, &state] {
2698 return this->ReadTouchpadScrollDirection(state);
2699 }
2700 );
2701 if (ret != RET_OK) {
2702 MMI_HILOGE("Get touchpad scroll direction switch failed, return:%{public}d", ret);
2703 return ret;
2704 }
2705 #endif // OHOS_BUILD_ENABLE_POINTER
2706 return RET_OK;
2707 }
2708
SetTouchpadTapSwitch(bool switchFlag)2709 int32_t MMIService::SetTouchpadTapSwitch(bool switchFlag)
2710 {
2711 CALL_INFO_TRACE;
2712 #if defined OHOS_BUILD_ENABLE_POINTER
2713 int32_t ret = delegateTasks_.PostSyncTask(
2714 [switchFlag] {
2715 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadTapSwitch(switchFlag);
2716 }
2717 );
2718 if (ret != RET_OK) {
2719 MMI_HILOGE("Set touchpad tap switch failed, return:%{public}d", ret);
2720 return ret;
2721 }
2722 #endif // OHOS_BUILD_ENABLE_POINTER
2723 return RET_OK;
2724 }
2725
GetTouchpadTapSwitch(bool & switchFlag)2726 int32_t MMIService::GetTouchpadTapSwitch(bool &switchFlag)
2727 {
2728 CALL_INFO_TRACE;
2729 #ifdef OHOS_BUILD_ENABLE_POINTER
2730 int32_t ret = delegateTasks_.PostSyncTask(
2731 [this, &switchFlag] {
2732 return this->ReadTouchpadTapSwitch(switchFlag);
2733 }
2734 );
2735 if (ret != RET_OK) {
2736 MMI_HILOGE("Get touchpad tap switch failed, return:%{public}d", ret);
2737 return ret;
2738 }
2739 #endif // OHOS_BUILD_ENABLE_POINTER
2740 return RET_OK;
2741 }
2742
SetTouchpadPointerSpeed(int32_t speed)2743 int32_t MMIService::SetTouchpadPointerSpeed(int32_t speed)
2744 {
2745 CALL_INFO_TRACE;
2746 #if defined OHOS_BUILD_ENABLE_POINTER
2747 int32_t ret = delegateTasks_.PostSyncTask(
2748 [speed] {
2749 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadPointerSpeed(speed);
2750 }
2751 );
2752 if (ret != RET_OK) {
2753 MMI_HILOGE("Set touchpad speed failed, return:%{public}d", ret);
2754 return ret;
2755 }
2756 #endif // OHOS_BUILD_ENABLE_POINTER
2757 return RET_OK;
2758 }
2759
GetTouchpadPointerSpeed(int32_t & speed)2760 int32_t MMIService::GetTouchpadPointerSpeed(int32_t &speed)
2761 {
2762 CALL_INFO_TRACE;
2763 #ifdef OHOS_BUILD_ENABLE_POINTER
2764 int32_t ret = delegateTasks_.PostSyncTask(
2765 [this, &speed] {
2766 return this->ReadTouchpadPointerSpeed(speed);
2767 }
2768 );
2769 if (ret != RET_OK) {
2770 MMI_HILOGE("Get touchpad speed failed, return:%{public}d", ret);
2771 return ret;
2772 }
2773 #endif // OHOS_BUILD_ENABLE_POINTER
2774 return RET_OK;
2775 }
2776
GetTouchpadCDG(TouchpadCDG & touchpadCDG)2777 int32_t MMIService::GetTouchpadCDG(TouchpadCDG &touchpadCDG)
2778 {
2779 CALL_INFO_TRACE;
2780 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
2781 int32_t ret = delegateTasks_.PostSyncTask(
2782 [this, &touchpadCDG] {
2783 return this->ReadTouchpadCDG(touchpadCDG);
2784 }
2785 );
2786 if (ret != RET_OK) {
2787 MMI_HILOGE("Get touchpad option failed, return:%{public}d", ret);
2788 return ret;
2789 }
2790 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
2791 return RET_OK;
2792 }
2793
SetTouchpadPinchSwitch(bool switchFlag)2794 int32_t MMIService::SetTouchpadPinchSwitch(bool switchFlag)
2795 {
2796 CALL_INFO_TRACE;
2797 #if defined OHOS_BUILD_ENABLE_POINTER
2798 int32_t ret = delegateTasks_.PostSyncTask(
2799 [switchFlag] {
2800 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadPinchSwitch(switchFlag);
2801 }
2802 );
2803 if (ret != RET_OK) {
2804 MMI_HILOGE("Set touch pad pinch switch failed, return:%{public}d", ret);
2805 return ret;
2806 }
2807 #endif // OHOS_BUILD_ENABLE_POINTER
2808 return RET_OK;
2809 }
2810
GetTouchpadPinchSwitch(bool & switchFlag)2811 int32_t MMIService::GetTouchpadPinchSwitch(bool &switchFlag)
2812 {
2813 CALL_INFO_TRACE;
2814 #ifdef OHOS_BUILD_ENABLE_POINTER
2815 int32_t ret = delegateTasks_.PostSyncTask(
2816 [this, &switchFlag] {
2817 return this->ReadTouchpadPinchSwitch(switchFlag);
2818 }
2819 );
2820 if (ret != RET_OK) {
2821 MMI_HILOGE("Get touch pad pinch switch failed, return:%{public}d", ret);
2822 return ret;
2823 }
2824 #endif // OHOS_BUILD_ENABLE_POINTER
2825 return RET_OK;
2826 }
2827
SetTouchpadSwipeSwitch(bool switchFlag)2828 int32_t MMIService::SetTouchpadSwipeSwitch(bool switchFlag)
2829 {
2830 CALL_INFO_TRACE;
2831 #if defined OHOS_BUILD_ENABLE_POINTER
2832 int32_t ret = delegateTasks_.PostSyncTask(
2833 [switchFlag] {
2834 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadSwipeSwitch(switchFlag);
2835 }
2836 );
2837 if (ret != RET_OK) {
2838 MMI_HILOGE("Set touchpad swipe switch failed, return:%{public}d", ret);
2839 return ret;
2840 }
2841 #endif // OHOS_BUILD_ENABLE_POINTER
2842 return RET_OK;
2843 }
2844
GetTouchpadSwipeSwitch(bool & switchFlag)2845 int32_t MMIService::GetTouchpadSwipeSwitch(bool &switchFlag)
2846 {
2847 CALL_INFO_TRACE;
2848 #ifdef OHOS_BUILD_ENABLE_POINTER
2849 int32_t ret = delegateTasks_.PostSyncTask(
2850 [this, &switchFlag] {
2851 return this->ReadTouchpadSwipeSwitch(switchFlag);
2852 }
2853 );
2854 if (ret != RET_OK) {
2855 MMI_HILOGE("Get touchpad swipe switch failed, return:%{public}d", ret);
2856 return ret;
2857 }
2858 #endif // OHOS_BUILD_ENABLE_POINTER
2859 return RET_OK;
2860 }
2861
SetTouchpadRightClickType(int32_t type)2862 int32_t MMIService::SetTouchpadRightClickType(int32_t type)
2863 {
2864 CALL_INFO_TRACE;
2865 #if defined OHOS_BUILD_ENABLE_POINTER
2866 int32_t ret = delegateTasks_.PostSyncTask(
2867 [type] {
2868 return ::OHOS::DelayedSingleton<MouseEventNormalize>::GetInstance()->SetTouchpadRightClickType(type);
2869 }
2870 );
2871 if (ret != RET_OK) {
2872 MMI_HILOGE("Set touchpad right button menu type failed, return:%{public}d", ret);
2873 return ret;
2874 }
2875 #endif // OHOS_BUILD_ENABLE_POINTER
2876 return RET_OK;
2877 }
2878
GetTouchpadRightClickType(int32_t & type)2879 int32_t MMIService::GetTouchpadRightClickType(int32_t &type)
2880 {
2881 CALL_INFO_TRACE;
2882 #ifdef OHOS_BUILD_ENABLE_POINTER
2883 int32_t ret = delegateTasks_.PostSyncTask(
2884 [this, &type] {
2885 return this->ReadTouchpadRightMenuType(type);
2886 }
2887 );
2888 if (ret != RET_OK) {
2889 MMI_HILOGE("Get touchpad right button menu type failed, return:%{public}d", ret);
2890 return ret;
2891 }
2892 #endif // OHOS_BUILD_ENABLE_POINTER
2893 return RET_OK;
2894 }
2895
SetTouchpadRotateSwitch(bool rotateSwitch)2896 int32_t MMIService::SetTouchpadRotateSwitch(bool rotateSwitch)
2897 {
2898 CALL_INFO_TRACE;
2899 #if defined OHOS_BUILD_ENABLE_POINTER
2900 int32_t ret = delegateTasks_.PostSyncTask(
2901 [rotateSwitch] {
2902 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadRotateSwitch(rotateSwitch);
2903 }
2904 );
2905 if (ret != RET_OK) {
2906 MMI_HILOGE("Set touchpad rotate switch failed, ret:%{public}d", ret);
2907 return ret;
2908 }
2909 #endif // OHOS_BUILD_ENABLE_POINTER
2910 return RET_OK;
2911 }
2912
GetTouchpadRotateSwitch(bool & rotateSwitch)2913 int32_t MMIService::GetTouchpadRotateSwitch(bool &rotateSwitch)
2914 {
2915 CALL_INFO_TRACE;
2916 #ifdef OHOS_BUILD_ENABLE_POINTER
2917 int32_t ret = delegateTasks_.PostSyncTask(
2918 [this, &rotateSwitch] {
2919 return this->ReadTouchpadRotateSwitch(rotateSwitch);
2920 }
2921 );
2922 if (ret != RET_OK) {
2923 MMI_HILOGE("Get touchpad rotate switch failed, ret:%{public}d", ret);
2924 return ret;
2925 }
2926 #endif // OHOS_BUILD_ENABLE_POINTER
2927 return RET_OK;
2928 }
2929
SetTouchpadDoubleTapAndDragState(bool switchFlag)2930 int32_t MMIService::SetTouchpadDoubleTapAndDragState(bool switchFlag)
2931 {
2932 CALL_INFO_TRACE;
2933 #ifdef OHOS_BUILD_ENABLE_POINTER
2934 int32_t ret = delegateTasks_.PostSyncTask(
2935 [switchFlag] {
2936 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadDoubleTapAndDragState(
2937 switchFlag);
2938 }
2939 );
2940 if (ret != RET_OK) {
2941 MMI_HILOGE("Failed to SetTouchpadDoubleTapAndDragState status, ret:%{public}d", ret);
2942 return ret;
2943 }
2944 #endif // OHOS_BUILD_ENABLE_POINTER
2945 return RET_OK;
2946 }
2947
GetTouchpadDoubleTapAndDragState(bool & switchFlag)2948 int32_t MMIService::GetTouchpadDoubleTapAndDragState(bool &switchFlag)
2949 {
2950 CALL_INFO_TRACE;
2951 #ifdef OHOS_BUILD_ENABLE_POINTER
2952 int32_t ret = delegateTasks_.PostSyncTask(
2953 [this, &switchFlag] {
2954 return this->ReadTouchpadDoubleTapAndDragState(switchFlag);
2955 }
2956 );
2957 if (ret != RET_OK) {
2958 MMI_HILOGE("Failed to GetTouchpadDoubleTapAndDragState status, ret:%{public}d", ret);
2959 return ret;
2960 }
2961 #endif // OHOS_BUILD_ENABLE_POINTER
2962 return RET_OK;
2963 }
2964
SetShieldStatus(int32_t shieldMode,bool isShield)2965 int32_t MMIService::SetShieldStatus(int32_t shieldMode, bool isShield)
2966 {
2967 CALL_INFO_TRACE;
2968 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2969 int32_t ret = delegateTasks_.PostSyncTask(
2970 [this, shieldMode, isShield] {
2971 return sMsgHandler_.SetShieldStatus(shieldMode, isShield);
2972 }
2973 );
2974 if (ret != RET_OK) {
2975 MMI_HILOGE("Set shield event interception state failed, return:%{public}d", ret);
2976 return ret;
2977 }
2978 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2979 return RET_OK;
2980 }
2981
GetShieldStatus(int32_t shieldMode,bool & isShield)2982 int32_t MMIService::GetShieldStatus(int32_t shieldMode, bool &isShield)
2983 {
2984 CALL_INFO_TRACE;
2985 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
2986 int32_t ret = delegateTasks_.PostSyncTask(
2987 [this, shieldMode, &isShield] {
2988 return sMsgHandler_.GetShieldStatus(shieldMode, isShield);
2989 }
2990 );
2991 if (ret != RET_OK) {
2992 MMI_HILOGE("Failed to set shield event interception status, ret:%{public}d", ret);
2993 return ret;
2994 }
2995 #endif // OHOS_BUILD_ENABLE_KEYBOARD
2996 return RET_OK;
2997 }
2998
GetKeyState(std::vector<int32_t> & pressedKeys,std::map<int32_t,int32_t> & specialKeysState)2999 int32_t MMIService::GetKeyState(std::vector<int32_t> &pressedKeys, std::map<int32_t, int32_t> &specialKeysState)
3000 {
3001 CALL_INFO_TRACE;
3002 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
3003 int32_t ret = delegateTasks_.PostSyncTask(
3004 [this, &pressedKeys, &specialKeysState] {
3005 return this->OnGetKeyState(pressedKeys, specialKeysState);
3006 }
3007 );
3008 if (ret != RET_OK) {
3009 MMI_HILOGE("Get pressed keys failed, return:%{public}d", ret);
3010 return ret;
3011 }
3012 #endif // OHOS_BUILD_ENABLE_KEYBOARD
3013 return RET_OK;
3014 }
3015
Authorize(bool isAuthorize)3016 int32_t MMIService::Authorize(bool isAuthorize)
3017 {
3018 CALL_DEBUG_ENTER;
3019 int32_t ret = delegateTasks_.PostSyncTask(
3020 [this, isAuthorize] {
3021 return this->OnAuthorize(isAuthorize);
3022 }
3023 );
3024 if (ret != RET_OK) {
3025 MMI_HILOGE("OnAuthorize failed, ret:%{public}d", ret);
3026 return ret;
3027 }
3028 return RET_OK;
3029 }
3030
OnAuthorize(bool isAuthorize)3031 int32_t MMIService::OnAuthorize(bool isAuthorize)
3032 {
3033 return sMsgHandler_.OnAuthorize(isAuthorize);
3034 }
3035
CancelInjection()3036 int32_t MMIService::CancelInjection()
3037 {
3038 CALL_DEBUG_ENTER;
3039 int32_t callPid = GetCallingPid();
3040 int32_t ret = delegateTasks_.PostSyncTask(
3041 [this, callPid] {
3042 return this->OnCancelInjection(callPid);
3043 }
3044 );
3045 if (ret != RET_OK) {
3046 MMI_HILOGE("OnCancelInjection failed, ret:%{public}d", ret);
3047 return ret;
3048 }
3049 return RET_OK;
3050 }
3051
OnCancelInjection(int32_t callPid)3052 int32_t MMIService::OnCancelInjection(int32_t callPid)
3053 {
3054 return sMsgHandler_.OnCancelInjection(callPid);
3055 }
3056
HasIrEmitter(bool & hasIrEmitter)3057 int32_t MMIService::HasIrEmitter(bool &hasIrEmitter)
3058 {
3059 CALL_DEBUG_ENTER;
3060 int32_t ret = delegateTasks_.PostSyncTask(
3061 [this, &hasIrEmitter] {
3062 return this->OnHasIrEmitter(hasIrEmitter);
3063 }
3064 );
3065 if (ret != RET_OK) {
3066 MMI_HILOGE("OnHasIrEmitter failed, ret:%{public}d", ret);
3067 return ret;
3068 }
3069 return RET_OK;
3070 }
3071
GetInfraredFrequencies(std::vector<InfraredFrequency> & frequencies)3072 int32_t MMIService::GetInfraredFrequencies(std::vector<InfraredFrequency>& frequencies)
3073 {
3074 CALL_DEBUG_ENTER;
3075 #ifndef OHOS_BUILD_ENABLE_WATCH
3076 MMI_HILOGI("Start get infrared frequency");
3077 std::vector<InfraredFrequencyInfo> infos;
3078 if (!InfraredEmitterController::GetInstance()->GetFrequencies(infos)) {
3079 MMI_HILOGE("Failed to get frequencies");
3080 return RET_ERR;
3081 }
3082 for (auto &item : infos) {
3083 InfraredFrequency info;
3084 info.min_ = item.min_;
3085 info.max_ = item.max_;
3086 frequencies.push_back(info);
3087 }
3088 std::string context = "";
3089 int32_t size = static_cast<int32_t>(frequencies.size());
3090 for (int32_t i = 0; i < size; i++) {
3091 context = context + "frequencies[" + std::to_string(i) + "]. max=" + std::to_string(frequencies[i].max_) +
3092 ",min=" + std::to_string(frequencies[i].min_) + ";";
3093 }
3094 MMI_HILOGD("Data from hdf context:%{public}s", context.c_str());
3095 #endif // OHOS_BUILD_ENABLE_WATCH
3096 return RET_OK;
3097 }
3098
TransmitInfrared(int64_t number,std::vector<int64_t> & pattern)3099 int32_t MMIService::TransmitInfrared(int64_t number, std::vector<int64_t>& pattern)
3100 {
3101 CALL_DEBUG_ENTER;
3102 #ifndef OHOS_BUILD_ENABLE_WATCH
3103 std::string context = "infraredFrequency:" + std::to_string(number) + ";";
3104 int32_t size = static_cast<int32_t>(pattern.size());
3105 for (int32_t i = 0; i < size; i++) {
3106 context = context + "index:" + std::to_string(i) + ": pattern:" + std::to_string(pattern[i]) + ";";
3107 }
3108 MMI_HILOGI("TransmitInfrared para context:%{public}s", context.c_str());
3109 if (!InfraredEmitterController::GetInstance()->Transmit(number, pattern)) {
3110 MMI_HILOGE("Failed to transmit");
3111 return RET_ERR;
3112 }
3113 #endif // OHOS_BUILD_ENABLE_WATCH
3114 return RET_OK;
3115 }
3116
3117 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
CreateVKeyboardDevice(sptr<IRemoteObject> & vkeyboardDevice)3118 int32_t MMIService::CreateVKeyboardDevice(sptr<IRemoteObject> &vkeyboardDevice)
3119 {
3120 CALL_INFO_TRACE;
3121 isHPR_ = PRODUCT_TYPE == DEVICE_TYPE_HPR;
3122 if (!isHPR_) {
3123 MMI_HILOGE("Failed to create vkeyboard device, feature not support");
3124 return RET_ERR;
3125 }
3126 int32_t ret = RET_OK;
3127 // init keyboard handler
3128 if (g_VKeyboardHandle == nullptr) {
3129 InitVKeyboardFuncHandler();
3130 }
3131 if (g_VKeyboardHandle == nullptr) {
3132 MMI_HILOGE("VKeyboard handler is nullptr");
3133 return RET_ERR;
3134 } else {
3135 ret = delegateTasks_.PostSyncTask(
3136 [this, &vkeyboardDevice] {
3137 return this->OnCreateVKeyboardDevice(vkeyboardDevice);
3138 }
3139 );
3140 if (ret != RET_OK) {
3141 MMI_HILOGE("Failed to create vkeyboard device, ret:%{public}d", ret);
3142 }
3143 }
3144 return ret;
3145 }
3146
OnCreateVKeyboardDevice(sptr<IRemoteObject> & vkeyboardDevice)3147 int32_t MMIService::OnCreateVKeyboardDevice(sptr<IRemoteObject> &vkeyboardDevice)
3148 {
3149 if (g_VKeyboardHandle == nullptr) {
3150 MMI_HILOGE("VKeyboard handler is nullptr");
3151 return RET_ERR;
3152 }
3153 vkeyboard_createVKeyboardDevice_ = (VKEYBOARD_CREATEVKEYBOARDDEVICE_TYPE)dlsym(
3154 g_VKeyboardHandle, "CreateVKeyboardDevice");
3155 IRemoteObject* vkbDevice = nullptr;
3156 int32_t ret = vkeyboard_createVKeyboardDevice_(vkbDevice);
3157 if (ret != RET_OK) {
3158 MMI_HILOGE("Create vkeyboard device failed");
3159 return ret;
3160 }
3161 if (vkbDevice == nullptr) {
3162 MMI_HILOGE("VKeyboard device pointer is nullptr");
3163 return RET_ERR;
3164 }
3165 vkeyboardDevice = sptr(vkbDevice);
3166
3167 vkeyboard_onFuncKeyEvent_ = (VKEYBOARD_ONFUNCKEYEVENT_TYPE)dlsym(
3168 g_VKeyboardHandle, "OnFuncKeyEvent");
3169
3170 auto keyEvent = KeyEventHdr->GetKeyEvent();
3171 CHKPR(keyEvent, ERROR_NULL_POINTER);
3172 if (vkeyboard_onFuncKeyEvent_ != nullptr) {
3173 vkeyboard_onFuncKeyEvent_(keyEvent);
3174 }
3175 return RET_OK;
3176 }
3177
InitVKeyboardFuncHandler()3178 void MMIService::InitVKeyboardFuncHandler()
3179 {
3180 if (isHPR_) {
3181 // Initialize vkeyboard handler
3182 g_VKeyboardHandle = dlopen(VKEYBOARD_PATH.c_str(), RTLD_NOW);
3183 if (g_VKeyboardHandle != nullptr) {
3184 handleTouchPoint_ = (HANDLE_TOUCHPOINT_TYPE)dlsym(g_VKeyboardHandle, "HandleTouchPoint");
3185 statemachineMessageQueue_getLibinputMessage_ = (STATEMACINEMESSAGQUEUE_GETLIBINPUTMESSAGE_TYPE)dlsym(
3186 g_VKeyboardHandle, "StateMachineMessageQueueGetLibinputMessage");
3187 trackPadEngine_getAllTouchMessage_ = (TRACKPADENGINE_GETALLTOUCHMESSAGE_TYPE)dlsym(
3188 g_VKeyboardHandle, "TrackPadEngineGetAllTouchMessage");
3189 trackPadEngine_clearTouchMessage_ = (TRACKPADENGINE_CLEARTOUCHMESSAGE_TYPE)dlsym(
3190 g_VKeyboardHandle, "TrackPadEngineClearTouchMessage");
3191 trackPadEngine_getAllKeyMessage_ = (TRACKPADENGINE_GETALLKEYMESSAGE_TYPE)dlsym(
3192 g_VKeyboardHandle, "TrackPadEngineGetAllKeyMessage");
3193 trackPadEngine_clearKeyMessage_ = (TRACKPADENGINE_CLEARKEYMESSAGE_TYPE)dlsym(
3194 g_VKeyboardHandle, "TrackPadEngineClearKeyMessage");
3195 vkeyboard_hardwareKeyEventDetected_ = (VKEYBOARD_HARDWAREKEYEVENTDETECTED_TYPE)dlsym(
3196 g_VKeyboardHandle, "HardwareKeyEventDetected");
3197 vkeyboard_getKeyboardActivationState_ = (VKEYBOARD_GETKEYBOARDACTIVATIONSTATE_TYPE)dlsym(
3198 g_VKeyboardHandle, "GetKeyboardActivationState");
3199
3200 libinputAdapter_.InitVKeyboard(handleTouchPoint_,
3201 statemachineMessageQueue_getLibinputMessage_,
3202 trackPadEngine_getAllTouchMessage_,
3203 trackPadEngine_clearTouchMessage_,
3204 trackPadEngine_getAllKeyMessage_,
3205 trackPadEngine_clearKeyMessage_,
3206 vkeyboard_hardwareKeyEventDetected_,
3207 vkeyboard_getKeyboardActivationState_);
3208 }
3209 }
3210 }
3211 #endif // OHOS_BUILD_ENABLE_VKEYBOARD
3212
OnHasIrEmitter(bool & hasIrEmitter)3213 int32_t MMIService::OnHasIrEmitter(bool &hasIrEmitter)
3214 {
3215 hasIrEmitter = false;
3216 return RET_OK;
3217 }
3218
SetPixelMapData(int32_t infoId,void * pixelMap)3219 int32_t MMIService::SetPixelMapData(int32_t infoId, void* pixelMap)
3220 {
3221 CALL_DEBUG_ENTER;
3222 CHKPR(pixelMap, ERROR_NULL_POINTER);
3223 int32_t ret = delegateTasks_.PostSyncTask(
3224 [this, infoId, pixelMap] {
3225 return sMsgHandler_.SetPixelMapData(infoId, pixelMap);
3226 }
3227 );
3228 if (ret != RET_OK) {
3229 MMI_HILOGE("Failed to set pixelmap, ret:%{public}d", ret);
3230 return ret;
3231 }
3232 return RET_OK;
3233 }
3234
InitPreferences()3235 void MMIService::InitPreferences()
3236 {
3237 PREFERENCES_MGR->InitPreferences();
3238 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
3239 int32_t ret = SetMoveEventFilters(PREFERENCES_MGR->GetBoolValue("moveEventFilterFlag", false));
3240 if (ret != RET_OK) {
3241 MMI_HILOGE("Failed to read moveEventFilterFlag, ret:%{public}d", ret);
3242 }
3243 #endif // OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
3244 }
3245
SetMoveEventFilters(bool flag)3246 int32_t MMIService::SetMoveEventFilters(bool flag)
3247 {
3248 CALL_DEBUG_ENTER;
3249 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
3250 int32_t ret = delegateTasks_.PostSyncTask(
3251 std::bind(&InputEventHandler::SetMoveEventFilters, InputHandler, flag));
3252 if (ret != RET_OK) {
3253 MMI_HILOGE("Failed to set move event filter flag, ret:%{public}d", ret);
3254 return ret;
3255 }
3256 #endif // OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
3257 return RET_OK;
3258 }
3259
SetCurrentUser(int32_t userId)3260 int32_t MMIService::SetCurrentUser(int32_t userId)
3261 {
3262 CALL_DEBUG_ENTER;
3263 int32_t ret = delegateTasks_.PostSyncTask(
3264 [userId] {
3265 return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetCurrentUser(userId);
3266 }
3267 );
3268 if (ret != RET_OK) {
3269 MMI_HILOGE("Failed to set current user, ret:%{public}d", ret);
3270 return ret;
3271 }
3272 auto eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();
3273 CHKPR(eventKeyCommandHandler, RET_ERR);
3274 ret = delegateTasks_.PostSyncTask(
3275 [userId, eventKeyCommandHandler] {
3276 return eventKeyCommandHandler->RegisterKnuckleSwitchByUserId(userId);
3277 }
3278 );
3279 if (ret != RET_OK) {
3280 MMI_HILOGE("Failed to set current user, ret:%{public}d", ret);
3281 return ret;
3282 }
3283 return RET_OK;
3284 }
3285
SetTouchpadThreeFingersTapSwitch(bool switchFlag)3286 int32_t MMIService::SetTouchpadThreeFingersTapSwitch(bool switchFlag)
3287 {
3288 CALL_INFO_TRACE;
3289 #ifdef OHOS_BUILD_ENABLE_POINTER
3290 int32_t ret = delegateTasks_.PostSyncTask(
3291 [switchFlag] {
3292 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadThreeFingersTapSwitch(
3293 switchFlag);
3294 }
3295 );
3296 if (ret != RET_OK) {
3297 MMI_HILOGE("Failed to SetTouchpadThreeFingersTapSwitch status, ret:%{public}d", ret);
3298 return ret;
3299 }
3300 #endif // OHOS_BUILD_ENABLE_POINTER
3301 return RET_OK;
3302 }
3303
GetTouchpadThreeFingersTapSwitch(bool & switchFlag)3304 int32_t MMIService::GetTouchpadThreeFingersTapSwitch(bool &switchFlag)
3305 {
3306 CALL_INFO_TRACE;
3307 #ifdef OHOS_BUILD_ENABLE_POINTER
3308 int32_t ret = delegateTasks_.PostSyncTask(
3309 [&switchFlag] {
3310 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->GetTouchpadThreeFingersTapSwitch(
3311 switchFlag);
3312 }
3313 );
3314 if (ret != RET_OK) {
3315 MMI_HILOGE("Failed to GetTouchpadThreeFingersTapSwitch status, ret:%{public}d", ret);
3316 return ret;
3317 }
3318 #endif // OHOS_BUILD_ENABLE_POINTER
3319 return RET_OK;
3320 }
3321
AddVirtualInputDevice(std::shared_ptr<InputDevice> device,int32_t & deviceId)3322 int32_t MMIService::AddVirtualInputDevice(std::shared_ptr<InputDevice> device, int32_t &deviceId)
3323 {
3324 CALL_DEBUG_ENTER;
3325 CHKPR(device, ERROR_NULL_POINTER);
3326 int32_t ret = delegateTasks_.PostSyncTask(
3327 [device, &deviceId] {
3328 return ::OHOS::MMI::InputDeviceManager::GetInstance()->AddVirtualInputDevice(device, deviceId);
3329 }
3330 );
3331 if (ret != RET_OK) {
3332 MMI_HILOGE("AddVirtualInputDevice failed:%{public}d", ret);
3333 }
3334 return ret;
3335 }
3336
RemoveVirtualInputDevice(int32_t deviceId)3337 int32_t MMIService::RemoveVirtualInputDevice(int32_t deviceId)
3338 {
3339 CALL_DEBUG_ENTER;
3340 int32_t ret = delegateTasks_.PostSyncTask(
3341 [deviceId] {
3342 return ::OHOS::MMI::InputDeviceManager::GetInstance()->RemoveVirtualInputDevice(deviceId);
3343 }
3344 );
3345 if (ret != RET_OK) {
3346 MMI_HILOGE("RemoveVirtualInputDevice failed:%{public}d", ret);
3347 }
3348 return ret;
3349 }
3350
EnableHardwareCursorStats(bool enable)3351 int32_t MMIService::EnableHardwareCursorStats(bool enable)
3352 {
3353 CALL_DEBUG_ENTER;
3354 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
3355 int32_t pid = GetCallingPid();
3356 int32_t ret = delegateTasks_.PostSyncTask(
3357 [pid, enable] {
3358 return IPointerDrawingManager::GetInstance()->EnableHardwareCursorStats(pid, enable);
3359 }
3360 );
3361 if (ret != RET_OK) {
3362 MMI_HILOGE("Enable hardware cursor stats failed, ret:%{public}d", ret);
3363 return ret;
3364 }
3365 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
3366 return RET_OK;
3367 }
3368
GetHardwareCursorStats(uint32_t & frameCount,uint32_t & vsyncCount)3369 int32_t MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsyncCount)
3370 {
3371 CALL_DEBUG_ENTER;
3372 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
3373 int32_t pid = GetCallingPid();
3374 int32_t ret = delegateTasks_.PostSyncTask(
3375 [pid, &frameCount, &vsyncCount] {
3376 return IPointerDrawingManager::GetInstance()->GetHardwareCursorStats(pid, frameCount, vsyncCount);
3377 }
3378 );
3379 if (ret != RET_OK) {
3380 MMI_HILOGE("Get hardware cursor stats failed, ret:%{public}d", ret);
3381 return ret;
3382 }
3383 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
3384 return RET_OK;
3385 }
3386
3387 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
GetPointerSnapshot(void * pixelMapPtr)3388 int32_t MMIService::GetPointerSnapshot(void *pixelMapPtr)
3389 {
3390 CALL_INFO_TRACE;
3391 #if defined OHOS_BUILD_ENABLE_POINTER
3392 MMI_HILOGI("Get pointer snapshot from process(%{public}d)", GetCallingPid());
3393 int32_t ret = delegateTasks_.PostSyncTask(std::bind(
3394 std::bind(&IPointerDrawingManager::GetPointerSnapshot, IPointerDrawingManager::GetInstance(), pixelMapPtr)));
3395 if (ret != RET_OK) {
3396 MMI_HILOGE("Get the pointer snapshot failed, ret:%{public}d", ret);
3397 return ret;
3398 }
3399 #endif // OHOS_BUILD_ENABLE_POINTER
3400 return RET_OK;
3401 }
3402 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
3403
SetTouchpadScrollRows(int32_t rows)3404 int32_t MMIService::SetTouchpadScrollRows(int32_t rows)
3405 {
3406 CALL_INFO_TRACE;
3407 #ifdef OHOS_BUILD_ENABLE_POINTER
3408 int32_t ret = delegateTasks_.PostSyncTask(
3409 [rows] {
3410 return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadScrollRows(rows);
3411 }
3412 );
3413 if (ret != RET_OK) {
3414 MMI_HILOGE("Set the number of touchpad scrolling rows failed, return %{public}d", ret);
3415 return ret;
3416 }
3417 #endif // OHOS_BUILD_ENABLE_POINTER
3418 return RET_OK;
3419 }
3420
3421 #ifdef OHOS_BUILD_ENABLE_POINTER
ReadTouchpadScrollRows(int32_t & rows)3422 int32_t MMIService::ReadTouchpadScrollRows(int32_t &rows)
3423 {
3424 rows = TOUCH_EVENT_HDR->GetTouchpadScrollRows();
3425 return RET_OK;
3426 }
3427 #endif // OHOS_BUILD_ENABLE_POINTER
3428
GetTouchpadScrollRows(int32_t & rows)3429 int32_t MMIService::GetTouchpadScrollRows(int32_t &rows)
3430 {
3431 CALL_INFO_TRACE;
3432 #ifdef OHOS_BUILD_ENABLE_POINTER
3433 int32_t ret = delegateTasks_.PostSyncTask(
3434 [this, &rows] {
3435 return this->ReadTouchpadScrollRows(rows);
3436 }
3437 );
3438 if (ret != RET_OK) {
3439 MMI_HILOGE("Get the number of touchpad scrolling rows failed, return %{public}d, pid:%{public}d", ret,
3440 GetCallingPid());
3441 return ret;
3442 }
3443 #endif // OHOS_BUILD_ENABLE_POINTER
3444 return RET_OK;
3445 }
3446
3447 #ifdef OHOS_BUILD_ENABLE_ANCO
AncoAddChannel(sptr<IAncoChannel> channel)3448 int32_t MMIService::AncoAddChannel(sptr<IAncoChannel> channel)
3449 {
3450 int32_t ret = delegateTasks_.PostSyncTask([channel]() {
3451 return WIN_MGR->AncoAddChannel(channel);
3452 });
3453 if (ret != RET_OK) {
3454 MMI_HILOGE("AncoAddChannel fail, error:%{public}d", ret);
3455 }
3456 SyncKnuckleStatus();
3457 return ret;
3458 }
3459
AncoRemoveChannel(sptr<IAncoChannel> channel)3460 int32_t MMIService::AncoRemoveChannel(sptr<IAncoChannel> channel)
3461 {
3462 int32_t ret = delegateTasks_.PostSyncTask([channel]() {
3463 return WIN_MGR->AncoRemoveChannel(channel);
3464 });
3465 if (ret != RET_OK) {
3466 MMI_HILOGE("AncoRemoveChannel fail, error:%{public}d", ret);
3467 }
3468 return ret;
3469 }
3470 #endif // OHOS_BUILD_ENABLE_ANCO
3471
TransferBinderClientSrv(const sptr<IRemoteObject> & binderClientObject)3472 int32_t MMIService::TransferBinderClientSrv(const sptr<IRemoteObject> &binderClientObject)
3473 {
3474 CALL_DEBUG_ENTER;
3475 int32_t pid = GetCallingPid();
3476 int32_t ret =
3477 delegateTasks_.PostSyncTask(
3478 [this, pid, binderClientObject] {
3479 return sMsgHandler_.OnTransferBinderClientSrv(binderClientObject, pid);
3480 }
3481 );
3482 MMI_HILOGI("TransferBinderClientSrv result:%{public}d", ret);
3483 return ret;
3484 }
3485
CalculateFuntionRunningTime(std::function<void ()> func,const std::string & flag)3486 void MMIService::CalculateFuntionRunningTime(std::function<void()> func, const std::string &flag)
3487 {
3488 std::function<void (void *)> printLog = std::bind(&MMIService::PrintLog, this, flag, THREAD_BLOCK_TIMER_SPAN_S,
3489 getpid(), gettid());
3490 int32_t id = HiviewDFX::XCollie::GetInstance().SetTimer(flag, THREAD_BLOCK_TIMER_SPAN_S, printLog, nullptr,
3491 HiviewDFX::XCOLLIE_FLAG_NOOP);
3492 func();
3493 HiviewDFX::XCollie::GetInstance().CancelTimer(id);
3494 }
3495
PrintLog(const std::string & flag,int32_t duration,int32_t pid,int32_t tid)3496 void MMIService::PrintLog(const std::string &flag, int32_t duration, int32_t pid, int32_t tid)
3497 {
3498 std::string dfxThreadBlockMsg { "MMIBlockTask name:" };
3499 dfxThreadBlockMsg += flag;
3500 dfxThreadBlockMsg += ", duration time:";
3501 dfxThreadBlockMsg += std::to_string(duration);
3502 dfxThreadBlockMsg += ", pid:";
3503 dfxThreadBlockMsg += std::to_string(pid);
3504 dfxThreadBlockMsg += ", tid:";
3505 dfxThreadBlockMsg += std::to_string(tid);
3506 MMI_HILOGW("DfxThreadBlockMsg:%{public}s", dfxThreadBlockMsg.c_str());
3507 OHOS::HiviewDFX::DfxDumpCatcher dumpCatcher;
3508 dumpCatcher.DumpCatch(pid, tid, dfxThreadBlockMsg, MAX_FRAME_NUMS, false);
3509 MMI_HILOGW("BlockMsg:%{public}s", dfxThreadBlockMsg.c_str());
3510 }
3511
SkipPointerLayer(bool isSkip)3512 int32_t MMIService::SkipPointerLayer(bool isSkip)
3513 {
3514 CALL_INFO_TRACE;
3515 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
3516 int32_t ret = delegateTasks_.PostSyncTask(
3517 [isSkip] {
3518 return IPointerDrawingManager::GetInstance()->SkipPointerLayer(isSkip);
3519 }
3520 );
3521 if (ret != RET_OK) {
3522 MMI_HILOGE("Skip pointer layerfailed, return:%{public}d", ret);
3523 return ret;
3524 }
3525 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
3526 return RET_OK;
3527 }
3528
OnSessionDelete(SessionPtr session)3529 void MMIService::OnSessionDelete(SessionPtr session)
3530 {
3531 CALL_DEBUG_ENTER;
3532 CHKPV(session);
3533 std::string programName = session->GetProgramName();
3534 std::lock_guard<std::mutex> guard(mutex_);
3535 auto it = clientInfos_.find(programName);
3536 if (it != clientInfos_.end()) {
3537 clientInfos_.erase(it);
3538 MMI_HILOGD("Clear the client info, programName:%{public}s", programName.c_str());
3539 }
3540 }
3541
SetClientInfo(int32_t pid,uint64_t readThreadId)3542 int32_t MMIService::SetClientInfo(int32_t pid, uint64_t readThreadId)
3543 {
3544 CALL_DEBUG_ENTER;
3545 auto sess = GetSessionByPid(pid);
3546 CHKPR(sess, ERROR_NULL_POINTER);
3547 std::string programName = sess->GetProgramName();
3548 std::lock_guard<std::mutex> guard(mutex_);
3549 if (clientInfos_.find(programName) != clientInfos_.end()) {
3550 clientInfos_[programName].pid = pid;
3551 clientInfos_[programName].readThreadId = readThreadId;
3552 return RET_OK;
3553 }
3554 ClientInfo clientInfo {
3555 .pid = pid,
3556 .readThreadId = readThreadId
3557 };
3558 clientInfos_[programName] = clientInfo;
3559 return RET_OK;
3560 }
3561
InitPrintClientInfo()3562 void MMIService::InitPrintClientInfo()
3563 {
3564 CALL_DEBUG_ENTER;
3565 TimerMgr->AddLongTimer(PRINT_INTERVAL_TIME, -1, [this]() {
3566 ffrt::submit([this] {
3567 std::lock_guard<std::mutex> guard(mutex_);
3568 for (const auto &info : clientInfos_) {
3569 if (static_cast<uint64_t>(info.second.pid) == info.second.readThreadId) {
3570 MMI_HILOGW("The application main thread and event reading thread are combined, such as:"
3571 "programName:%{public}s, pid:%{public}d, mainThreadId:%{public}d, readThreadId:%{public}" PRIu64,
3572 info.first.c_str(), info.second.pid, info.second.pid, info.second.readThreadId);
3573 return;
3574 }
3575 }
3576 if (!clientInfos_.empty()) {
3577 auto it = clientInfos_.begin();
3578 MMI_HILOGI("The application main thread and event reading thread are separated, such as:"
3579 "programName:%{public}s, pid:%{public}d, mainThreadId:%{public}d, readThreadId:%{public}" PRIu64,
3580 it->first.c_str(), it->second.pid, it->second.pid, it->second.readThreadId);
3581 }
3582 });
3583 });
3584 std::function<void(SessionPtr)> callback = [this](SessionPtr sess) {
3585 return this->OnSessionDelete(sess);
3586 };
3587 AddSessionDeletedCallback(callback);
3588 }
3589
GetIntervalSinceLastInput(int64_t & timeInterval)3590 int32_t MMIService::GetIntervalSinceLastInput(int64_t &timeInterval)
3591 {
3592 CALL_INFO_TRACE;
3593 int32_t ret = delegateTasks_.PostSyncTask(std::bind(&InputEventHandler::GetIntervalSinceLastInput,
3594 InputHandler, std::ref(timeInterval)));
3595 MMI_HILOGD("timeInterval:%{public}" PRId64, timeInterval);
3596 if (ret != RET_OK) {
3597 MMI_HILOGE("Failed to GetIntervalSinceLastInput, ret:%{public}d", ret);
3598 }
3599 return ret;
3600 }
3601
GetAllSystemHotkeys(std::vector<std::unique_ptr<KeyOption>> & keyOptions)3602 int32_t MMIService::GetAllSystemHotkeys(std::vector<std::unique_ptr<KeyOption>> &keyOptions)
3603 {
3604 CALL_DEBUG_ENTER;
3605 int32_t ret = delegateTasks_.PostSyncTask(
3606 [this, &keyOptions] {
3607 return this->OnGetAllSystemHotkey(keyOptions);
3608 }
3609 );
3610 if (ret != RET_OK) {
3611 MMI_HILOGD("Get all system hot key, ret:%{public}d", ret);
3612 return ret;
3613 }
3614 return RET_OK;
3615 }
3616
OnGetAllSystemHotkey(std::vector<std::unique_ptr<KeyOption>> & keyOptions)3617 int32_t MMIService::OnGetAllSystemHotkey(std::vector<std::unique_ptr<KeyOption>> &keyOptions)
3618 {
3619 CALL_DEBUG_ENTER;
3620 #ifdef SHORTCUT_KEY_MANAGER_ENABLED
3621 return KEY_SHORTCUT_MGR->GetAllSystemHotkeys(keyOptions);
3622 #endif // SHORTCUT_KEY_MANAGER_ENABLED
3623 MMI_HILOGI("OnGetAllSystemHotkey function does not support");
3624 return ERROR_UNSUPPORT;
3625 }
3626
3627 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
SetupTouchGestureHandler()3628 void MMIService::SetupTouchGestureHandler()
3629 {
3630 touchGestureMgr_ = std::make_shared<TouchGestureManager>(delegateInterface_);
3631 WIN_MGR->AttachTouchGestureMgr(touchGestureMgr_);
3632 }
3633 #endif // defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
3634
SetInputDeviceEnable(int32_t deviceId,bool enable,int32_t index,int32_t pid,SessionPtr sess)3635 int32_t MMIService::SetInputDeviceEnable(int32_t deviceId, bool enable, int32_t index, int32_t pid, SessionPtr sess)
3636 {
3637 CALL_INFO_TRACE;
3638 CHKPR(sess, RET_ERR);
3639 int32_t ret = INPUT_DEV_MGR->SetInputDeviceEnabled(deviceId, enable, index, pid, sess);
3640 if (RET_OK != ret) {
3641 MMI_HILOGE("Set inputdevice enabled failed, return:%{public}d", ret);
3642 return ret;
3643 }
3644 return RET_OK;
3645 }
3646
SetInputDeviceEnabled(int32_t deviceId,bool enable,int32_t index)3647 int32_t MMIService::SetInputDeviceEnabled(int32_t deviceId, bool enable, int32_t index)
3648 {
3649 CALL_INFO_TRACE;
3650 int32_t pid = GetCallingPid();
3651 auto sess = GetSessionByPid(pid);
3652 int32_t ret = delegateTasks_.PostAsyncTask(
3653 [this, deviceId, enable, index, pid, sess] {
3654 return this->SetInputDeviceEnable(deviceId, enable, index, pid, sess);
3655 }
3656 );
3657 if (ret != RET_OK) {
3658 MMI_HILOGE("Set inputdevice enable failed, return:%{public}d", ret);
3659 return ret;
3660 }
3661 return RET_OK;
3662 }
3663
ShiftAppPointerEvent(const ShiftWindowParam & param,bool autoGenDown)3664 int32_t MMIService::ShiftAppPointerEvent(const ShiftWindowParam ¶m, bool autoGenDown)
3665 {
3666 CALL_DEBUG_ENTER;
3667 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
3668 int32_t ret = delegateTasks_.PostSyncTask(
3669 [param, autoGenDown]() {
3670 return WIN_MGR->ShiftAppPointerEvent(param, autoGenDown);
3671 }
3672 );
3673 if (ret != RET_OK) {
3674 MMI_HILOGE("Shift AppPointerEvent failed, return:%{public}d", ret);
3675 return ret;
3676 }
3677 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
3678 return RET_OK;
3679 }
3680
SetCustomCursor(int32_t windowId,CustomCursor cursor,CursorOptions options)3681 int32_t MMIService::SetCustomCursor(int32_t windowId, CustomCursor cursor, CursorOptions options)
3682 {
3683 CALL_INFO_TRACE;
3684 int32_t pid = GetCallingPid();
3685 int32_t ret = delegateTasks_.PostSyncTask(std::bind(
3686 [pid, windowId] {
3687 return WIN_MGR->CheckWindowIdPermissionByPid(windowId, pid);
3688 })
3689 );
3690 if (windowId > 0 && ret != RET_OK) {
3691 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
3692 return ERROR_WINDOW_ID_PERMISSION_DENIED;
3693 }
3694 #if defined OHOS_BUILD_ENABLE_POINTER
3695 ret = delegateTasks_.PostSyncTask(std::bind(
3696 [pid, windowId, cursor, options] {
3697 return IPointerDrawingManager::GetInstance()->SetCustomCursor(pid, windowId, cursor, options);
3698 }
3699 ));
3700 if (ret != RET_OK) {
3701 MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
3702 return ret;
3703 }
3704 #endif // OHOS_BUILD_ENABLE_POINTER
3705 return RET_OK;
3706 }
3707
3708 #ifdef OHOS_BUILD_ENABLE_ANCO
CheckKnuckleEvent(float pointX,float pointY,bool & isKnuckleType)3709 int32_t MMIService::CheckKnuckleEvent(float pointX, float pointY, bool &isKnuckleType)
3710 {
3711 CALL_INFO_TRACE;
3712 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER)
3713 int tryTimes = RETRY_CHECK_TIMES;
3714 int32_t ret = RET_ERR;
3715 for (int count = 0; count < tryTimes; ++count) {
3716 ret = FINGERSENSE_WRAPPER->CheckKnuckleEvent(pointX, pointY, isKnuckleType);
3717 if (ret == RET_OK) {
3718 break;
3719 }
3720 std::this_thread::sleep_for(std::chrono::microseconds(CHECK_EEVENT_INTERVAL_TIME));
3721 }
3722 return ret;
3723 #endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
3724 return RET_OK;
3725 }
3726
SyncKnuckleStatus()3727 int32_t MMIService::SyncKnuckleStatus()
3728 {
3729 CALL_DEBUG_ENTER;
3730 int ret = delegateTasks_.PostSyncTask([] {
3731 auto keyHandler = InputHandler->GetKeyCommandHandler();
3732 if (keyHandler == nullptr) {
3733 return RET_ERR;
3734 }
3735 bool isKnuckleEnable = !keyHandler->SkipKnuckleDetect();
3736 return WIN_MGR->SyncKnuckleStatus(isKnuckleEnable);
3737 });
3738 if (ret != RET_OK) {
3739 MMI_HILOGE("post sync knuckle status fail, ret:%{public}d", ret);
3740 }
3741 return ret;
3742 }
3743 #endif
3744
SetMultiWindowScreenId(uint64_t screenId,uint64_t displayNodeScreenId)3745 int32_t MMIService::SetMultiWindowScreenId(uint64_t screenId, uint64_t displayNodeScreenId)
3746 {
3747 TOUCH_DRAWING_MGR->SetMultiWindowScreenId(screenId, displayNodeScreenId);
3748 return RET_OK;
3749 }
3750 } // namespace MMI
3751 } // namespace OHOS
3752