diff --git a/frameworks/js/napi/interaction/cooperate/include/js_event_cooperate_target.h b/frameworks/js/napi/interaction/cooperate/include/js_event_cooperate_target.h
index 11aaa267e622a77242aa4f33e69ccad12be0b3b1..8f50e511cad586b4fdb1ee57cdc825551d565efd 100644
--- a/frameworks/js/napi/interaction/cooperate/include/js_event_cooperate_target.h
+++ b/frameworks/js/napi/interaction/cooperate/include/js_event_cooperate_target.h
@@ -32,15 +32,19 @@
 namespace OHOS {
 namespace Msdp {
 namespace DeviceStatus {
-class JsEventCooperateTarget : public ICoordinationListener, public std::enable_shared_from_this<JsEventCooperateTarget> {
+class JsEventCooperateTarget : public ICoordinationListener,
+                               public std::enable_shared_from_this<JsEventCooperateTarget> {
 public:
     JsEventCooperateTarget();
     virtual ~JsEventCooperateTarget() = default;
     DISALLOW_COPY_AND_MOVE(JsEventCooperateTarget);
 
-    static void EmitJsEnable(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg);
-    static void EmitJsStart(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg);
-    static void EmitJsStop(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg);
+    static void EmitJsEnable(sptr<JsUtilCooperate::CallbackInfo> cb,
+        const std::string &deviceId, CoordinationMessage msg);
+    static void EmitJsStart(sptr<JsUtilCooperate::CallbackInfo> cb,
+        const std::string &deviceId, CoordinationMessage msg);
+    static void EmitJsStop(sptr<JsUtilCooperate::CallbackInfo> cb,
+        const std::string &deviceId, CoordinationMessage msg);
     static void EmitJsGetState(sptr<JsUtilCooperate::CallbackInfo> cb, bool state);
 
     void AddListener(napi_env env, const std::string &type, napi_value handle);
diff --git a/frameworks/js/napi/interaction/cooperate/src/js_cooperate_context.cpp b/frameworks/js/napi/interaction/cooperate/src/js_cooperate_context.cpp
index 6859f24992cb7ed4eaaefdcfdabf6a2386a321ad..ba502a7d6c61234e1c5ae61b27ea7e4823fc58eb 100644
--- a/frameworks/js/napi/interaction/cooperate/src/js_cooperate_context.cpp
+++ b/frameworks/js/napi/interaction/cooperate/src/js_cooperate_context.cpp
@@ -24,8 +24,8 @@ namespace Msdp {
 namespace DeviceStatus {
 namespace {
 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MSDP_DOMAIN_ID, "JsCooperateContext" };
-const char* COORDINATION_CLASS = "Coordination_class";
-const char* COORDINATION = "Coordination";
+const char* g_coordinationClass = "Coordination_class";
+const char* g_coordination = "Coordination";
 constexpr int32_t ZERO_PARAM = 0;
 constexpr int32_t ONE_PARAM = 1;
 constexpr int32_t TWO_PARAM = 2;
@@ -273,12 +273,12 @@ napi_value JsCooperateContext::CreateInstance(napi_env env)
         JsCooperateContext::JsConstructor, nullptr, sizeof(desc) / sizeof(desc[ZERO_PARAM]), nullptr, &jsClass);
     CHKRP(status, DEFINE_CLASS);
 
-    status = napi_set_named_property(env, global, COORDINATION_CLASS, jsClass);
+    status = napi_set_named_property(env, global, g_coordinationClass, jsClass);
     CHKRP(status, SET_NAMED_PROPERTY);
 
     napi_value jsInstance = nullptr;
     CHKRP(napi_new_instance(env, jsClass, ZERO_PARAM, nullptr, &jsInstance), NEW_INSTANCE);
-    CHKRP(napi_set_named_property(env, global, COORDINATION, jsInstance),
+    CHKRP(napi_set_named_property(env, global, g_coordination, jsInstance),
         SET_NAMED_PROPERTY);
 
     JsCooperateContext *jsContext = nullptr;
@@ -327,7 +327,7 @@ JsCooperateContext *JsCooperateContext::GetInstance(napi_env env)
     CHKRP(napi_get_global(env, &global), GET_GLOBAL);
 
     bool result = false;
-    CHKRP(napi_has_named_property(env, global, COORDINATION, &result), HAS_NAMED_PROPERTY);
+    CHKRP(napi_has_named_property(env, global, g_coordination, &result), HAS_NAMED_PROPERTY);
     if (!result) {
         FI_HILOGE("Coordination was not found");
         return nullptr;
@@ -340,7 +340,7 @@ JsCooperateContext *JsCooperateContext::GetInstance(napi_env env)
         return nullptr;
     }
     napi_value object = nullptr;
-    CHKRP_SCOPE(env, napi_get_named_property(env, global, COORDINATION, &object), GET_NAMED_PROPERTY, scope);
+    CHKRP_SCOPE(env, napi_get_named_property(env, global, g_coordination, &object), GET_NAMED_PROPERTY, scope);
     if (object == nullptr) {
         napi_close_handle_scope(env, scope);
         FI_HILOGE("object is nullptr");
diff --git a/frameworks/js/napi/interaction/cooperate/src/js_event_cooperate_target.cpp b/frameworks/js/napi/interaction/cooperate/src/js_event_cooperate_target.cpp
index 4cc273dcaaaa6321f58dc02382439223e02f0ffd..58f9b8bd2efa954a2a3a614058acf01c2a9195a6 100644
--- a/frameworks/js/napi/interaction/cooperate/src/js_event_cooperate_target.cpp
+++ b/frameworks/js/napi/interaction/cooperate/src/js_event_cooperate_target.cpp
@@ -44,7 +44,8 @@ JsEventCooperateTarget::JsEventCooperateTarget()
     }
 }
 
-void JsEventCooperateTarget::EmitJsEnable(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg)
+void JsEventCooperateTarget::EmitJsEnable(sptr<JsUtilCooperate::CallbackInfo> cb,
+    const std::string &deviceId, CoordinationMessage msg)
 {
     CALL_INFO_TRACE;
     CHKPV(cb);
@@ -71,7 +72,8 @@ void JsEventCooperateTarget::EmitJsEnable(sptr<JsUtilCooperate::CallbackInfo> cb
     }
 }
 
-void JsEventCooperateTarget::EmitJsStart(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg)
+void JsEventCooperateTarget::EmitJsStart(sptr<JsUtilCooperate::CallbackInfo> cb,
+    const std::string &deviceId, CoordinationMessage msg)
 {
     CALL_INFO_TRACE;
     CHKPV(cb);
@@ -98,7 +100,8 @@ void JsEventCooperateTarget::EmitJsStart(sptr<JsUtilCooperate::CallbackInfo> cb,
     }
 }
 
-void JsEventCooperateTarget::EmitJsStop(sptr<JsUtilCooperate::CallbackInfo> cb, const std::string& deviceId, CoordinationMessage msg)
+void JsEventCooperateTarget::EmitJsStop(sptr<JsUtilCooperate::CallbackInfo> cb,
+    const std::string &deviceId, CoordinationMessage msg)
 {
     CALL_INFO_TRACE;
     CHKPV(cb);
@@ -208,7 +211,8 @@ monitorLabel:
     }
 }
 
-napi_value JsEventCooperateTarget::CreateCallbackInfo(napi_env env, napi_value handle, sptr<JsUtilCooperate::CallbackInfo> cb)
+napi_value JsEventCooperateTarget::CreateCallbackInfo(napi_env env,
+    napi_value handle, sptr<JsUtilCooperate::CallbackInfo> cb)
 {
     CALL_INFO_TRACE;
     CHKPP(cb);
diff --git a/frameworks/js/napi/interaction/coordination/src/js_coordination_context.cpp b/frameworks/js/napi/interaction/coordination/src/js_coordination_context.cpp
index 1e06cc6b6dc83466d925432982ecdfeb810f7f7d..69485b7d08cdd909e480d946cb522e0afa64766d 100755
--- a/frameworks/js/napi/interaction/coordination/src/js_coordination_context.cpp
+++ b/frameworks/js/napi/interaction/coordination/src/js_coordination_context.cpp
@@ -24,8 +24,8 @@ namespace Msdp {
 namespace DeviceStatus {
 namespace {
 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MSDP_DOMAIN_ID, "JsCoordinationContext" };
-const char* COORDINATION_CLASS = "Coordination_class";
-const char* COORDINATION = "Coordination";
+const char* g_coordinationClass = "Coordination_class";
+const char* g_coordination = "Coordination";
 constexpr int32_t ZERO_PARAM = 0;
 constexpr int32_t ONE_PARAM = 1;
 constexpr int32_t TWO_PARAM = 2;
@@ -300,12 +300,12 @@ napi_value JsCoordinationContext::CreateInstance(napi_env env)
         JsCoordinationContext::JsConstructor, nullptr, sizeof(desc) / sizeof(desc[0]), nullptr, &jsClass);
     CHKRP(status, DEFINE_CLASS);
 
-    status = napi_set_named_property(env, global, COORDINATION_CLASS, jsClass);
+    status = napi_set_named_property(env, global, g_coordinationClass, jsClass);
     CHKRP(status, SET_NAMED_PROPERTY);
 
     napi_value jsInstance = nullptr;
     CHKRP(napi_new_instance(env, jsClass, 0, nullptr, &jsInstance), NEW_INSTANCE);
-    CHKRP(napi_set_named_property(env, global, COORDINATION, jsInstance),
+    CHKRP(napi_set_named_property(env, global, g_coordination, jsInstance),
         SET_NAMED_PROPERTY);
 
     JsCoordinationContext *jsContext = nullptr;
@@ -354,7 +354,7 @@ JsCoordinationContext *JsCoordinationContext::GetInstance(napi_env env)
     CHKRP(napi_get_global(env, &global), GET_GLOBAL);
 
     bool result = false;
-    CHKRP(napi_has_named_property(env, global, COORDINATION, &result), HAS_NAMED_PROPERTY);
+    CHKRP(napi_has_named_property(env, global, g_coordination, &result), HAS_NAMED_PROPERTY);
     if (!result) {
         FI_HILOGE("Coordination was not found");
         return nullptr;
@@ -367,7 +367,7 @@ JsCoordinationContext *JsCoordinationContext::GetInstance(napi_env env)
         return nullptr;
     }
     napi_value object = nullptr;
-    CHKRP_SCOPE(env, napi_get_named_property(env, global, COORDINATION, &object), GET_NAMED_PROPERTY, scope);
+    CHKRP_SCOPE(env, napi_get_named_property(env, global, g_coordination, &object), GET_NAMED_PROPERTY, scope);
     if (object == nullptr) {
         napi_close_handle_scope(env, scope);
         FI_HILOGE("object is nullptr");
diff --git a/frameworks/native/interaction/test/unittest/src/interaction_manager_test.cpp b/frameworks/native/interaction/test/unittest/src/interaction_manager_test.cpp
index f820e824726a629e822a925a67a55a9dd724464a..9f714b5aed7cdd3828bb124106a1ec2e306a25df 100644
--- a/frameworks/native/interaction/test/unittest/src/interaction_manager_test.cpp
+++ b/frameworks/native/interaction/test/unittest/src/interaction_manager_test.cpp
@@ -39,6 +39,7 @@ constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MSDP_DOMAIN_ID, "Inter
 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
 constexpr int32_t TIME_WAIT_FOR_INJECT_MS { 20 };
 constexpr int32_t TIME_WAIT_FOR_TOUCH_DOWN_MS { 1000 };
+constexpr int32_t PROMISE_WAIT_SPAN { 2000 };
 constexpr int32_t MOUSE_POINTER_ID { 0 };
 constexpr int32_t TOUCH_POINTER_ID { 1 };
 constexpr int32_t DISPLAY_ID { 0 };
@@ -377,13 +378,37 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_PrepareCoordination, Tes
     std::promise<bool> promiseFlag;
     std::future<bool> futureFlag = promiseFlag.get_future();
     auto fun = [&promiseFlag](std::string listener, CoordinationMessage coordinationMessages) {
-        FI_HILOGD("Prepare coordination success");
+        FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
         promiseFlag.set_value(true);
     };
     int32_t ret = InteractionManager::GetInstance()->PrepareCoordination(fun);
 #ifdef OHOS_BUILD_ENABLE_COORDINATION
     ASSERT_EQ(ret, RET_OK);
-    ASSERT_TRUE(futureFlag.get());
+    ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
+#else
+    ASSERT_EQ(ret, ERROR_UNSUPPORT);
+#endif // OHOS_BUILD_ENABLE_COORDINATION
+}
+
+/**
+ * @tc.name: InteractionManagerTest_UnprepareCoordination
+ * @tc.desc: Prepare coordination
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnprepareCoordination, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    std::promise<bool> promiseFlag;
+    std::future<bool> futureFlag = promiseFlag.get_future();
+    auto fun = [&promiseFlag](std::string listener, CoordinationMessage coordinationMessages) {
+        FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
+        promiseFlag.set_value(true);
+    };
+    int32_t ret = InteractionManager::GetInstance()->UnprepareCoordination(fun);
+#ifdef OHOS_BUILD_ENABLE_COORDINATION
+    ASSERT_EQ(ret, RET_OK);
+    ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
 #else
     ASSERT_EQ(ret, ERROR_UNSUPPORT);
 #endif // OHOS_BUILD_ENABLE_COORDINATION
@@ -474,19 +499,19 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Nor
     int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(deviceId, fun);
 #ifdef OHOS_BUILD_ENABLE_COORDINATION
     ASSERT_EQ(ret, RET_OK);
-    ASSERT_TRUE(futureFlag.get());
+    ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
 #else
     ASSERT_EQ(ret, ERROR_UNSUPPORT);
 #endif // OHOS_BUILD_ENABLE_COORDINATION
 }
 
 /**
- * @tc.name: InteractionManagerTest_Draglistener
+ * @tc.name: InteractionManagerTest_Draglistener_Mouse
  * @tc.desc: Drag listener
  * @tc.type: FUNC
  * @tc.require:
  */
-HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.Level1)
+HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Mouse, TestSize.Level1)
 {
     CALL_TEST_DEBUG;
     if (g_deviceMouseId < 0) {
@@ -500,7 +525,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.L
                 FI_HILOGD("DragListenerTest state:%{public}d", state);
             };
         };
-        std::shared_ptr<DragListenerTest> listener = std::make_shared<DragListenerTest>();
+        auto listener = std::make_shared<DragListenerTest>();
         int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
         ASSERT_EQ(ret, RET_OK);
         std::promise<bool> promiseFlag;
@@ -520,7 +545,55 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.L
             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
+        ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
+        ASSERT_EQ(ret, RET_OK);
+    }
+}
+
+/**
+ * @tc.name: InteractionManagerTest_Draglistener_Touch
+ * @tc.desc: Drag listener
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Touch, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    if (g_deviceTouchId < 0) {
+        ASSERT_TRUE(g_deviceTouchId < 0);
+    } else {
+        class DragListenerTest : public IDragListener {
+        public:
+            DragListenerTest() : IDragListener() {}
+            void OnDragMessage(DragState state) override
+            {
+                FI_HILOGD("DragListenerTest state:%{public}d", state);
+            };
+        };
+        auto listener = std::make_shared<DragListenerTest>();
+        int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
+        ASSERT_EQ(ret, RET_OK);
+        std::promise<bool> promiseFlag;
+        std::future<bool> futureFlag = promiseFlag.get_future();
+        auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
+            FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
+                notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
+            promiseFlag.set_value(true);
+        };
+        SimulateDownEvent({ DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
+        std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
+            MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
+        ASSERT_TRUE(dragData);
+        ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), callback);
+        ASSERT_EQ(ret, RET_OK);
+        ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
+        ASSERT_EQ(ret, RET_OK);
+        SimulateMoveEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
+            MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
+        SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
+        InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
         ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
         ASSERT_EQ(ret, RET_OK);
     }
@@ -555,7 +628,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Mouse, TestSiz
             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 
@@ -586,7 +659,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Mouse, TestSize
         ASSERT_EQ(ret, RET_OK);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 
@@ -620,7 +693,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Touch, TestSiz
             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 
@@ -652,7 +725,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Touch, TestSize
         ASSERT_EQ(ret, RET_OK);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 
@@ -689,13 +762,15 @@ HWTEST_F(InteractionManagerTest, GetDragTargetPid_Mouse, TestSize.Level1)
             [&promiseEventFlag]{promiseEventFlag.set_value(true);});
         int32_t monitorId = TestAddMonitor(callbackPtr);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
-        ASSERT_TRUE(futureEventFlag.get());
+        ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
         TestRemoveMonitor(monitorId);
         int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
         FI_HILOGI("Target pid:%{public}d", pid);
         ASSERT_TRUE(pid > 0);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureStopFlag.get());
+        ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
     }
 }
 
@@ -733,13 +808,15 @@ HWTEST_F(InteractionManagerTest, GetDragTargetPid_Touch, TestSize.Level1)
             [&promiseEventFlag]{promiseEventFlag.set_value(true);});
         int32_t monitorId = TestAddMonitor(callbackPtr);
         SimulateUpEvent({ DRAG_DST_X, DRAG_DST_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
-        ASSERT_TRUE(futureEventFlag.get());
+        ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
         TestRemoveMonitor(monitorId);
         int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
         FI_HILOGI("Target pid:%{public}d", pid);
         ASSERT_TRUE(pid > 0);
         InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
-        ASSERT_TRUE(futureStopFlag.get());
+        ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
     }
 }
 
@@ -773,7 +850,8 @@ HWTEST_F(InteractionManagerTest, TouchEventDispatch, TestSize.Level1)
         int32_t monitorId = TestAddMonitor(callbackPtr);
         SimulateMoveEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_SRC_X, DRAG_SRC_Y },
             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
-        ASSERT_TRUE(futureEventFlag.get());
+        ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
         TestRemoveMonitor(monitorId);
         ret = InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
         ASSERT_EQ(ret, RET_OK);
@@ -809,7 +887,8 @@ HWTEST_F(InteractionManagerTest, MouseEventDispatch, TestSize.Level1)
         int32_t monitorId = TestAddMonitor(callbackPtr);
         SimulateMoveEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_SRC_X, DRAG_SRC_Y },
             MMI::PointerEvent::SOURCE_TYPE_MOUSE, TOUCH_POINTER_ID, true);
-        ASSERT_TRUE(futureEventFlag.get());
+        ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) !=
+            std::future_status::timeout);
         TestRemoveMonitor(monitorId);
         ret = InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
         ASSERT_EQ(ret, RET_OK);
@@ -867,7 +946,7 @@ HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetShadowOffset, TestSiz
     ASSERT_EQ(ret, RET_OK);
     ret = InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
     ASSERT_EQ(ret, RET_OK);
-    ASSERT_TRUE(futureFlag.get());
+    ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
 }
 
 /**
@@ -901,7 +980,7 @@ HWTEST_F(InteractionManagerTest, GetUdKey_Mouse, TestSize.Level1)
         ASSERT_EQ(udKey, UD_KEY);
         ret = InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
         ASSERT_EQ(ret, RET_OK);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 
@@ -937,7 +1016,7 @@ HWTEST_F(InteractionManagerTest, GetUdKey_Touch, TestSize.Level1)
         ASSERT_EQ(udKey, UD_KEY);
         ret = InteractionManager::GetInstance()->StopDrag(DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION);
         ASSERT_EQ(ret, RET_OK);
-        ASSERT_TRUE(futureFlag.get());
+        ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN)) != std::future_status::timeout);
     }
 }
 } // namespace DeviceStatus
diff --git a/services/device_manager/src/device_manager.cpp b/services/device_manager/src/device_manager.cpp
index 0aa5ed80ebe772d328d3e88b790b92c29c28c23f..d0eca434eeffdfe13608eb4cc7f131daca5e8b48 100755
--- a/services/device_manager/src/device_manager.cpp
+++ b/services/device_manager/src/device_manager.cpp
@@ -281,10 +281,9 @@ int32_t DeviceManager::EpollAdd(IEpollEventSource *source)
 {
     CALL_DEBUG_ENTER;
     CHKPR(source, RET_ERR);
-    struct epoll_event ev {
-        .events = EPOLLIN | EPOLLHUP | EPOLLERR,
-        .data.ptr = source,
-    };
+    struct epoll_event ev {};
+    ev.events = EPOLLIN | EPOLLHUP | EPOLLERR;
+    ev.data.ptr = source;
     int32_t ret = epoll_ctl(epollFd_, EPOLL_CTL_ADD, source->GetFd(), &ev);
     if (ret != 0) {
         FI_HILOGE("epoll_ctl failed: %{public}s", strerror(errno));
diff --git a/services/interaction/coordination/src/coordination_sm.cpp b/services/interaction/coordination/src/coordination_sm.cpp
old mode 100755
new mode 100644
index 561a0ccd343fc84de53b296f1341affc9cc25a54..350741ba4a313aad9e193712afcee799eac40425
--- a/services/interaction/coordination/src/coordination_sm.cpp
+++ b/services/interaction/coordination/src/coordination_sm.cpp
@@ -753,13 +753,13 @@ void CoordinationSM::DeviceInitCallBack::OnRemoteDied()
 void CoordinationSM::DmDeviceStateCallback::OnDeviceOnline(const DistributedHardware::DmDeviceInfo &deviceInfo)
 {
     CALL_DEBUG_ENTER;
-    COOR_SM->OnDeviceOnline(deviceInfo.deviceId);
+    COOR_SM->OnDeviceOnline(deviceInfo.networkId);
 }
 
 void CoordinationSM::DmDeviceStateCallback::OnDeviceOffline(const DistributedHardware::DmDeviceInfo &deviceInfo)
 {
     CALL_INFO_TRACE;
-    COOR_SM->OnDeviceOffline(deviceInfo.deviceId);
+    COOR_SM->OnDeviceOffline(deviceInfo.networkId);
 }
 
 void CoordinationSM::DmDeviceStateCallback::OnDeviceChanged(const DistributedHardware::DmDeviceInfo &deviceInfo)
@@ -796,8 +796,10 @@ void CoordinationSM::InterceptorConsumer::OnInputEvent(std::shared_ptr<MMI::KeyE
     int32_t keyCode = keyEvent->GetKeyCode();
     if (keyCode == MMI::KeyEvent::KEYCODE_BACK || keyCode == MMI::KeyEvent::KEYCODE_VOLUME_UP ||
         keyCode == MMI::KeyEvent::KEYCODE_VOLUME_DOWN || keyCode == MMI::KeyEvent::KEYCODE_POWER) {
-        keyEvent->AddFlag(MMI::AxisEvent::EVENT_FLAG_NO_INTERCEPT);
-        MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
+        if ((state == CoordinationState::STATE_OUT) || (!COOR_DEV_MGR->IsRemote(deviceId))) {
+            keyEvent->AddFlag(MMI::AxisEvent::EVENT_FLAG_NO_INTERCEPT);
+            MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
+        }
         return;
     }
     CoordinationState state = COOR_SM->GetCurrentCoordinationState();
diff --git a/services/native/test/unittest/src/devicestatus_service_test.cpp b/services/native/test/unittest/src/devicestatus_service_test.cpp
index 91c92068b9a71b4615994224af38634a167d29ee..29b6a9a88a287d693c36c9173aeb8f6934b48435 100644
--- a/services/native/test/unittest/src/devicestatus_service_test.cpp
+++ b/services/native/test/unittest/src/devicestatus_service_test.cpp
@@ -352,3 +352,27 @@ HWTEST_F (DeviceStatusServiceTest, GetDeviceStatusDataTest018, TestSize.Level0)
     g_client->UnsubscribeCallback(g_type, ActivityEvent::ENTER_EXIT, devCallback_);
     DEV_HILOGI(SERVICE, "GetDeviceStatusDataTest018 end");
 }
+
+/**
+ * @tc.name: GetDeviceStatusDataTest
+ * @tc.desc: test get devicestatus data in proxy
+ * @tc.type: FUNC
+ */
+HWTEST_F (DeviceStatusServiceTest, GetDeviceStatusDataTest019, TestSize.Level0)
+{
+    DEV_HILOGI(SERVICE, "GetDeviceStatusDataTest019 Enter");
+    g_type = Type::TYPE_VERTICAL_POSITION;
+    Data data = g_client->GetDeviceStatusData(g_type);
+    GTEST_LOG_(INFO) << "type: " << data.type;
+    GTEST_LOG_(INFO) << "value: " << data.value;
+    EXPECT_TRUE(data.type == Type::TYPE_VERTICAL_POSITION &&
+        (data.value >= OnChangedValue::VALUE_INVALID && data.value <= OnChangedValue::VALUE_EXIT))
+        << "GetDeviceStatusData failed";
+    Data invalidData;
+    invalidData.type = Type::TYPE_INVALID;
+    invalidData.value = OnChangedValue::VALUE_INVALID;
+    invalidData.status = Status::STATUS_INVALID;
+    invalidData.movement = 0.0f;
+    EXPECT_TRUE(data != invalidData);
+    DEV_HILOGI(SERVICE, "GetDeviceStatusDataTest019 end");
+}