diff --git a/service/module_loader/src/mmi_service.cpp b/service/module_loader/src/mmi_service.cpp
index 6e07ea4c73d6e0701f0ecdcee6b83a2d8f0a276a..08a6e46a8dd427ca608b6cd734f147f53517cf40 100644
--- a/service/module_loader/src/mmi_service.cpp
+++ b/service/module_loader/src/mmi_service.cpp
@@ -2592,9 +2592,17 @@ int32_t MMIService::UpdateSettingsXml(const std::string &businessId, int32_t del
 }
 #endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY
 
-int32_t MMIService::SetKeyDownDuration(const std::string &businessId, int32_t delay)
+ErrCode MMIService::SetKeyDownDuration(const std::string &businessId, int32_t delay)
 {
     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 defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY)
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, businessId, delay] {
@@ -2672,9 +2680,17 @@ int32_t MMIService::ReadTouchpadDoubleTapAndDragState(bool &switchFlag)
 
 #endif // OHOS_BUILD_ENABLE_POINTER
 
-int32_t MMIService::SetTouchpadScrollSwitch(bool switchFlag)
+ErrCode MMIService::SetTouchpadScrollSwitch(bool switchFlag)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t clientPid = GetCallingPid();
     int32_t ret = delegateTasks_.PostSyncTask(
@@ -2691,9 +2707,18 @@ int32_t MMIService::SetTouchpadScrollSwitch(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadScrollSwitch(bool &switchFlag)
+ErrCode MMIService::GetTouchpadScrollSwitch(bool &switchFlag)
 {
     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;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &switchFlag] {
@@ -2708,9 +2733,17 @@ int32_t MMIService::GetTouchpadScrollSwitch(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadScrollDirection(bool state)
+ErrCode MMIService::SetTouchpadScrollDirection(bool state)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [state] {
@@ -2725,9 +2758,18 @@ int32_t MMIService::SetTouchpadScrollDirection(bool state)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadScrollDirection(bool &state)
+ErrCode MMIService::GetTouchpadScrollDirection(bool &state)
 {
     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;
+    }
+    state = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &state] {
@@ -2742,9 +2784,17 @@ int32_t MMIService::GetTouchpadScrollDirection(bool &state)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadTapSwitch(bool switchFlag)
+ErrCode MMIService::SetTouchpadTapSwitch(bool switchFlag)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [switchFlag] {
@@ -2759,9 +2809,18 @@ int32_t MMIService::SetTouchpadTapSwitch(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadTapSwitch(bool &switchFlag)
+ErrCode MMIService::GetTouchpadTapSwitch(bool &switchFlag)
 {
     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;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &switchFlag] {
@@ -2776,9 +2835,22 @@ int32_t MMIService::GetTouchpadTapSwitch(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadPointerSpeed(int32_t speed)
+ErrCode MMIService::SetTouchpadPointerSpeed(int32_t speed)
 {
     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 (speed < MIN_SPEED) {
+        speed = MIN_SPEED;
+    } else if (speed > MAX_SPEED) {
+        speed = MAX_SPEED;
+    }
 #if defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [speed] {
@@ -2793,9 +2865,18 @@ int32_t MMIService::SetTouchpadPointerSpeed(int32_t speed)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadPointerSpeed(int32_t &speed)
+ErrCode MMIService::GetTouchpadPointerSpeed(int32_t &speed)
 {
     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;
+    }
+    speed = 1;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &speed] {
@@ -2810,9 +2891,21 @@ int32_t MMIService::GetTouchpadPointerSpeed(int32_t &speed)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadCDG(TouchpadCDG &touchpadCDG)
+ErrCode MMIService::GetTouchpadCDG(TouchpadCDG &touchpadCDG)
 {
     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;
+    }
+    touchpadCDG.ppi = 0.0;
+    touchpadCDG.size = 0.0;
+    touchpadCDG.speed = 0;
+    touchpadCDG.frequency = 0;
 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &touchpadCDG] {
@@ -2827,9 +2920,17 @@ int32_t MMIService::GetTouchpadCDG(TouchpadCDG &touchpadCDG)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadPinchSwitch(bool switchFlag)
+ErrCode MMIService::SetTouchpadPinchSwitch(bool switchFlag)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [switchFlag] {
@@ -2844,9 +2945,18 @@ int32_t MMIService::SetTouchpadPinchSwitch(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadPinchSwitch(bool &switchFlag)
+ErrCode MMIService::GetTouchpadPinchSwitch(bool &switchFlag)
 {
     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;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &switchFlag] {
@@ -2861,9 +2971,17 @@ int32_t MMIService::GetTouchpadPinchSwitch(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadSwipeSwitch(bool switchFlag)
+ErrCode MMIService::SetTouchpadSwipeSwitch(bool switchFlag)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [switchFlag] {
@@ -2878,9 +2996,18 @@ int32_t MMIService::SetTouchpadSwipeSwitch(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadSwipeSwitch(bool &switchFlag)
+ErrCode MMIService::GetTouchpadSwipeSwitch(bool &switchFlag)
 {
     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;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &switchFlag] {
@@ -2895,9 +3022,24 @@ int32_t MMIService::GetTouchpadSwipeSwitch(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadRightClickType(int32_t type)
+ErrCode MMIService::SetTouchpadRightClickType(int32_t type)
 {
     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 (type != RightClickType::TOUCHPAD_RIGHT_BUTTON && type != RightClickType::TOUCHPAD_LEFT_BUTTON &&
+        type != RightClickType::TOUCHPAD_TWO_FINGER_TAP &&
+        type != RightClickType::TOUCHPAD_TWO_FINGER_TAP_OR_RIGHT_BUTTON &&
+        type != RightClickType::TOUCHPAD_TWO_FINGER_TAP_OR_LEFT_BUTTON) {
+        MMI_HILOGE("Invalid type:%{public}d", type);
+        return RET_ERR;
+    }
 #if defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [type] {
@@ -2912,9 +3054,18 @@ int32_t MMIService::SetTouchpadRightClickType(int32_t type)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadRightClickType(int32_t &type)
+ErrCode MMIService::GetTouchpadRightClickType(int32_t &type)
 {
     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;
+    }
+    type = 1;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &type] {
@@ -2929,9 +3080,17 @@ int32_t MMIService::GetTouchpadRightClickType(int32_t &type)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadRotateSwitch(bool rotateSwitch)
+ErrCode MMIService::SetTouchpadRotateSwitch(bool rotateSwitch)
 {
     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 defined OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [rotateSwitch] {
@@ -2946,9 +3105,18 @@ int32_t MMIService::SetTouchpadRotateSwitch(bool rotateSwitch)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadRotateSwitch(bool &rotateSwitch)
+ErrCode MMIService::GetTouchpadRotateSwitch(bool &rotateSwitch)
 {
     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;
+    }
+    rotateSwitch = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &rotateSwitch] {
@@ -2963,9 +3131,17 @@ int32_t MMIService::GetTouchpadRotateSwitch(bool &rotateSwitch)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadDoubleTapAndDragState(bool switchFlag)
+ErrCode MMIService::SetTouchpadDoubleTapAndDragState(bool switchFlag)
 {
     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;
+    }
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [switchFlag] {
@@ -2981,9 +3157,18 @@ int32_t MMIService::SetTouchpadDoubleTapAndDragState(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadDoubleTapAndDragState(bool &switchFlag)
+ErrCode MMIService::GetTouchpadDoubleTapAndDragState(bool &switchFlag)
 {
     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;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &switchFlag] {
@@ -2998,9 +3183,21 @@ int32_t MMIService::GetTouchpadDoubleTapAndDragState(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::SetShieldStatus(int32_t shieldMode, bool isShield)
+ErrCode MMIService::SetShieldStatus(int32_t shieldMode, bool isShield)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    if (!PER_HELPER->CheckDispatchControl()) {
+        MMI_HILOGE("Input dispatch control permission check failed");
+        return ERROR_NO_PERMISSION;
+    }
+    if (!IsRunning()) {
+        MMI_HILOGE("Service is not running");
+        return MMISERVICE_NOT_RUNNING;
+    }
 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, shieldMode, isShield] {
@@ -3015,9 +3212,22 @@ int32_t MMIService::SetShieldStatus(int32_t shieldMode, bool isShield)
     return RET_OK;
 }
 
-int32_t MMIService::GetShieldStatus(int32_t shieldMode, bool &isShield)
+ErrCode MMIService::GetShieldStatus(int32_t shieldMode, bool &isShield)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    if (!PER_HELPER->CheckDispatchControl()) {
+        MMI_HILOGE("Input dispatch control permission check failed");
+        return ERROR_NO_PERMISSION;
+    }
+    if (!IsRunning()) {
+        MMI_HILOGE("Service is not running");
+        return MMISERVICE_NOT_RUNNING;
+    }
+    isShield = false;
 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, shieldMode, &isShield] {
@@ -3032,7 +3242,8 @@ int32_t MMIService::GetShieldStatus(int32_t shieldMode, bool &isShield)
     return RET_OK;
 }
 
-int32_t MMIService::GetKeyState(std::vector<int32_t> &pressedKeys, std::map<int32_t, int32_t> &specialKeysState)
+ErrCode MMIService::GetKeyState(std::vector<int32_t>& pressedKeys,
+    std::unordered_map<int32_t, int32_t>& specialKeysState)
 {
     CALL_INFO_TRACE;
 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
@@ -3049,9 +3260,17 @@ int32_t MMIService::GetKeyState(std::vector<int32_t> &pressedKeys, std::map<int3
     return RET_OK;
 }
 
-int32_t MMIService::Authorize(bool isAuthorize)
+ErrCode MMIService::Authorize(bool isAuthorize)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    if (!PER_HELPER->CheckAuthorize()) {
+        MMI_HILOGE("Input authorize permission check failed");
+        return ERROR_NO_PERMISSION;
+    }
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, isAuthorize] {
             return this->OnAuthorize(isAuthorize);
@@ -3069,7 +3288,7 @@ int32_t MMIService::OnAuthorize(bool isAuthorize)
     return sMsgHandler_.OnAuthorize(isAuthorize);
 }
 
-int32_t MMIService::CancelInjection()
+ErrCode MMIService::CancelInjection()
 {
     CALL_DEBUG_ENTER;
     int32_t callPid = GetCallingPid();
@@ -3090,9 +3309,14 @@ int32_t MMIService::OnCancelInjection(int32_t callPid)
     return sMsgHandler_.OnCancelInjection(callPid);
 }
 
-int32_t MMIService::HasIrEmitter(bool &hasIrEmitter)
+ErrCode MMIService::HasIrEmitter(bool &hasIrEmitter)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    hasIrEmitter = false;
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &hasIrEmitter] {
             return this->OnHasIrEmitter(hasIrEmitter);
@@ -3105,9 +3329,13 @@ int32_t MMIService::HasIrEmitter(bool &hasIrEmitter)
     return RET_OK;
 }
 
-int32_t MMIService::GetInfraredFrequencies(std::vector<InfraredFrequency>& frequencies)
+ErrCode MMIService::GetInfraredFrequencies(std::vector<InfraredFrequency>& frequencies)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->CheckInfraredEmmit()) {
+        MMI_HILOGE("Infrared permission check failed");
+        return ERROR_NO_PERMISSION;
+    }
 #ifndef OHOS_BUILD_ENABLE_WATCH
     MMI_HILOGI("Start get infrared frequency");
     std::vector<InfraredFrequencyInfo> infos;
@@ -3132,9 +3360,13 @@ int32_t MMIService::GetInfraredFrequencies(std::vector<InfraredFrequency>& frequ
     return RET_OK;
 }
 
-int32_t MMIService::TransmitInfrared(int64_t number, std::vector<int64_t>& pattern)
+ErrCode MMIService::TransmitInfrared(int64_t number, const std::vector<int64_t>& pattern)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->CheckInfraredEmmit()) {
+        MMI_HILOGE("StubTransmitInfrared permission check failed. returnCode:%{public}d", ERROR_NO_PERMISSION);
+        return ERROR_NO_PERMISSION;
+    }
 #ifndef OHOS_BUILD_ENABLE_WATCH
     std::string context = "infraredFrequency:" + std::to_string(number) + ";";
     int32_t size = static_cast<int32_t>(pattern.size());
@@ -3151,9 +3383,14 @@ int32_t MMIService::TransmitInfrared(int64_t number, std::vector<int64_t>& patte
 }
 
 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
-int32_t MMIService::CreateVKeyboardDevice(sptr<IRemoteObject> &vkeyboardDevice)
+ErrCode MMIService::CreateVKeyboardDevice(sptr<IRemoteObject> &vkeyboardDevice)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("StubCreateVKeyboardDevice Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    vkeyboardDevice = nullptr;
     isHPR_ = PRODUCT_TYPE == DEVICE_TYPE_HPR;
     if (!isHPR_) {
         MMI_HILOGE("Failed to create vkeyboard device, feature not support");
@@ -3255,10 +3492,23 @@ int32_t MMIService::OnHasIrEmitter(bool &hasIrEmitter)
     return RET_OK;
 }
 
-int32_t MMIService::SetPixelMapData(int32_t infoId, void* pixelMap)
+ErrCode MMIService::SetPixelMapData(int32_t infoId, const CursorPixelMap& curPixelMap)
 {
     CALL_DEBUG_ENTER;
-    CHKPR(pixelMap, ERROR_NULL_POINTER);
+    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 (infoId <= 0) {
+        MMI_HILOGE("Invalid infoId:%{public}d", infoId);
+        return RET_ERR;
+    }
+    CHKPR(curPixelMap.pixelMap, ERROR_NULL_POINTER);
+    void* pixelMap = curPixelMap.pixelMap;
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, infoId, pixelMap] {
             return sMsgHandler_.SetPixelMapData(infoId, pixelMap);
@@ -3282,9 +3532,17 @@ void MMIService::InitPreferences()
 #endif // OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
 }
 
-int32_t MMIService::SetMoveEventFilters(bool flag)
+ErrCode MMIService::SetMoveEventFilters(bool flag)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("StubSetMoveEventFilters Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    if (!IsRunning()) {
+        MMI_HILOGE("Service is not running");
+        return MMISERVICE_NOT_RUNNING;
+    }
 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
     int32_t ret = delegateTasks_.PostSyncTask(
         std::bind(&InputEventHandler::SetMoveEventFilters, InputHandler, flag));
@@ -3296,9 +3554,22 @@ int32_t MMIService::SetMoveEventFilters(bool flag)
     return RET_OK;
 }
 
-int32_t MMIService::SetCurrentUser(int32_t userId)
+ErrCode MMIService::SetCurrentUser(int32_t userId)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("StubSetCurrentUser Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    int32_t callingUid = GetCallingUid();
+    if (callingUid < UID_TRANSFORM_DIVISOR) {
+        MMI_HILOGE("CallingUid is not within the range:%{public}d", callingUid);
+        return RET_ERR;
+    }
+    if (callingUid / UID_TRANSFORM_DIVISOR != userId) {
+        MMI_HILOGE("Invalid CallingUid:%{public}d", callingUid);
+        return RET_ERR;
+    }
     int32_t ret = delegateTasks_.PostSyncTask(
         [userId] {
             return ::OHOS::MMI::IInputWindowsManager::GetInstance()->SetCurrentUser(userId);
@@ -3322,9 +3593,13 @@ int32_t MMIService::SetCurrentUser(int32_t userId)
     return RET_OK;
 }
 
-int32_t MMIService::SetTouchpadThreeFingersTapSwitch(bool switchFlag)
+ErrCode MMIService::SetTouchpadThreeFingersTapSwitch(bool switchFlag)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("StubSetTouchpadThreeFingersTapSwitch Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [switchFlag] {
@@ -3340,9 +3615,14 @@ int32_t MMIService::SetTouchpadThreeFingersTapSwitch(bool switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::GetTouchpadThreeFingersTapSwitch(bool &switchFlag)
+ErrCode MMIService::GetTouchpadThreeFingersTapSwitch(bool &switchFlag)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("StubGetTouchpadThreeFingersTapSwitch Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    switchFlag = true;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [&switchFlag] {
@@ -3358,13 +3638,19 @@ int32_t MMIService::GetTouchpadThreeFingersTapSwitch(bool &switchFlag)
     return RET_OK;
 }
 
-int32_t MMIService::AddVirtualInputDevice(std::shared_ptr<InputDevice> device, int32_t &deviceId)
+ErrCode MMIService::AddVirtualInputDevice(const InputDevice& device, int32_t& deviceId)
 {
     CALL_DEBUG_ENTER;
-    CHKPR(device, ERROR_NULL_POINTER);
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    deviceId = -1;
+    std::shared_ptr<InputDevice>devicePtr = std::make_shared<InputDevice>(device);
+    CHKPR(devicePtr, ERROR_NULL_POINTER);
     int32_t ret = delegateTasks_.PostSyncTask(
-        [device, &deviceId] {
-            return ::OHOS::MMI::InputDeviceManager::GetInstance()->AddVirtualInputDevice(device, deviceId);
+        [devicePtr, &deviceId] {
+            return ::OHOS::MMI::InputDeviceManager::GetInstance()->AddVirtualInputDevice(devicePtr, deviceId);
         }
         );
     if (ret != RET_OK) {
@@ -3373,9 +3659,17 @@ int32_t MMIService::AddVirtualInputDevice(std::shared_ptr<InputDevice> device, i
     return ret;
 }
 
-int32_t MMIService::RemoveVirtualInputDevice(int32_t deviceId)
+ErrCode MMIService::RemoveVirtualInputDevice(int32_t deviceId)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    if (deviceId < 0) {
+        MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
+        return RET_ERR;
+    }
     int32_t ret = delegateTasks_.PostSyncTask(
         [deviceId] {
             return ::OHOS::MMI::InputDeviceManager::GetInstance()->RemoveVirtualInputDevice(deviceId);
@@ -3387,9 +3681,13 @@ int32_t MMIService::RemoveVirtualInputDevice(int32_t deviceId)
     return ret;
 }
 
-int32_t MMIService::EnableHardwareCursorStats(bool enable)
+ErrCode MMIService::EnableHardwareCursorStats(bool enable)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
     int32_t pid = GetCallingPid();
     int32_t ret = delegateTasks_.PostSyncTask(
@@ -3405,9 +3703,15 @@ int32_t MMIService::EnableHardwareCursorStats(bool enable)
     return RET_OK;
 }
 
-int32_t MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsyncCount)
+ErrCode MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsyncCount)
 {
     CALL_DEBUG_ENTER;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    frameCount = 0;
+    vsyncCount = 0;
 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
     int32_t pid = GetCallingPid();
     int32_t ret = delegateTasks_.PostSyncTask(
@@ -3424,29 +3728,50 @@ int32_t MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsync
 }
 
 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
-int32_t MMIService::GetPointerSnapshot(void *pixelMapPtr)
+ErrCode MMIService::GetPointerSnapshot(CursorPixelMap& pixelMapPtr)
 {
     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;
+    }
+    std::shared_ptr<Media::PixelMap> pixelMap;
 #if defined OHOS_BUILD_ENABLE_POINTER
     MMI_HILOGI("Get pointer snapshot from process(%{public}d)", GetCallingPid());
     int32_t ret = delegateTasks_.PostSyncTask(std::bind(
-        std::bind(&IPointerDrawingManager::GetPointerSnapshot, IPointerDrawingManager::GetInstance(), pixelMapPtr)));
+        std::bind(&IPointerDrawingManager::GetPointerSnapshot,
+            IPointerDrawingManager::GetInstance(), &pixelMap)));
     if (ret != RET_OK) {
         MMI_HILOGE("Get the pointer snapshot failed, ret:%{public}d", ret);
         return ret;
     }
 #endif // OHOS_BUILD_ENABLE_POINTER
+    CHKPR(pixelMap, ERR_INVALID_VALUE);
+    pixelMapPtr.pixelMap = static_cast<void*>(&pixelMap);
     return RET_OK;
 }
 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
 
-int32_t MMIService::SetTouchpadScrollRows(int32_t rows)
+ErrCode MMIService::SetTouchpadScrollRows(int32_t rows)
 {
     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;
+    }
+    int32_t newRows = std::clamp(rows, MIN_ROWS, MAX_ROWS);
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
-        [rows] {
-            return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadScrollRows(rows);
+        [newRows] {
+            return ::OHOS::DelayedSingleton<TouchEventNormalize>::GetInstance()->SetTouchpadScrollRows(newRows);
         }
         );
     if (ret != RET_OK) {
@@ -3465,9 +3790,18 @@ int32_t MMIService::ReadTouchpadScrollRows(int32_t &rows)
 }
 #endif // OHOS_BUILD_ENABLE_POINTER
 
-int32_t MMIService::GetTouchpadScrollRows(int32_t &rows)
+ErrCode MMIService::GetTouchpadScrollRows(int32_t &rows)
 {
     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;
+    }
+    rows = TOUCHPAD_SCROLL_ROWS;
 #ifdef OHOS_BUILD_ENABLE_POINTER
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &rows] {
@@ -3480,14 +3814,22 @@ int32_t MMIService::GetTouchpadScrollRows(int32_t &rows)
         return ret;
     }
 #endif // OHOS_BUILD_ENABLE_POINTER
+    if (rows < MIN_ROWS || rows > MAX_ROWS) {
+        MMI_HILOGD("Invalid touchpad scroll rows:%{public}d", rows);
+    }
     return RET_OK;
 }
 
 #ifdef OHOS_BUILD_ENABLE_ANCO
-int32_t MMIService::AncoAddChannel(sptr<IAncoChannel> channel)
+ErrCode MMIService::AncoAddChannel(const sptr<IAncoChannel>& channel)
 {
-    int32_t ret = delegateTasks_.PostSyncTask([channel]() {
-        return WIN_MGR->AncoAddChannel(channel);
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    sptr<IAncoChannel> ancoChannel = channel;
+    int32_t ret = delegateTasks_.PostSyncTask([ancoChannel]() {
+        return WIN_MGR->AncoAddChannel(ancoChannel);
     });
     if (ret != RET_OK) {
         MMI_HILOGE("AncoAddChannel fail, error:%{public}d", ret);
@@ -3496,10 +3838,15 @@ int32_t MMIService::AncoAddChannel(sptr<IAncoChannel> channel)
     return ret;
 }
 
-int32_t MMIService::AncoRemoveChannel(sptr<IAncoChannel> channel)
+ErrCode MMIService::AncoRemoveChannel(const sptr<IAncoChannel>& channel)
 {
-    int32_t ret = delegateTasks_.PostSyncTask([channel]() {
-        return WIN_MGR->AncoRemoveChannel(channel);
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    sptr<IAncoChannel> ancoChannel = channel;
+    int32_t ret = delegateTasks_.PostSyncTask([ancoChannel]() {
+        return WIN_MGR->AncoRemoveChannel(ancoChannel);
     });
     if (ret != RET_OK) {
         MMI_HILOGE("AncoRemoveChannel fail, error:%{public}d", ret);
@@ -3508,7 +3855,7 @@ int32_t MMIService::AncoRemoveChannel(sptr<IAncoChannel> channel)
 }
 #endif // OHOS_BUILD_ENABLE_ANCO
 
-int32_t MMIService::TransferBinderClientSrv(const sptr<IRemoteObject> &binderClientObject)
+ErrCode MMIService::TransferBinderClientSrv(const sptr<IRemoteObject> &binderClientObject)
 {
     CALL_DEBUG_ENTER;
     int32_t pid = GetCallingPid();
@@ -3548,9 +3895,13 @@ void MMIService::PrintLog(const std::string &flag, int32_t duration, int32_t pid
     MMI_HILOGW("BlockMsg:%{public}s", dfxThreadBlockMsg.c_str());
 }
 
-int32_t MMIService::SkipPointerLayer(bool isSkip)
+ErrCode MMIService::SkipPointerLayer(bool isSkip)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
     int32_t ret = delegateTasks_.PostSyncTask(
         [isSkip] {
@@ -3578,9 +3929,17 @@ void MMIService::OnSessionDelete(SessionPtr session)
     }
 }
 
-int32_t MMIService::SetClientInfo(int32_t pid, uint64_t readThreadId)
+ErrCode MMIService::SetClientInfo(int32_t pid, uint64_t readThreadId)
 {
     CALL_DEBUG_ENTER;
+    if (!IsRunning()) {
+        MMI_HILOGE("Service is not running");
+        return MMISERVICE_NOT_RUNNING;
+    }
+    if (readThreadId < 0) {
+        MMI_HILOGE("invalid readThreadId :%{public}llu", readThreadId);
+        return RET_ERR;
+    }
     auto sess = GetSessionByPid(pid);
     CHKPR(sess, ERROR_NULL_POINTER);
     std::string programName = sess->GetProgramName();
@@ -3626,9 +3985,10 @@ void MMIService::InitPrintClientInfo()
     AddSessionDeletedCallback(callback);
 }
 
-int32_t MMIService::GetIntervalSinceLastInput(int64_t &timeInterval)
+ErrCode MMIService::GetIntervalSinceLastInput(int64_t &timeInterval)
 {
     CALL_INFO_TRACE;
+    timeInterval = 0;
     int32_t ret = delegateTasks_.PostSyncTask(std::bind(&InputEventHandler::GetIntervalSinceLastInput,
         InputHandler, std::ref(timeInterval)));
     MMI_HILOGD("timeInterval:%{public}" PRId64, timeInterval);
@@ -3638,18 +3998,23 @@ int32_t MMIService::GetIntervalSinceLastInput(int64_t &timeInterval)
     return ret;
 }
 
-int32_t MMIService::GetAllSystemHotkeys(std::vector<std::unique_ptr<KeyOption>> &keyOptions)
+ErrCode MMIService::GetAllSystemHotkeys(std::vector<KeyOption>& keyOptions)
 {
     CALL_DEBUG_ENTER;
+    std::vector<std::unique_ptr<KeyOption>> options {};
     int32_t ret = delegateTasks_.PostSyncTask(
-        [this, &keyOptions] {
-            return this->OnGetAllSystemHotkey(keyOptions);
+        [this, &options] {
+            return this->OnGetAllSystemHotkey(options);
         }
         );
     if (ret != RET_OK) {
         MMI_HILOGD("Get all system hot key, ret:%{public}d", ret);
         return ret;
     }
+    keyOptions.clear();
+    for (const auto &item : options) {
+        keyOptions.push_back(std::move(*item));
+    }
     return RET_OK;
 }
 
@@ -3683,8 +4048,24 @@ int32_t MMIService::SetInputDeviceEnable(int32_t deviceId, bool enable, int32_t
     return RET_OK;
 }
 
-int32_t MMIService::SetInputDeviceEnabled(int32_t deviceId, bool enable, int32_t index)
+ErrCode MMIService::SetInputDeviceEnabled(int32_t deviceId, bool enable, int32_t index)
 {
+    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 (!PER_HELPER->CheckInputDeviceController()) {
+        MMI_HILOGE("Controller permission check failed");
+        return ERROR_NO_PERMISSION;
+    }
+    if (deviceId < 0) {
+        MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
+        return RET_ERR;
+    }
     CALL_INFO_TRACE;
     int32_t pid = GetCallingPid();
     auto sess = GetSessionByPid(pid);
@@ -3700,9 +4081,17 @@ int32_t MMIService::SetInputDeviceEnabled(int32_t deviceId, bool enable, int32_t
     return RET_OK;
 }
 
-int32_t MMIService::ShiftAppPointerEvent(const ShiftWindowParam &param, bool autoGenDown)
+ErrCode MMIService::ShiftAppPointerEvent(const ShiftWindowParam &param, bool autoGenDown)
 {
     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_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
     int32_t ret = delegateTasks_.PostSyncTask(
         [param, autoGenDown]() {
@@ -3717,9 +4106,14 @@ int32_t MMIService::ShiftAppPointerEvent(const ShiftWindowParam &param, bool aut
     return RET_OK;
 }
 
-int32_t MMIService::SetCustomCursor(int32_t windowId, CustomCursor cursor, CursorOptions options)
+ErrCode MMIService::SetCustomCursor(int32_t windowId,
+    const CustomCursorParcel& curParcel, const CursorOptionsParcel& cOptionParcel)
 {
     CALL_INFO_TRACE;
+    if (!IsRunning()) {
+        MMI_HILOGE("Service is not running");
+        return MMISERVICE_NOT_RUNNING;
+    }
     int32_t pid = GetCallingPid();
     int32_t ret = delegateTasks_.PostSyncTask(std::bind(
         [pid, windowId] {
@@ -3730,6 +4124,12 @@ int32_t MMIService::SetCustomCursor(int32_t windowId, CustomCursor cursor, Curso
         MMI_HILOGE("Set the custom cursor failed, ret:%{public}d", ret);
         return ERROR_WINDOW_ID_PERMISSION_DENIED;
     }
+    CustomCursor cursor;
+    cursor.pixelMap = curParcel.pixelMap;
+    cursor.focusX = curParcel.focusX;
+    cursor.focusY = curParcel.focusY;
+    CursorOptions options;
+    options.followSystem = cOptionParcel.followSystem;
 #if defined OHOS_BUILD_ENABLE_POINTER
     ret = delegateTasks_.PostSyncTask(std::bind(
         [pid, windowId, cursor, options] {
@@ -3745,9 +4145,14 @@ int32_t MMIService::SetCustomCursor(int32_t windowId, CustomCursor cursor, Curso
 }
 
 #ifdef OHOS_BUILD_ENABLE_ANCO
-int32_t MMIService::CheckKnuckleEvent(float pointX, float pointY, bool &isKnuckleType)
+ErrCode MMIService::CheckKnuckleEvent(float pointX, float pointY, bool &isKnuckleType)
 {
     CALL_INFO_TRACE;
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
+    isKnuckleType = false;
 #if defined(OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER)
     int tryTimes = RETRY_CHECK_TIMES;
     int32_t ret = RET_ERR;
@@ -3789,8 +4194,12 @@ int32_t MMIService::SetMultiWindowScreenIdInner(uint64_t screenId, uint64_t disp
     return RET_OK;
 }
 
-int32_t MMIService::SetMultiWindowScreenId(uint64_t screenId, uint64_t displayNodeScreenId)
+ErrCode MMIService::SetMultiWindowScreenId(uint64_t screenId, uint64_t displayNodeScreenId)
 {
+    if (!PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
     int32_t ret = delegateTasks_.PostSyncTask(
         [this, &screenId, &displayNodeScreenId] {
             return this->SetMultiWindowScreenIdInner(screenId, displayNodeScreenId);
@@ -3806,6 +4215,12 @@ int32_t MMIService::SetMultiWindowScreenId(uint64_t screenId, uint64_t displayNo
 int32_t MMIService::SetKnuckleSwitch(bool knuckleSwitch)
 {
     CALL_INFO_TRACE;
+    int32_t callingUid = GetCallingUid();
+    int32_t gameUid = 7011;
+    if (callingUid != gameUid || !PER_HELPER->VerifySystemApp()) {
+        MMI_HILOGE("Verify system APP failed");
+        return ERROR_NOT_SYSAPI;
+    }
     int32_t pid = GetCallingPid();
     auto sess = GetSessionByPid(pid);
     auto eventKeyCommandHandler = InputHandler->GetKeyCommandHandler();