From a485b68e5e12a7afe63a55f18aba90c664b886e5 Mon Sep 17 00:00:00 2001 From: Dragon51 Date: Fri, 18 Apr 2025 16:11:49 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A4=9A=E6=A8=A1=E8=BE=93=E5=85=A5IDL?= =?UTF-8?q?=E5=8C=96=E6=8B=86=E5=88=86006=5Fservice=5Fmodule=5Floader=5F00?= =?UTF-8?q?2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Dragon51 --- service/module_loader/src/mmi_service.cpp | 539 +++++++++++++++++++--- 1 file changed, 465 insertions(+), 74 deletions(-) diff --git a/service/module_loader/src/mmi_service.cpp b/service/module_loader/src/mmi_service.cpp index 6e07ea4c7..19900e314 100644 --- a/service/module_loader/src/mmi_service.cpp +++ b/service/module_loader/src/mmi_service.cpp @@ -1383,9 +1383,18 @@ int32_t MMIService::GetKeyboardRepeatDelay(int32_t &delay) return RET_OK; } -int32_t MMIService::GetKeyboardRepeatRate(int32_t &rate) +ErrCode MMIService::GetKeyboardRepeatRate(int32_t &rate) { CALL_INFO_TRACE; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + rate = 0; #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t ret = delegateTasks_.PostSyncTask( [&rate] { @@ -1411,26 +1420,58 @@ int32_t MMIService::CheckAddInput(int32_t pid, InputHandlerType handlerType, Han #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR -int32_t MMIService::AddInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority, - uint32_t deviceTags, std::vector actionsType) +ErrCode MMIService::AddInputHandler(int32_t handlerType, uint32_t eventType, int32_t priority, + uint32_t deviceTags, const std::vector& actionsType) { CALL_INFO_TRACE; bool isRegisterCaptureCb = false; + InputHandlerType hType = static_cast(handlerType); + HandleEventType eType = static_cast(eventType); + if (!PER_HELPER->VerifySystemApp()) { + if (hType == InputHandlerType::MONITOR) { +#ifdef PLAYER_FRAMEWORK_EXISTS + int32_t pid = GetCallingPid(); + bool ret = InputScreenCaptureAgent::GetInstance().IsScreenCaptureWorking(pid); + if (!ret) { + MMI_HILOGE("Calling pid is:%{public}d", pid); + return ERROR_NO_PERMISSION; + } +#else + return ERROR_NOT_SYSAPI; +#endif + } else if (hType != InputHandlerType::INTERCEPTOR) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + } + + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if ((hType == InputHandlerType::INTERCEPTOR) && (!PER_HELPER->CheckInterceptor())) { + MMI_HILOGE("Interceptor permission check failed"); + return ERROR_NO_PERMISSION; + } + if ((hType == InputHandlerType::MONITOR) && (!PER_HELPER->CheckMonitor())) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS) - if (!PER_HELPER->VerifySystemApp() && handlerType == InputHandlerType::MONITOR) { + if (!PER_HELPER->VerifySystemApp() && hType == InputHandlerType::MONITOR) { isRegisterCaptureCb = true; } #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR) int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, handlerType, eventType, priority, deviceTags, isRegisterCaptureCb] { + [this, pid, hType, eType, priority, deviceTags, isRegisterCaptureCb] { if (isRegisterCaptureCb) { #if defined(OHOS_BUILD_ENABLE_MONITOR) && defined(PLAYER_FRAMEWORK_EXISTS) RegisterScreenCaptureCallback(); #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS } - return this->CheckAddInput(pid, handlerType, eventType, priority, deviceTags); + return this->CheckAddInput(pid, hType, eType, priority, deviceTags); }); if (ret != RET_OK) { MMI_HILOGE("Add input handler failed, ret:%{public}d", ret); @@ -1445,17 +1486,29 @@ int32_t MMIService::AddInputHandler(InputHandlerType handlerType, HandleEventTyp return RET_OK; } -int32_t MMIService::AddPreInputHandler(int32_t handlerId, HandleEventType eventType, std::vector keys) +ErrCode MMIService::AddPreInputHandler(int32_t handlerId, uint32_t eventType, const std::vector& keys) { CALL_DEBUG_ENTER; + if (!PER_HELPER->VerifySystemApp()) { + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->CheckMonitor()) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } + HandleEventType eType = static_cast(eventType); #ifdef OHOS_BUILD_ENABLE_MONITOR int32_t pid = GetCallingPid(); - int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId, eventType, keys] () -> int32_t { + int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId, eType, keys] () -> int32_t { auto sess = GetSessionByPid(pid); CHKPR(sess, ERROR_NULL_POINTER); auto preMonitorHandler = InputHandler->GetEventPreMonitorHandler(); CHKPR(preMonitorHandler, RET_ERR); - return preMonitorHandler->AddInputHandler(sess, handlerId, eventType, keys); + return preMonitorHandler->AddInputHandler(sess, handlerId, eType, keys); }); if (ret != RET_OK) { MMI_HILOGE("The AddPreInputHandler key event processed failed, ret:%{public}d", ret); @@ -1465,9 +1518,20 @@ int32_t MMIService::AddPreInputHandler(int32_t handlerId, HandleEventType eventT return RET_OK; } -int32_t MMIService::RemovePreInputHandler(int32_t handlerId) +ErrCode MMIService::RemovePreInputHandler(int32_t handlerId) { CALL_DEBUG_ENTER; + if (!PER_HELPER->VerifySystemApp()) { + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->CheckMonitor()) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } #ifdef OHOS_BUILD_ENABLE_MONITOR int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask([this, pid, handlerId] () -> int32_t { @@ -1516,15 +1580,35 @@ int32_t MMIService::ObserverAddInputHandler(int32_t pid) } #endif // OHOS_BUILD_ENABLE_INTERCEPTOR || OHOS_BUILD_ENABLE_MONITOR -int32_t MMIService::RemoveInputHandler(InputHandlerType handlerType, HandleEventType eventType, int32_t priority, - uint32_t deviceTags, std::vector actionsType) +ErrCode MMIService::RemoveInputHandler(int32_t handlerType, uint32_t eventType, int32_t priority, + uint32_t deviceTags, const std::vector& actionsType) { CALL_INFO_TRACE; + InputHandlerType hType = static_cast(handlerType); + HandleEventType eType = static_cast(eventType); + if (!PER_HELPER->VerifySystemApp()) { + if (hType != InputHandlerType::MONITOR && hType != InputHandlerType::INTERCEPTOR) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if ((hType == InputHandlerType::INTERCEPTOR) && (!PER_HELPER->CheckInterceptor())) { + MMI_HILOGE("Interceptor permission check failed"); + return ERROR_NO_PERMISSION; + } + if ((hType == InputHandlerType::MONITOR) && (!PER_HELPER->CheckMonitor())) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } #if defined(OHOS_BUILD_ENABLE_INTERCEPTOR) || defined(OHOS_BUILD_ENABLE_MONITOR) int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, handlerType, eventType, priority, deviceTags] { - return this->CheckRemoveInput(pid, handlerType, eventType, priority, deviceTags); + [this, pid, hType, eType, priority, deviceTags] { + return this->CheckRemoveInput(pid, hType, eType, priority, deviceTags); } ); if (ret != RET_OK) { @@ -1550,30 +1634,48 @@ int32_t MMIService::RemoveInputHandler(InputHandlerType handlerType, HandleEvent return RET_OK; } -int32_t MMIService::AddGestureMonitor(InputHandlerType handlerType, - HandleEventType eventType, TouchGestureType gestureType, int32_t fingers) +ErrCode MMIService::AddGestureMonitor(int32_t handlerType, uint32_t eventType, uint32_t gestureType, int32_t fingers) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->CheckMonitor()) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } + InputHandlerType hType = static_cast(handlerType); + HandleEventType eType = static_cast(eventType); + TouchGestureType gType = static_cast(gestureType); + if (hType != InputHandlerType::MONITOR) { + MMI_HILOGE("Illegal type:%{public}d", hType); + return RET_ERR; + } #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR) int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, handlerType, eventType, gestureType, fingers]() -> int32_t { - if (((eventType & HANDLE_EVENT_TYPE_TOUCH_GESTURE) != HANDLE_EVENT_TYPE_TOUCH_GESTURE)) { - MMI_HILOGE("Illegal type:%{public}d", eventType); + [this, pid, hType, eType, gType, fingers]() -> int32_t { + if (((eType & HANDLE_EVENT_TYPE_TOUCH_GESTURE) != HANDLE_EVENT_TYPE_TOUCH_GESTURE)) { + MMI_HILOGE("Illegal type:%{public}d", eType); return RET_ERR; } - if (!GestureMonitorHandler::CheckMonitorValid(gestureType, fingers)) { + if (!GestureMonitorHandler::CheckMonitorValid(gType, fingers)) { MMI_HILOGE("Wrong number of fingers:%{public}d", fingers); return RET_ERR; } if (touchGestureMgr_ == nullptr) { touchGestureMgr_ = std::make_shared(delegateInterface_); } - touchGestureMgr_->AddHandler(pid, gestureType, fingers); + touchGestureMgr_->AddHandler(pid, gType, fingers); auto sess = GetSessionByPid(pid); CHKPR(sess, ERROR_NULL_POINTER); - return sMsgHandler_.OnAddGestureMonitor(sess, handlerType, eventType, gestureType, fingers); + return sMsgHandler_.OnAddGestureMonitor(sess, hType, eType, gType, fingers); }); if (ret != RET_OK) { MMI_HILOGE("Add gesture handler failed, ret:%{public}d", ret); @@ -1583,23 +1685,41 @@ int32_t MMIService::AddGestureMonitor(InputHandlerType handlerType, return RET_OK; } -int32_t MMIService::RemoveGestureMonitor(InputHandlerType handlerType, - HandleEventType eventType, TouchGestureType gestureType, int32_t fingers) +ErrCode MMIService::RemoveGestureMonitor(int32_t handlerType, uint32_t eventType, uint32_t gestureType, int32_t fingers) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->CheckMonitor()) { + MMI_HILOGE("Monitor permission check failed"); + return ERROR_NO_PERMISSION; + } + InputHandlerType hType = static_cast(handlerType); + HandleEventType eType = static_cast(eventType); + TouchGestureType gType = static_cast(gestureType); + if (hType != InputHandlerType::MONITOR) { + MMI_HILOGE("Illegal type:%{public}d", hType); + return RET_ERR; + } #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR) int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, handlerType, eventType, gestureType, fingers]() -> int32_t { + [this, pid, hType, eType, gType, fingers]() -> int32_t { auto sess = GetSessionByPid(pid); CHKPR(sess, ERROR_NULL_POINTER); - int32_t ret = sMsgHandler_.OnRemoveGestureMonitor(sess, handlerType, eventType, gestureType, fingers); + int32_t ret = sMsgHandler_.OnRemoveGestureMonitor(sess, hType, eType, gType, fingers); if (ret != RET_OK) { MMI_HILOGE("Failed to remove gesture recognizer, ret:%{public}d", ret); return ret; } if (touchGestureMgr_ != nullptr) { - touchGestureMgr_->RemoveHandler(pid, gestureType, fingers); + touchGestureMgr_->RemoveHandler(pid, gType, fingers); } return RET_OK; }); @@ -1620,9 +1740,17 @@ int32_t MMIService::CheckMarkConsumed(int32_t pid, int32_t eventId) } #endif // OHOS_BUILD_ENABLE_MONITOR -int32_t MMIService::MarkEventConsumed(int32_t eventId) +ErrCode MMIService::MarkEventConsumed(int32_t eventId) { CALL_DEBUG_ENTER; + if (!PER_HELPER->CheckMonitor()) { + MMI_HILOGE("Permission check failed"); + return ERROR_NO_PERMISSION; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } #ifdef OHOS_BUILD_ENABLE_MONITOR int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( @@ -1638,9 +1766,21 @@ int32_t MMIService::MarkEventConsumed(int32_t eventId) return RET_OK; } -int32_t MMIService::MoveMouseEvent(int32_t offsetX, int32_t offsetY) +ErrCode MMIService::MoveMouseEvent(int32_t offsetX, int32_t offsetY) { CALL_DEBUG_ENTER; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!PER_HELPER->CheckMouseCursor()) { + MMI_HILOGE("Mouse cursor permission check failed"); + return ERROR_NO_PERMISSION; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t ret = delegateTasks_.PostSyncTask( @@ -1656,18 +1796,28 @@ int32_t MMIService::MoveMouseEvent(int32_t offsetX, int32_t offsetY) return RET_OK; } -int32_t MMIService::InjectKeyEvent(const std::shared_ptr keyEvent, bool isNativeInject) +ErrCode MMIService::InjectKeyEvent(const KeyEvent& keyEvent, bool isNativeInject) { CALL_DEBUG_ENTER; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!isNativeInject && !PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + std::shared_ptrkeyEventPtr = std::make_shared(keyEvent); + CHKPR(keyEventPtr, ERROR_NULL_POINTER); #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t ret; int32_t pid = GetCallingPid(); #ifdef OHOS_BUILD_ENABLE_ANCO - ret = InjectKeyEventExt(keyEvent, pid, isNativeInject); + ret = InjectKeyEventExt(keyEventPtr, pid, isNativeInject); #else ret = delegateTasks_.PostSyncTask( - [this, keyEvent, pid, isNativeInject] { - return this->CheckInjectKeyEvent(keyEvent, pid, isNativeInject); + [this, keyEventPtr, pid, isNativeInject] { + return this->CheckInjectKeyEvent(keyEventPtr, pid, isNativeInject); } ); #endif // OHOS_BUILD_ENABLE_ANCO @@ -1691,7 +1841,8 @@ int32_t MMIService::CheckInjectKeyEvent(const std::shared_ptr keyEvent } #ifdef OHOS_BUILD_ENABLE_KEYBOARD -int32_t MMIService::OnGetKeyState(std::vector &pressedKeys, std::map &specialKeysState) +int32_t MMIService::OnGetKeyState(std::vector &pressedKeys, + std::unordered_map &specialKeysState) { auto keyEvent = KeyEventHdr->GetKeyEvent(); CHKPR(keyEvent, ERROR_NULL_POINTER); @@ -1737,19 +1888,29 @@ int32_t MMIService::CheckTouchPadEvent(const std::shared_ptr point #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH } -int32_t MMIService::InjectPointerEvent(const std::shared_ptr pointerEvent, bool isNativeInject) +ErrCode MMIService::InjectPointerEvent(const PointerEvent& pointerEvent, bool isNativeInject) { CALL_DEBUG_ENTER; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!isNativeInject && !PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + std::shared_ptrpointerEventPtr = std::make_shared(pointerEvent); + CHKPR(pointerEventPtr, ERROR_NULL_POINTER); #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) int32_t ret; int32_t pid = GetCallingPid(); bool isShell = PER_HELPER->RequestFromShell(); #ifdef OHOS_BUILD_ENABLE_ANCO - ret = InjectPointerEventExt(pointerEvent, pid, isNativeInject, isShell); + ret = InjectPointerEventExt(pointerEventPtr, pid, isNativeInject, isShell); #else ret = delegateTasks_.PostSyncTask( - [this, pointerEvent, pid, isNativeInject, isShell] { - return this->CheckInjectPointerEvent(pointerEvent, pid, isNativeInject, isShell); + [this, pointerEventPtr, pid, isNativeInject, isShell] { + return this->CheckInjectPointerEvent(pointerEventPtr, pid, isNativeInject, isShell); } ); #endif // OHOS_BUILD_ENABLE_ANCO @@ -1761,17 +1922,27 @@ int32_t MMIService::InjectPointerEvent(const std::shared_ptr point return RET_OK; } -int32_t MMIService::InjectTouchPadEvent(const std::shared_ptr pointerEvent, - const TouchpadCDG &touchpadCDG, bool isNativeInject) +ErrCode MMIService::InjectTouchPadEvent(const PointerEvent& pointerEvent, + const TouchpadCDG& touchpadCDG, bool isNativeInject) { CALL_DEBUG_ENTER; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + std::shared_ptrpointerEventPtr = std::make_shared(pointerEvent); + CHKPR(pointerEventPtr, ERROR_NULL_POINTER); #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) int32_t ret; int32_t pid = GetCallingPid(); bool isShell = PER_HELPER->RequestFromShell(); ret = delegateTasks_.PostSyncTask( - [this, pointerEvent, pid, touchpadCDG, isNativeInject, isShell] { - return sMsgHandler_.OnInjectTouchPadEvent(pointerEvent, pid, touchpadCDG, isNativeInject, isShell); + [this, pointerEventPtr, pid, touchpadCDG, isNativeInject, isShell] { + return sMsgHandler_.OnInjectTouchPadEvent(pointerEventPtr, pid, touchpadCDG, isNativeInject, isShell); } ); if (ret != RET_OK) { @@ -1892,14 +2063,24 @@ void MMIService::RegisterScreenCaptureCallback() } #endif // OHOS_BUILD_ENABLE_MONITOR && PLAYER_FRAMEWORK_EXISTS -int32_t MMIService::SubscribeKeyEvent(int32_t subscribeId, const std::shared_ptr option) +ErrCode MMIService::SubscribeKeyEvent(int32_t subscribeId, const KeyOption& keyOption) { + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } CALL_DEBUG_ENTER; + std::shared_ptrkeyOptionPtr = std::make_shared(keyOption); + CHKPR(keyOptionPtr, ERROR_NULL_POINTER); #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, subscribeId, option] { - return sMsgHandler_.OnSubscribeKeyEvent(this, pid, subscribeId, option); + [this, pid, subscribeId, keyOptionPtr] { + return sMsgHandler_.OnSubscribeKeyEvent(this, pid, subscribeId, keyOptionPtr); }); if (ret != RET_OK) { MMI_HILOGE("The subscribe key event processed failed, ret:%{public}d", ret); @@ -1924,9 +2105,21 @@ int32_t MMIService::SubscribeKeyEvent(int32_t subscribeId, const std::shared_ptr return RET_OK; } -int32_t MMIService::UnsubscribeKeyEvent(int32_t subscribeId) +ErrCode MMIService::UnsubscribeKeyEvent(int32_t subscribeId) { CALL_INFO_TRACE; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (subscribeId < 0) { + MMI_HILOGE("Invalid subscribe"); + return RET_ERR; + } #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( @@ -1956,14 +2149,24 @@ int32_t MMIService::UnsubscribeKeyEvent(int32_t subscribeId) return RET_OK; } -int32_t MMIService::SubscribeHotkey(int32_t subscribeId, const std::shared_ptr option) +ErrCode MMIService::SubscribeHotkey(int32_t subscribeId, const KeyOption& keyOption) { CALL_DEBUG_ENTER; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (subscribeId < 0) { + MMI_HILOGE("Invalid subscribe"); + return RET_ERR; + } + std::shared_ptrkeyOptionPtr = std::make_shared(keyOption); + CHKPR(keyOptionPtr, ERROR_NULL_POINTER); #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( - [this, pid, subscribeId, option] { - return sMsgHandler_.OnSubscribeHotkey(this, pid, subscribeId, option); + [this, pid, subscribeId, keyOptionPtr] { + return sMsgHandler_.OnSubscribeHotkey(this, pid, subscribeId, keyOptionPtr); }); if (ret != RET_OK) { MMI_HILOGE("ServerMsgHandler::OnSubscribeHotkey fail, error:%{public}d", ret); @@ -1988,9 +2191,17 @@ int32_t MMIService::SubscribeHotkey(int32_t subscribeId, const std::shared_ptrVerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } #ifdef OHOS_BUILD_ENABLE_SWITCH int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( @@ -2067,9 +2294,21 @@ int32_t MMIService::SubscribeSwitchEvent(int32_t subscribeId, int32_t switchType return RET_OK; } -int32_t MMIService::UnsubscribeSwitchEvent(int32_t subscribeId) +ErrCode MMIService::UnsubscribeSwitchEvent(int32_t subscribeId) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (subscribeId < 0) { + MMI_HILOGE("Invalid subscribeId"); + return RET_ERR; + } #ifdef OHOS_BUILD_ENABLE_SWITCH int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( @@ -2085,9 +2324,19 @@ int32_t MMIService::UnsubscribeSwitchEvent(int32_t subscribeId) return RET_OK; } -int32_t MMIService::QuerySwitchStatus(int32_t switchType, int32_t& state) +ErrCode MMIService::QuerySwitchStatus(int32_t switchType, int32_t& state) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + state = 0; #ifdef OHOS_BUILD_ENABLE_SWITCH int32_t ret = delegateTasks_.PostSyncTask( [this, switchType, &state] { @@ -2102,9 +2351,17 @@ int32_t MMIService::QuerySwitchStatus(int32_t switchType, int32_t& state) return RET_OK; } -int32_t MMIService::SubscribeTabletProximity(int32_t subscribeId) +ErrCode MMIService::SubscribeTabletProximity(int32_t subscribeId) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [this, pid, subscribeId] { @@ -2120,9 +2377,21 @@ int32_t MMIService::SubscribeTabletProximity(int32_t subscribeId) return RET_OK; } -int32_t MMIService::UnsubscribetabletProximity(int32_t subscribeId) +ErrCode MMIService::UnsubscribetabletProximity(int32_t subscribeId) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (subscribeId < 0) { + MMI_HILOGE("Invalid subscribeId"); + return RET_ERR; + } int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [this, pid, subscribeId] { @@ -2138,9 +2407,17 @@ int32_t MMIService::UnsubscribetabletProximity(int32_t subscribeId) return RET_OK; } -int32_t MMIService::SubscribeLongPressEvent(int32_t subscribeId, const LongPressRequest &longPressRequest) +ErrCode MMIService::SubscribeLongPressEvent(int32_t subscribeId, const LongPressRequest &longPressRequest) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [this, pid, subscribeId, longPressRequest] { @@ -2154,9 +2431,17 @@ int32_t MMIService::SubscribeLongPressEvent(int32_t subscribeId, const LongPress return RET_OK; } -int32_t MMIService::UnsubscribeLongPressEvent(int32_t subscribeId) +ErrCode MMIService::UnsubscribeLongPressEvent(int32_t subscribeId) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [this, pid, subscribeId] { @@ -2170,9 +2455,17 @@ int32_t MMIService::UnsubscribeLongPressEvent(int32_t subscribeId) return RET_OK; } -int32_t MMIService::SetAnrObserver() +ErrCode MMIService::SetAnrObserver() { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [pid] { @@ -2186,9 +2479,18 @@ int32_t MMIService::SetAnrObserver() return RET_OK; } -int32_t MMIService::GetDisplayBindInfo(DisplayBindInfos &infos) +ErrCode MMIService::GetDisplayBindInfo(std::vector& infos) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + infos.clear(); int32_t ret = delegateTasks_.PostSyncTask( [&infos] { return ::OHOS::MMI::IInputWindowsManager::GetInstance()->GetDisplayBindInfo(infos); @@ -2201,16 +2503,33 @@ int32_t MMIService::GetDisplayBindInfo(DisplayBindInfos &infos) return RET_OK; } -int32_t MMIService::GetAllMmiSubscribedEvents(std::map, int32_t> &datas) +ErrCode MMIService::GetAllMmiSubscribedEvents(MmiEventMap& mmiEventMap) { CALL_INFO_TRACE; - NapProcess::GetInstance()->GetAllMmiSubscribedEvents(datas); + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + mmiEventMap.datas.clear(); + NapProcess::GetInstance()->GetAllMmiSubscribedEvents(mmiEventMap.datas); return RET_OK; } -int32_t MMIService::SetDisplayBind(int32_t deviceId, int32_t displayId, std::string &msg) +ErrCode MMIService::SetDisplayBind(int32_t deviceId, int32_t displayId, std::string &msg) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } int32_t ret = delegateTasks_.PostSyncTask( [deviceId, displayId, &msg] { return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetDisplayBind(deviceId, displayId, msg); @@ -2223,9 +2542,14 @@ int32_t MMIService::SetDisplayBind(int32_t deviceId, int32_t displayId, std::str return RET_OK; } -int32_t MMIService::GetFunctionKeyState(int32_t funcKey, bool &state) +ErrCode MMIService::GetFunctionKeyState(int32_t funcKey, bool &state) { CALL_INFO_TRACE; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + state = false; #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t ret = delegateTasks_.PostSyncTask( [this, funcKey, &state] { @@ -2240,9 +2564,22 @@ int32_t MMIService::GetFunctionKeyState(int32_t funcKey, bool &state) return RET_OK; } -int32_t MMIService::SetFunctionKeyState(int32_t funcKey, bool enable) +ErrCode MMIService::SetFunctionKeyState(int32_t funcKey, bool enable) { CALL_INFO_TRACE; + if (!PER_HELPER->CheckFunctionKeyEnabled()) { + MMI_HILOGE("Set function key state permission check failed"); + return ERROR_KEYBOARD_NO_PERMISSION; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (funcKey != KeyEvent::NUM_LOCK_FUNCTION_KEY && funcKey != KeyEvent::CAPS_LOCK_FUNCTION_KEY && + funcKey != KeyEvent::SCROLL_LOCK_FUNCTION_KEY) { + MMI_HILOGE("Invalid funcKey:%{public}d", funcKey); + return RET_ERR; + } #ifdef OHOS_BUILD_ENABLE_KEYBOARD int32_t clientPid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( @@ -2258,9 +2595,21 @@ int32_t MMIService::SetFunctionKeyState(int32_t funcKey, bool enable) return RET_OK; } -int32_t MMIService::SetPointerLocation(int32_t x, int32_t y, int32_t displayId) +ErrCode MMIService::SetPointerLocation(int32_t x, int32_t y, int32_t displayId) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("StubSetPointerLocation Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!PER_HELPER->CheckMouseCursor()) { + MMI_HILOGE("Mouse cursor permission check failed"); + return ERROR_NO_PERMISSION; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t ret = delegateTasks_.PostSyncTask( [x, y, displayId] { @@ -2463,9 +2812,17 @@ int32_t MMIService::Dump(int32_t fd, const std::vector &args) return RET_OK; } -int32_t MMIService::SetMouseCaptureMode(int32_t windowId, bool isCaptureMode) +ErrCode MMIService::SetMouseCaptureMode(int32_t windowId, bool isCaptureMode) { CALL_INFO_TRACE; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (windowId <= 0) { + MMI_HILOGE("Invalid windowId:%{public}d", windowId); + return RET_ERR; + } int32_t ret = delegateTasks_.PostSyncTask( [windowId, isCaptureMode] { return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetMouseCaptureMode(windowId, isCaptureMode); @@ -2490,10 +2847,14 @@ int32_t MMIService::OnGetWindowPid(int32_t windowId, int32_t &windowPid) return RET_OK; } -int32_t MMIService::GetWindowPid(int32_t windowId) +ErrCode MMIService::GetWindowPid(int32_t windowId, int32_t &windowPid) { CALL_INFO_TRACE; - int32_t windowPid = INVALID_PID; + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + windowPid = INVALID_PID; int32_t ret = delegateTasks_.PostSyncTask( [this, windowId, &windowPid] { return this->OnGetWindowPid(windowId, windowPid); @@ -2504,12 +2865,34 @@ int32_t MMIService::GetWindowPid(int32_t windowId) return ret; } MMI_HILOGD("The windowpid is:%{public}d", windowPid); - return windowPid; + return RET_OK; } -int32_t MMIService::AppendExtraData(const ExtraData &extraData) +ErrCode MMIService::AppendExtraData(const ExtraData &extraData) { CALL_DEBUG_ENTER; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } + if (extraData.buffer.size() > ExtraData::MAX_BUFFER_SIZE) { + MMI_HILOGE("Append extra data failed, buffer is oversize:%{public}d", extraData.buffer.size()); + return ERROR_OVER_SIZE_BUFFER; + } + if (extraData.sourceType != InputEvent::SOURCE_TYPE_TOUCHSCREEN && + extraData.sourceType != InputEvent::SOURCE_TYPE_MOUSE) { + MMI_HILOGE("Invalid extraData.sourceType:%{public}d", extraData.sourceType); + return RET_ERR; + } + if (extraData.pointerId < 0 || extraData.pullId < 0) { + MMI_HILOGE("Invalid extraData.pointerId or extraData.pullId or extraData.eventId, pointerId:%{public}d," + "pullId:%{public}d, eventId:%{public}d", extraData.pointerId, extraData.pullId, extraData.eventId); + return RET_ERR; + } int32_t ret = delegateTasks_.PostSyncTask( [extraData] { return ::OHOS::MMI::IInputWindowsManager::GetInstance()->AppendExtraData(extraData); @@ -2521,7 +2904,7 @@ int32_t MMIService::AppendExtraData(const ExtraData &extraData) return ret; } -int32_t MMIService::EnableInputDevice(bool enable) +ErrCode MMIService::EnableInputDevice(bool enable) { CALL_DEBUG_ENTER; int32_t ret = delegateTasks_.PostSyncTask( @@ -2566,9 +2949,17 @@ int32_t MMIService::CheckPidPermission(int32_t pid) return RET_OK; } -int32_t MMIService::EnableCombineKey(bool enable) +ErrCode MMIService::EnableCombineKey(bool enable) { CALL_DEBUG_ENTER; + if (!PER_HELPER->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!IsRunning()) { + MMI_HILOGE("Service is not running"); + return MMISERVICE_NOT_RUNNING; + } #if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY) int32_t ret = delegateTasks_.PostSyncTask( [this, enable] { -- Gitee