diff --git a/interfaces/ipc/src/distributed_input_source_stub.cpp b/interfaces/ipc/src/distributed_input_source_stub.cpp
index 345a77b..f8571e6 100644
--- a/interfaces/ipc/src/distributed_input_source_stub.cpp
+++ b/interfaces/ipc/src/distributed_input_source_stub.cpp
@@ -84,469 +84,440 @@ void DistributedInputSourceStub::RegRespFunMap()
     memberFuncMap_[static_cast<uint32_t>(IDInputSourceInterfaceCode::UNREGISTER_SESSION_STATE_CB)] =
         &DistributedInputSourceStub::HandleUnregisterSessionStateCb;
 }
-int32_t DistributedInputSourceStub::HandleInitDistributedHardware(MessageParcel &reply)
+
+bool DScreenSourceStub::HasEnableDHPermission()
 {
     Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
+    const std::string permissionName = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
     int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::unique_lock<std::mutex> lock(operatorMutex_);
-        if (sourceManagerInitFlag_.load()) {
-            DHLOGE("DistributedInputSourceStub already init.");
-            return DH_SUCCESS;
-        }
-        int32_t ret = Init();
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("DistributedInputSourceStub Init write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
-        }
-        sourceManagerInitFlag_.store(true);
-        DHLOGE("Enable Permission vailable");
+        permissionName);
+    return (result == Security::AccessToken::PERMISSION_GRANTED);
+}
+
+bool DScreenSourceStub::HasAccessDHPermission()
+{
+    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
+    const std::string permissionName = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
+    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
+        permissionName);
+    return (result == Security::AccessToken::PERMISSION_GRANTED);
+}
+
+int32_t DistributedInputSourceStub::HandleInitDistributedHardware(MessageParcel &reply)
+{
+    if (!HasEnableDHPermission()) {
+        DHLOGE("Enable Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    }
+    std::unique_lock<std::mutex> lock(operatorMutex_);
+    if (sourceManagerInitFlag_.load()) {
+        DHLOGE("DistributedInputSourceStub already init.");
         return DH_SUCCESS;
     }
-    DHLOGE("Enable Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    int32_t ret = Init();
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("DistributedInputSourceStub Init write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
+    }
+    sourceManagerInitFlag_.store(true);
+    DHLOGE("Enable Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleReleaseDistributedHardware(MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::unique_lock<std::mutex> lock(operatorMutex_);
-        if (!sourceManagerInitFlag_.load()) {
-            DHLOGE("DistributedInputSourceStub already Release.");
-            return DH_SUCCESS;
-        }
-        int32_t ret = Release();
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("DistributedInputSourceStub release write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
-        }
-        sourceManagerInitFlag_.store(false);
-        DHLOGE("Enable Permission vailable");
+    if (!HasEnableDHPermission()) {
+        DHLOGE("Enable Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    }
+    std::unique_lock<std::mutex> lock(operatorMutex_);
+    if (!sourceManagerInitFlag_.load()) {
+        DHLOGE("DistributedInputSourceStub already Release.");
         return DH_SUCCESS;
     }
-    DHLOGE("Enable Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    int32_t ret = Release();
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("DistributedInputSourceStub release write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
+    }
+    sourceManagerInitFlag_.store(false);
+    DHLOGE("Enable Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleRegisterDistributedHardware(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string devId = data.ReadString();
-        std::string dhId = data.ReadString();
-        std::string params = data.ReadString();
-        sptr<IRegisterDInputCallback> callback = iface_cast<IRegisterDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleRegisterDistributedHardware failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = RegisterDistributedHardware(devId, dhId, params, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleRegisterDistributedHardware write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
-        }
-        DHLOGE("Enable Permission vailable");
-        return DH_SUCCESS;
+    if (!HasEnableDHPermission()) {
+        DHLOGE("Enable Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Enable Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string devId = data.ReadString();
+    std::string dhId = data.ReadString();
+    std::string params = data.ReadString();
+    sptr<IRegisterDInputCallback> callback = iface_cast<IRegisterDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleRegisterDistributedHardware failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = RegisterDistributedHardware(devId, dhId, params, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleRegisterDistributedHardware write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
+    }
+    DHLOGE("Enable Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleUnregisterDistributedHardware(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string devId = data.ReadString();
-        std::string dhId = data.ReadString();
-        sptr<IUnregisterDInputCallback> callback = iface_cast<IUnregisterDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleUnregisterDistributedHardware failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = UnregisterDistributedHardware(devId, dhId, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleUnregisterDistributedHardware write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
-        }
-        DHLOGE("Enable Permission vailable");
-        return DH_SUCCESS;
+    if (!HasEnableDHPermission()) {
+        DHLOGE("Enable Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Enable Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string devId = data.ReadString();
+    std::string dhId = data.ReadString();
+    sptr<IUnregisterDInputCallback> callback = iface_cast<IUnregisterDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleUnregisterDistributedHardware failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = UnregisterDistributedHardware(devId, dhId, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleUnregisterDistributedHardware write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
+    }
+    DHLOGE("Enable Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandlePrepareRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string deviceId = data.ReadString();
-        sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandlePrepareRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = PrepareRemoteInput(deviceId, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandlePrepareRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string deviceId = data.ReadString();
+    sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandlePrepareRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = PrepareRemoteInput(deviceId, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandlePrepareRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleUnprepareRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-        if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string deviceId = data.ReadString();
-        sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleUnprepareRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = UnprepareRemoteInput(deviceId, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleUnprepareRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string deviceId = data.ReadString();
+    sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleUnprepareRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = UnprepareRemoteInput(deviceId, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleUnprepareRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStartRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string deviceId = data.ReadString();
-        uint32_t inputTypes = data.ReadUint32();
-        sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStartRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StartRemoteInput(deviceId, inputTypes, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStartRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string deviceId = data.ReadString();
+    uint32_t inputTypes = data.ReadUint32();
+    sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStartRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StartRemoteInput(deviceId, inputTypes, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStartRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStopRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string deviceId = data.ReadString();
-        uint32_t inputTypes = data.ReadUint32();
-        sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStopRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StopRemoteInput(deviceId, inputTypes, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStopRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string deviceId = data.ReadString();
+    uint32_t inputTypes = data.ReadUint32();
+    sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStopRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StopRemoteInput(deviceId, inputTypes, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStopRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStartRelayTypeRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-        uint32_t inputTypes = data.ReadUint32();
-        sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStartRelayTypeRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StartRemoteInput(srcId, sinkId, inputTypes, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStartRelayTypeRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+    uint32_t inputTypes = data.ReadUint32();
+    sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStartRelayTypeRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StartRemoteInput(srcId, sinkId, inputTypes, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStartRelayTypeRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStopRelayTypeRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-        uint32_t inputTypes = data.ReadUint32();
-        sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStopRelayTypeRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StopRemoteInput(srcId, sinkId, inputTypes, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStopRelayTypeRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+    uint32_t inputTypes = data.ReadUint32();
+    sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStopRelayTypeRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StopRemoteInput(srcId, sinkId, inputTypes, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStopRelayTypeRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandlePrepareRelayRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-        sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandlePrepareRelayRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = PrepareRemoteInput(srcId, sinkId, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandlePrepareRelayRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+    sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandlePrepareRelayRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = PrepareRemoteInput(srcId, sinkId, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandlePrepareRelayRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleUnprepareRelayRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-        sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleUnprepareRelayRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = UnprepareRemoteInput(srcId, sinkId, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleUnprepareRelayRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+    sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleUnprepareRelayRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = UnprepareRemoteInput(srcId, sinkId, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleUnprepareRelayRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStartDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string sinkId = data.ReadString();
-
-        std::vector<std::string> tempVector;
-        uint32_t vecSize = data.ReadUint32();
-        if (vecSize > IPC_VECTOR_MAX_SIZE) {
-            DHLOGE("HandleStartDhidRemoteInput vecSize too large");
-            return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
-        }
-
-        for (uint32_t i = 0; i < vecSize; i++) {
-            std::string dhid = data.ReadString();
-            if (dhid.empty()) {
-                DHLOGE("HandleStartDhidRemoteInput dhid is empty");
-                continue;
-            }
-            tempVector.push_back(dhid);
-        }
-
-        sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStartDhidRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StartRemoteInput(sinkId, tempVector, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStartDhidRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string sinkId = data.ReadString();
+
+    std::vector<std::string> tempVector;
+    uint32_t vecSize = data.ReadUint32();
+    if (vecSize > IPC_VECTOR_MAX_SIZE) {
+        DHLOGE("HandleStartDhidRemoteInput vecSize too large");
+        return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
+    }
+
+    for (uint32_t i = 0; i < vecSize; i++) {
+        std::string dhid = data.ReadString();
+        if (dhid.empty()) {
+            DHLOGE("HandleStartDhidRemoteInput dhid is empty");
+            continue;
+        }
+        tempVector.push_back(dhid);
+    }
+
+    sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStartDhidRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StartRemoteInput(sinkId, tempVector, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStartDhidRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStopDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string sinkId = data.ReadString();
-
-        std::vector<std::string> tempVector;
-        uint32_t vecSize = data.ReadUint32();
-        if (vecSize > IPC_VECTOR_MAX_SIZE) {
-            DHLOGE("HandleStopDhidRemoteInput vecSize too large");
-            return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
-        }
-
-        for (uint32_t i = 0; i < vecSize; i++) {
-            std::string dhid = data.ReadString();
-            if (dhid.empty()) {
-                DHLOGE("HandleStopDhidRemoteInput dhid is empty");
-                continue;
-            }
-            tempVector.push_back(dhid);
-        }
-
-        sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStopDhidRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StopRemoteInput(sinkId, tempVector, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStopDhidRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string sinkId = data.ReadString();
+
+    std::vector<std::string> tempVector;
+    uint32_t vecSize = data.ReadUint32();
+    if (vecSize > IPC_VECTOR_MAX_SIZE) {
+        DHLOGE("HandleStopDhidRemoteInput vecSize too large");
+        return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
+    }
+
+    for (uint32_t i = 0; i < vecSize; i++) {
+        std::string dhid = data.ReadString();
+        if (dhid.empty()) {
+            DHLOGE("HandleStopDhidRemoteInput dhid is empty");
+            continue;
+        }
+        tempVector.push_back(dhid);
+    }
+
+    sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStopDhidRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StopRemoteInput(sinkId, tempVector, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStopDhidRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStartRelayDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-
-        std::vector<std::string> tempVector;
-        uint32_t vecSize = data.ReadUint32();
-        if (vecSize > IPC_VECTOR_MAX_SIZE) {
-            DHLOGE("HandleStartRelayDhidRemoteInput vecSize too large");
-            return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
-        }
-
-        for (uint32_t i = 0; i < vecSize; i++) {
-            std::string dhid = data.ReadString();
-            if (dhid.empty()) {
-                DHLOGE("HandleStartRelayDhidRemoteInput dhid is empty");
-                continue;
-            }
-            tempVector.push_back(dhid);
-        }
-
-        sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStartRelayDhidRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StartRemoteInput(srcId, sinkId, tempVector, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStartRelayDhidRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+
+    std::vector<std::string> tempVector;
+    uint32_t vecSize = data.ReadUint32();
+    if (vecSize > IPC_VECTOR_MAX_SIZE) {
+        DHLOGE("HandleStartRelayDhidRemoteInput vecSize too large");
+        return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
+    }
+
+    for (uint32_t i = 0; i < vecSize; i++) {
+        std::string dhid = data.ReadString();
+        if (dhid.empty()) {
+            DHLOGE("HandleStartRelayDhidRemoteInput dhid is empty");
+            continue;
+        }
+        tempVector.push_back(dhid);
+    }
+
+    sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStartRelayDhidRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StartRemoteInput(srcId, sinkId, tempVector, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStartRelayDhidRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleStopRelayDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        std::string srcId = data.ReadString();
-        std::string sinkId = data.ReadString();
-
-        std::vector<std::string> tempVector;
-        uint32_t vecSize = data.ReadUint32();
-        if (vecSize > IPC_VECTOR_MAX_SIZE) {
-            DHLOGE("HandleStopRelayDhidRemoteInput vecSize too large");
-            return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
-        }
-
-        for (uint32_t i = 0; i < vecSize; i++) {
-            std::string dhid = data.ReadString();
-            if (dhid.empty()) {
-                DHLOGE("HandleStopRelayDhidRemoteInput dhid is empty");
-                continue;
-            }
-            tempVector.push_back(dhid);
-        }
-
-        sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleStopRelayDhidRemoteInput failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = StopRemoteInput(srcId, sinkId, tempVector, callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleStopRelayDhidRemoteInput write ret failed");
-            return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
-        }
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    std::string srcId = data.ReadString();
+    std::string sinkId = data.ReadString();
+
+    std::vector<std::string> tempVector;
+    uint32_t vecSize = data.ReadUint32();
+    if (vecSize > IPC_VECTOR_MAX_SIZE) {
+        DHLOGE("HandleStopRelayDhidRemoteInput vecSize too large");
+        return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
+    }
+
+    for (uint32_t i = 0; i < vecSize; i++) {
+        std::string dhid = data.ReadString();
+        if (dhid.empty()) {
+            DHLOGE("HandleStopRelayDhidRemoteInput dhid is empty");
+            continue;
+        }
+        tempVector.push_back(dhid);
+    }
+
+    sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleStopRelayDhidRemoteInput failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = StopRemoteInput(srcId, sinkId, tempVector, callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleStopRelayDhidRemoteInput write ret failed");
+        return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
+    }
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleSyncNodeInfoRemoteInput(MessageParcel &data, MessageParcel &reply)
@@ -659,45 +630,39 @@ int32_t DistributedInputSourceStub::HandleUnregisterSimulationEventListener(Mess
 
 int32_t DistributedInputSourceStub::HandleRegisterSessionStateCb(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        sptr<ISessionStateCallback> callback = iface_cast<ISessionStateCallback>(data.ReadRemoteObject());
-        if (callback == nullptr) {
-            DHLOGE("HandleRegisterSessionStateCb failed, callback is nullptr.");
-            return ERR_DH_INPUT_POINTER_NULL;
-        }
-        int32_t ret = RegisterSessionStateCb(callback);
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleRegisterSessionStateCb write ret failed, ret = %d", ret);
-            return ERR_DH_INPUT_SRC_STUB_REGISTER_SESSION_STATE_FAIL;
-        }
-
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    sptr<ISessionStateCallback> callback = iface_cast<ISessionStateCallback>(data.ReadRemoteObject());
+    if (callback == nullptr) {
+        DHLOGE("HandleRegisterSessionStateCb failed, callback is nullptr.");
+        return ERR_DH_INPUT_POINTER_NULL;
+    }
+    int32_t ret = RegisterSessionStateCb(callback);
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleRegisterSessionStateCb write ret failed, ret = %d", ret);
+        return ERR_DH_INPUT_SRC_STUB_REGISTER_SESSION_STATE_FAIL;
+    }
+
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::HandleUnregisterSessionStateCb(MessageParcel &data, MessageParcel &reply)
 {
-    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
-    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
-    "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
-    if (result == Security::AccessToken::PERMISSION_GRANTED) {
-        int32_t ret = UnregisterSessionStateCb();
-        if (!reply.WriteInt32(ret)) {
-            DHLOGE("HandleUnregisterSessionStateCb write ret failed, ret = %d", ret);
-            return ERR_DH_INPUT_SRC_STUB_UNREGISTER_SESSION_STATE_FAIL;
-        }
-
-        DHLOGE("Access Permission vailable");
-        return DH_SUCCESS;
+    if (!HasAccessDHPermission()) {
+        DHLOGE("Access Permission inlvaliable");
+        return ERR_DH_INPUT_CLIENT_STOP_FAIL;
     }
-    DHLOGE("Access Permission invailable");
-    return ERR_DH_INPUT_CLIENT_STOP_FAIL;
+    int32_t ret = UnregisterSessionStateCb();
+    if (!reply.WriteInt32(ret)) {
+        DHLOGE("HandleUnregisterSessionStateCb write ret failed, ret = %d", ret);
+        return ERR_DH_INPUT_SRC_STUB_UNREGISTER_SESSION_STATE_FAIL;
+    }
+
+    DHLOGE("Access Permission vailable");
+    return DH_SUCCESS;
 }
 
 int32_t DistributedInputSourceStub::OnRemoteRequest(