diff --git a/interfaces/innerkits/wm/window_manager.h b/interfaces/innerkits/wm/window_manager.h
index ab2484ec0097888580ba5092b3aee9c3276ff362..aabdb23703e2cf2c41e5d8d92c5cad6e60acd903 100644
--- a/interfaces/innerkits/wm/window_manager.h
+++ b/interfaces/innerkits/wm/window_manager.h
@@ -1272,6 +1272,15 @@ public:
      */
     WMError MinimizeByWindowId(const std::vector<int32_t>& windowIds);
 
+    /**
+     * @brief Set the animation speed multiplier for a specific process.
+     *
+     * @param pid process id.
+     * @param multiplier The animation speed multiplier.
+     * @return WM_OK means set success, others means set failed.
+     */
+    WMError UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier);
+
     /**
      * @brief Set foreground window number. Only main window. Only support freeMultiWindow.
      *
diff --git a/window_scene/session/container/include/zidl/session_stage_interface.h b/window_scene/session/container/include/zidl/session_stage_interface.h
index 8497291f8949e8b9ea459f225acceb95ff5a02ff..9b495be0dc70380c56ff0c0eb7c6bcf669bff0a7 100644
--- a/window_scene/session/container/include/zidl/session_stage_interface.h
+++ b/window_scene/session/container/include/zidl/session_stage_interface.h
@@ -206,6 +206,7 @@ public:
         return WSError::WS_OK;
     }
     virtual void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) = 0;
+    virtual void ApplyAnimationSpeedMultiplier(float multiplier) = 0;
     virtual void NotifySessionFullScreen(bool fullScreen) {}
 
     // **Non** IPC interface
diff --git a/window_scene/session/container/include/zidl/session_stage_ipc_interface_code.h b/window_scene/session/container/include/zidl/session_stage_ipc_interface_code.h
index fa52c3b51c5a65d8eafcbc5088c26a0026996960..cfa7a98396db7ab283ae359c1f0d02fd3d44a67f 100644
--- a/window_scene/session/container/include/zidl/session_stage_ipc_interface_code.h
+++ b/window_scene/session/container/include/zidl/session_stage_ipc_interface_code.h
@@ -98,6 +98,8 @@ enum class SessionStageInterfaceCode {
     // Floating ball
     TRANS_ID_SEND_FB_ACTION_EVENT,
     TRANS_ID_NOTIFY_UPDATE_SHOW_DECOR_IN_FREE_MULTI_WINDOW,
+
+    TRANS_ID_APPLY_ANIMATION_SPEED_MULTIPLIER,
 };
 }   // namespace Rosen
 }   // namespace OHOS
diff --git a/window_scene/session/container/include/zidl/session_stage_proxy.h b/window_scene/session/container/include/zidl/session_stage_proxy.h
index 529d61df444a0d2009175667d778c9add07f1a35..f326e1136fcdb8cbcc5e924058b0bad704414586 100644
--- a/window_scene/session/container/include/zidl/session_stage_proxy.h
+++ b/window_scene/session/container/include/zidl/session_stage_proxy.h
@@ -80,6 +80,7 @@ public:
     WSError PcAppInPadNormalClose() override;
     WSError NotifyCompatibleModePropertyChange(const sptr<CompatibleModeProperty> property) override;
     void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) override;
+    void ApplyAnimationSpeedMultiplier(float multiplier) override;
     void NotifySessionFullScreen(bool fullScreen) override;
     WSError NotifyTargetRotationInfo(OrientationInfo& Info) override;
     RotationChangeResult NotifyRotationChange(const RotationChangeInfo& rotationChangeInfo) override;
diff --git a/window_scene/session/container/include/zidl/session_stage_stub.h b/window_scene/session/container/include/zidl/session_stage_stub.h
index 0b7c60efc29b6bb8169819f484de445316a75a8f..c45d889a3968f8a36c70f16e7b97d41df1c404a8 100644
--- a/window_scene/session/container/include/zidl/session_stage_stub.h
+++ b/window_scene/session/container/include/zidl/session_stage_stub.h
@@ -80,6 +80,7 @@ private:
     int HandlePcAppInPadNormalClose(MessageParcel& data, MessageParcel& reply);
     int HandleNotifyCompatibleModePropertyChange(MessageParcel& data, MessageParcel& reply);
     int HandleSetUniqueVirtualPixelRatio(MessageParcel& data, MessageParcel& reply);
+    int HandleApplyAnimationSpeedMultiplier(MessageParcel& data, MessageParcel& reply);
     int HandleNotifySessionFullScreen(MessageParcel& data, MessageParcel& reply);
     int HandleNotifyDumpInfo(MessageParcel& data, MessageParcel& reply);
     int HandleExtensionHostData(MessageParcel& data, MessageParcel& reply, MessageOption& option);
diff --git a/window_scene/session/container/src/zidl/session_stage_proxy.cpp b/window_scene/session/container/src/zidl/session_stage_proxy.cpp
index 53ec21dbf669bed366b8051e59c420e6f70303f8..e67405d6cf6aeb19d799ae52200d8b73f7199faf 100644
--- a/window_scene/session/container/src/zidl/session_stage_proxy.cpp
+++ b/window_scene/session/container/src/zidl/session_stage_proxy.cpp
@@ -1593,6 +1593,34 @@ void SessionStageProxy::SetUniqueVirtualPixelRatio(bool useUniqueDensity, float
     }
 }
 
+void SessionStageProxy::ApplyAnimationSpeedMultiplier(float multiplier)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "remote is nullptr");
+        return;
+    }
+
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_ASYNC);
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "WriteInterfaceToken failed");
+        return;
+    }
+
+    if (!data.WriteFloat(multiplier)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Write multiplier failed");
+        return;
+    }
+
+    if (remote->SendRequest(static_cast<uint32_t>(SessionStageInterfaceCode::TRANS_ID_APPLY_ANIMATION_SPEED_MULTIPLIER),
+        data, reply, option) != ERR_NONE) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "SendRequest failed");
+        return;
+    }
+}
+
 WSError SessionStageProxy::NotifyDumpInfo(const std::vector<std::string>& params, std::vector<std::string>& info)
 {
     sptr<IRemoteObject> remote = Remote();
diff --git a/window_scene/session/container/src/zidl/session_stage_stub.cpp b/window_scene/session/container/src/zidl/session_stage_stub.cpp
index 04a419053839b243083cb77381f3a673100893b0..c7d96ae9d70d6511ec2aea6829c8d77503e8ace3 100644
--- a/window_scene/session/container/src/zidl/session_stage_stub.cpp
+++ b/window_scene/session/container/src/zidl/session_stage_stub.cpp
@@ -238,6 +238,8 @@ int SessionStageStub::OnRemoteRequest(uint32_t code, MessageParcel& data, Messag
             return HandleSendFbActionEvent(data, reply);
         case static_cast<uint32_t>(SessionStageInterfaceCode::TRANS_ID_NOTIFY_UPDATE_SHOW_DECOR_IN_FREE_MULTI_WINDOW):
             return HandleUpdateIsShowDecorInFreeMultiWindow(data, reply);
+        case static_cast<uint32_t>(SessionStageInterfaceCode::TRANS_ID_APPLY_ANIMATION_SPEED_MULTIPLIER):
+            return HandleApplyAnimationSpeedMultiplier(data, reply);
         default:
             WLOGFE("Failed to find function handler!");
             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
@@ -865,6 +867,18 @@ int SessionStageStub::HandleSetUniqueVirtualPixelRatio(MessageParcel& data, Mess
     return ERR_NONE;
 }
 
+int SessionStageStub::HandleApplyAnimationSpeedMultiplier(MessageParcel& data, MessageParcel& reply)
+{
+    TLOGD(WmsLogTag::WMS_ANIMATION, "HandleApplyAnimationSpeedMultiplier!");
+    float multiplier;
+    if (!data.ReadFloat(multiplier)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Read multiplier failed.");
+        return ERR_INVALID_DATA;
+    }
+    ApplyAnimationSpeedMultiplier(multiplier);
+    return ERR_NONE;
+}
+
 int SessionStageStub::HandleSetSplitButtonVisible(MessageParcel& data, MessageParcel& reply)
 {
     TLOGD(WmsLogTag::WMS_LAYOUT, "in");
diff --git a/window_scene/session/host/include/scene_session.h b/window_scene/session/host/include/scene_session.h
index 3de4319d29ef796f95cda7b01b5880cbc0b566ce..18b0c741ceaed7efb71038e9645267756050a4bd 100644
--- a/window_scene/session/host/include/scene_session.h
+++ b/window_scene/session/host/include/scene_session.h
@@ -494,6 +494,7 @@ public:
     virtual void SetSkipSelfWhenShowOnVirtualScreen(bool isSkip);
     virtual void SetSkipEventOnCastPlus(bool isSkip);
     WMError SetUniqueDensityDpi(bool useUnique, float dpi);
+    WMError ApplyAnimationSpeedMultiplier(float multiplier);
 
     bool IsAnco() const override;
     void SetBlank(bool isAddBlank) override;
diff --git a/window_scene/session/host/src/scene_session.cpp b/window_scene/session/host/src/scene_session.cpp
index 7bacd2bbf812fefcc955e26ca4bfff0cea3022b5..c8b9a6075ede21efb298ed2fdae5f2f06893647f 100644
--- a/window_scene/session/host/src/scene_session.cpp
+++ b/window_scene/session/host/src/scene_session.cpp
@@ -7512,6 +7512,21 @@ WMError SceneSession::SetUniqueDensityDpi(bool useUnique, float dpi)
     return WMError::WM_OK;
 }
 
+WMError SceneSession::ApplyAnimationSpeedMultiplier(float multiplier)
+{
+    if (!IsSessionValid()) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Session is invalid");
+        return WMError::WM_ERROR_INVALID_SESSION;
+    }
+
+    if (!sessionStage_) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "sessionStage_ is nullptr");
+        return WMError::WM_ERROR_NULLPTR;
+    }
+    sessionStage_->ApplyAnimationSpeedMultiplier(multiplier);
+    return WMError::WM_OK;
+}
+
 WMError SceneSession::SetSystemWindowEnableDrag(bool enableDrag)
 {
     if (!WindowHelper::IsSubWindow(GetWindowType()) && !WindowHelper::IsSystemWindow(GetWindowType())) {
diff --git a/window_scene/session_manager/include/scene_session_manager.h b/window_scene/session_manager/include/scene_session_manager.h
index b8488c0c1479e8e6c731738b0a3966cee887a416..e61f71d8fc3de228759e3642a7b489542f07fb40 100644
--- a/window_scene/session_manager/include/scene_session_manager.h
+++ b/window_scene/session_manager/include/scene_session_manager.h
@@ -754,6 +754,7 @@ public:
     bool IsMainWindowByPersistentId(int32_t persistentId);
     WMError MinimizeByWindowId(const std::vector<int32_t>& windowIds) override;
     void RegisterMinimizeByWindowIdCallback(MinimizeByWindowIdFunc&& func);
+    WMError UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier) override;
     void RegisterSceneSessionDestructCallback(NotifySceneSessionDestructFunc&& func);
     void RegisterTransferSessionToTargetScreenCallback(NotifyTransferSessionToTargetScreenFunc&& func);
     WMError NotifyTransferSessionToTargetScreen(const TransferSessionInfo& info);
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_interface.h b/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
index 8af9a8d0b3cda199844e7c369495ae94719e5f34..4143541a8cd8fb4cd74eeaaf0f4ff63024b51edd 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
@@ -156,6 +156,7 @@ public:
         TRANS_ID_REMOVE_SESSION_BLACK_LIST,
         TRANS_ID_GET_PIP_SWITCH_STATUS,
         TRANS_ID_RECOVER_WINDOW_PROPERTY_CHANGE_FLAG,
+        TRANS_ID_UPDATE_ANIMATION_SPEED_MULTIPLIER_FOR_PID,
     };
 
     virtual WSError SetSessionLabel(const sptr<IRemoteObject>& token, const std::string& label) = 0;
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h b/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
index 285e7f6ac81855e9513b833c80bc496a72f9eb96..7aa106082ff3379a0480571284d64674f6a5a0cf 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
@@ -167,6 +167,7 @@ public:
     WMError SetStartWindowBackgroundColor(
         const std::string& moduleName, const std::string& abilityName, uint32_t color, int32_t uid) override;
     WMError MinimizeByWindowId(const std::vector<int32_t>& windowIds) override;
+    WMError UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier) override;
     WMError SetForegroundWindowNum(uint32_t windowNum) override;
     WSError UseImplicitAnimation(int32_t hostWindowId, bool useImplicit) override;
     WMError RegisterWindowPropertyChangeAgent(WindowInfoKey windowInfoKey, uint32_t interestInfo,
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_stub.h b/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
index 57ca3b9ae61b266f8c89582187592c9bc7bccf6c..991bbc57c1cfce92922b633f68423b122f19069a 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
@@ -144,6 +144,7 @@ private:
 
     int ProcessRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option);
     int HandleMinimizeByWindowId(MessageParcel& data, MessageParcel& reply);
+    int HandleUpdateAnimationSpeedMultiplierForPid(MessageParcel& data, MessageParcel& reply);
     int HandleSetForegroundWindowNum(MessageParcel& data, MessageParcel& reply);
     int HandleUseImplicitAnimation(MessageParcel& data, MessageParcel& reply);
     int HandleCreateUIEffectController(MessageParcel& data, MessageParcel& reply);
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index 4597ef22bb32dad949a59e8d6da1484d015a507d..e31de0767406d84d119838eaf361f2ec55441f5f 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -16992,6 +16992,22 @@ void SceneSessionManager::RegisterMinimizeByWindowIdCallback(MinimizeByWindowIdF
     minimizeByWindowIdFunc_ = std::move(func);
 }
 
+WMError SceneSessionManager::UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier)
+{
+    if (!SessionPermission::IsSystemServiceCalling()) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "The caller is not system service.");
+        return WMError::WM_ERROR_INVALID_PERMISSION;
+    }
+
+    for (const auto& [_, session] : sceneSessionMap_) {
+        if (session && session->GetCallingPid() == pid && session->IsVisible()) {
+            session->ApplyAnimationSpeedMultiplier(multiplier);
+            return WMError::WM_OK;
+        }
+    }
+    return WMError::WM_OK;
+}
+
 const std::vector<sptr<SceneSession>> SceneSessionManager::GetActiveSceneSessionCopy()
 {
     std::map<int32_t, sptr<SceneSession>> sceneSessionMapCopy;
diff --git a/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp b/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
index ff0e9f6d4dceef7e70ae8fd87ca3cea1dac638e6..cfa36aa2498869fb0a54ecf67e432173d0c851fc 100644
--- a/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
+++ b/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
@@ -3669,6 +3669,42 @@ WMError SceneSessionManagerProxy::MinimizeByWindowId(const std::vector<int32_t>&
     return static_cast<WMError>(ret);
 }
 
+WMError SceneSessionManagerProxy::UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Write interfaceToken failed");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    if (!data.WriteInt32(pid)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Write pid failed");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    if (!data.WriteFloat(multiplier)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Write multiplier failed");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Remote is null");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    if (remote->SendRequest(static_cast<uint32_t>(
+        SceneSessionManagerMessage::TRANS_ID_UPDATE_ANIMATION_SPEED_MULTIPLIER_FOR_PID),
+        data, reply, option) != ERR_NONE) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "SendRequest failed");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    int32_t ret = 0;
+    if (!reply.ReadInt32(ret)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Read ret failed");
+        return WMError::WM_ERROR_IPC_FAILED;
+    }
+    return static_cast<WMError>(ret);
+}
+
 WMError SceneSessionManagerProxy::SetForegroundWindowNum(uint32_t windowNum)
 {
     MessageParcel data;
diff --git a/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp b/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
index 61331467e22be4e061bb1627add51dda2ad8cd5e..1ddc02cec8a5967299432fa2909bf8d3cb6df836 100644
--- a/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
+++ b/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
@@ -262,6 +262,8 @@ int SceneSessionManagerStub::ProcessRemoteRequest(uint32_t code, MessageParcel&
             return HandleGetPiPSettingSwitchStatus(data, reply);
         case static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_RECOVER_WINDOW_PROPERTY_CHANGE_FLAG):
             return HandleRecoverWindowPropertyChangeFlag(data, reply);
+        case static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UPDATE_ANIMATION_SPEED_MULTIPLIER_FOR_PID):
+            return HandleUpdateAnimationSpeedMultiplierForPid(data, reply);
         default:
             WLOGFE("Failed to find function handler!");
             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
@@ -2280,6 +2282,26 @@ int SceneSessionManagerStub::HandleMinimizeByWindowId(MessageParcel& data, Messa
     return ERR_NONE;
 }
 
+int SceneSessionManagerStub::HandleUpdateAnimationSpeedMultiplierForPid(MessageParcel& data, MessageParcel& reply)
+{
+    int32_t pid = 0;
+    float multiplier = 1.0f;
+    if (!data.ReadInt32(pid)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "read pid failed");
+        return ERR_INVALID_DATA;
+    }
+    if (!data.ReadFloat(multiplier)) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "read multiplier failed");
+        return ERR_INVALID_DATA;
+    }
+    WMError errCode = UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    if (!reply.WriteInt32(static_cast<int32_t>(errCode))) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "Write errCode failed.");
+        return ERR_INVALID_DATA;
+    }
+    return ERR_NONE;
+}
+
 int SceneSessionManagerStub::HandleSetForegroundWindowNum(MessageParcel& data, MessageParcel& reply)
 {
     uint32_t windowNum = 0;
diff --git a/window_scene/test/mock/mock_session_stage.h b/window_scene/test/mock/mock_session_stage.h
index a0d624abb00b67fdbe65df5dd4a62318f9143e5c..fa886a3ee19807f2fa70f1b2ae5e9f52ce53a053 100644
--- a/window_scene/test/mock/mock_session_stage.h
+++ b/window_scene/test/mock/mock_session_stage.h
@@ -68,6 +68,7 @@ public:
     MOCK_METHOD2(NotifyDisplayMove, void(DisplayId from, DisplayId to));
     MOCK_METHOD1(SwitchFreeMultiWindow, WSError(bool enable));
     MOCK_METHOD2(SetUniqueVirtualPixelRatio, void(bool useUniqueDensity, float virtualPixelRatio));
+    MOCK_METHOD1(ApplyAnimationSpeedMultiplier, void(float multiplier));
     MOCK_METHOD0(PcAppInPadNormalClose, WSError(void));
     MOCK_METHOD1(NotifyCompatibleModePropertyChange, WSError(const sptr<CompatibleModeProperty> property));
     MOCK_METHOD1(NotifySessionFullScreen, void(bool fullScreen));
diff --git a/window_scene/test/unittest/scene_session_manager_proxy_test.cpp b/window_scene/test/unittest/scene_session_manager_proxy_test.cpp
index abb741b14602a0b72481e2f31ca1f94343a05ac9..393277d00e8b7542979c779bd87bba7be45c6896 100644
--- a/window_scene/test/unittest/scene_session_manager_proxy_test.cpp
+++ b/window_scene/test/unittest/scene_session_manager_proxy_test.cpp
@@ -621,6 +621,22 @@ HWTEST_F(sceneSessionManagerProxyTest, SetStartWindowBackgroundColor, TestSize.L
         sceneSessionManagerProxy->SetStartWindowBackgroundColor("moduleName", "abilityName", 0xffffffff, 100));
 }
 
+/**
+ * @tc.name: UpdateAnimationSpeedMultiplierForPid
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(sceneSessionManagerProxyTest, UpdateAnimationSpeedMultiplierForPid, TestSize.Level1)
+{
+    sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
+    ASSERT_NE(iRemoteObjectMocker, nullptr);
+    sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
+        sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
+    ASSERT_NE(sceneSessionManagerProxy, nullptr);
+
+    EXPECT_EQ(WMError::WM_OK, sceneSessionManagerProxy->UpdateAnimationSpeedMultiplierForPid(10000, 2.0f));
+}
+
 /**
  * @tc.name: RemoveExtensionWindowStageFromSCB
  * @tc.desc: normal function
diff --git a/window_scene/test/unittest/scene_session_manager_stub_test.cpp b/window_scene/test/unittest/scene_session_manager_stub_test.cpp
index 4f901b1675d806e223f1e042e7a4380a8aba752e..d491545b282ebfdb420f6daaec5b52d080582bf7 100644
--- a/window_scene/test/unittest/scene_session_manager_stub_test.cpp
+++ b/window_scene/test/unittest/scene_session_manager_stub_test.cpp
@@ -2039,6 +2039,30 @@ HWTEST_F(SceneSessionManagerStubTest, HandleSetStartWindowBackgroundColor, TestS
     EXPECT_EQ(res, ERR_NONE);
 }
 
+/**
+ * @tc.name: HandleUpdateAnimationSpeedMultiplierForPid
+ * @tc.desc: test HandleUpdateAnimationSpeedMultiplierForPid
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerStubTest, HandleUpdateAnimationSpeedMultiplierForPid, TestSize.Level1)
+{
+    ASSERT_NE(stub_, nullptr);
+    MessageParcel data;
+    MessageParcel reply;
+
+    int res = stub_->HandleUpdateAnimationSpeedMultiplierForPid(data, reply);
+    EXPECT_EQ(res, ERR_INVALID_DATA);
+
+    data.WriteInt32(10000);
+    res = stub_->HandleUpdateAnimationSpeedMultiplierForPid(data, reply);
+    EXPECT_EQ(res, ERR_INVALID_DATA);
+
+    data.WriteInt32(10000);
+    data.WriteFloat(2.0f);
+    res = stub_->HandleUpdateAnimationSpeedMultiplierForPid(data, reply);
+    EXPECT_EQ(res, ERR_NONE);
+}
+
 /**
  * @tc.name: HandleNotifyScreenshotEvent
  * @tc.desc: test HandleNotifyScreenshotEvent
diff --git a/window_scene/test/unittest/scene_session_manager_test7.cpp b/window_scene/test/unittest/scene_session_manager_test7.cpp
index 396329d7c685ecb355d9ae0372e586d8919867ab..66bb54b9fa25678c865ef20dafb18f2dd752358c 100644
--- a/window_scene/test/unittest/scene_session_manager_test7.cpp
+++ b/window_scene/test/unittest/scene_session_manager_test7.cpp
@@ -2111,6 +2111,57 @@ HWTEST_F(SceneSessionManagerTest7, MinimizeByWindowId, TestSize.Level1)
     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, res);
 }
 
+/**
+ * @tc.name: UpdateAnimationSpeedMultiplierForPid
+ * @tc.desc: test function : UpdateAnimationSpeedMultiplierForPid
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionManagerTest7, UpdateAnimationSpeedMultiplierForPid, TestSize.Level1)
+{
+    ASSERT_NE(nullptr, ssm_);
+
+    MockAccesstokenKit::MockIsSACalling(false);
+
+    float multiplier = 2.0f;
+    int32_t pid = 1;
+
+    auto result = ssm_->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    EXPECT_EQ(result, WMError::WM_ERROR_INVALID_PERMISSION);
+
+    MockAccesstokenKit::MockIsSACalling(true);
+    SessionInfo info;
+    info.bundleName_ = "SceneSessionManagerTest7";
+    info.abilityName_ = "UpdateAnimationSpeedMultiplierForPid";
+    sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
+    sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
+    sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
+    sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(info, nullptr);
+    ASSERT_NE(sceneSession01, nullptr);
+    ASSERT_NE(sceneSession02, nullptr);
+    ASSERT_NE(sceneSession03, nullptr);
+    ASSERT_NE(sceneSession04, nullptr);
+    sceneSession01->isVisible_ = false;
+    sceneSession01->SetCallingPid(2);
+    ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
+    result = ssm_->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    EXPECT_EQ(result, WMError::WM_OK);
+    sceneSession02->isVisible_ = true;
+    sceneSession02->SetCallingPid(3);
+    ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
+    result = ssm_->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    EXPECT_EQ(result, WMError::WM_OK);
+    sceneSession03->isVisible_ = false;
+    sceneSession03->SetCallingPid(pid);
+    ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
+    result = ssm_->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    EXPECT_EQ(result, WMError::WM_OK);
+    sceneSession04->isVisible_ = true;
+    sceneSession04->SetCallingPid(pid);
+    ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
+    result = ssm_->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    EXPECT_EQ(result, WMError::WM_OK);
+}
+
 /**
  * @tc.name: SetForegroundWindowNum
  * @tc.desc: test function : SetForegroundWindowNum
diff --git a/window_scene/test/unittest/scene_session_test5.cpp b/window_scene/test/unittest/scene_session_test5.cpp
index 9ded5b7c1299ba413431cf3c483646428c53df09..8764f447932d7dc597a656570a147104ac15a87c 100644
--- a/window_scene/test/unittest/scene_session_test5.cpp
+++ b/window_scene/test/unittest/scene_session_test5.cpp
@@ -1518,6 +1518,31 @@ HWTEST_F(SceneSessionTest5, SetUniqueDensityDpi, TestSize.Level1)
     EXPECT_NE(nullptr, session->sessionStage_);
 }
 
+/**
+ * @tc.name: ApplyAnimationSpeedMultiplier
+ * @tc.desc: ApplyAnimationSpeedMultiplier function01
+ * @tc.type: FUNC
+ */
+HWTEST_F(SceneSessionTest5, ApplyAnimationSpeedMultiplier, TestSize.Level1)
+{
+    SessionInfo info;
+    info.abilityName_ = "ApplyAnimationSpeedMultiplier";
+    info.bundleName_ = "ApplyAnimationSpeedMultiplier";
+    sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
+    EXPECT_NE(session, nullptr);
+    session->sessionStage_ = nullptr;
+    EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, session->ApplyAnimationSpeedMultiplier(2.0f));
+    session->sessionInfo_.isSystem_ = false;
+    session->state_ = SessionState::STATE_DISCONNECT;
+    EXPECT_EQ(WMError::WM_ERROR_INVALID_SESSION, session->ApplyAnimationSpeedMultiplier(2.0f));
+    session->state_ = SessionState::STATE_CONNECT;
+    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, session->ApplyAnimationSpeedMultiplier(2.0f));
+
+    session->sessionStage_ = sptr<SessionStageMocker>::MakeSptr();
+    EXPECT_NE(nullptr, session->sessionStage_);
+    EXPECT_EQ(WMError::WM_OK, session->ApplyAnimationSpeedMultiplier(2.0f));
+}
+
 /**
  * @tc.name: HandleActionUpdateWindowModeSupportType
  * @tc.desc: HandleActionUpdateWindowModeSupportType function01
diff --git a/window_scene/test/unittest/session_stage_proxy_test.cpp b/window_scene/test/unittest/session_stage_proxy_test.cpp
index 3860f645c03f809fe68e3dcbe4720e84daf17dcf..2cb24d16b89e58966abdfea09f97abe95d3b13b8 100755
--- a/window_scene/test/unittest/session_stage_proxy_test.cpp
+++ b/window_scene/test/unittest/session_stage_proxy_test.cpp
@@ -286,6 +286,18 @@ HWTEST_F(SessionStageProxyTest, NotifyOccupiedAreaChangeInfo, TestSize.Level1)
     sessionStage_->NotifyOccupiedAreaChangeInfo(info, nullptr, {}, {});
 }
 
+/**
+ * @tc.name: ApplyAnimationSpeedMultiplier
+ * @tc.desc: test function : ApplyAnimationSpeedMultiplier
+ * @tc.type: FUNC
+ */
+HWTEST_F(SessionStageProxyTest, ApplyAnimationSpeedMultiplier, TestSize.Level1)
+{
+    float multiplier = 2.0f;
+    ASSERT_TRUE(sessionStage_ != nullptr);
+    sessionStage_->ApplyAnimationSpeedMultiplier(multiplier);
+}
+
 /**
  * @tc.name: NotifyKeyboardAnimationCompleted
  * @tc.desc: test function : NotifyKeyboardAnimationCompleted
diff --git a/window_scene/test/unittest/session_stage_stub_test.cpp b/window_scene/test/unittest/session_stage_stub_test.cpp
index 43c7b381be3d3a53510ab32df24cd4563516ee4f..b37e87c24b82d5c8350f382002286df103222324 100644
--- a/window_scene/test/unittest/session_stage_stub_test.cpp
+++ b/window_scene/test/unittest/session_stage_stub_test.cpp
@@ -811,6 +811,21 @@ HWTEST_F(SessionStageStubTest, HandleSetUniqueVirtualPixelRatio, TestSize.Level1
     ASSERT_EQ(0, sessionStageStub_->OnRemoteRequest(code, data, reply, option));
 }
 
+/**
+ * @tc.name: HandleApplyAnimationSpeedMultiplier
+ * @tc.desc: test function : HandleApplyAnimationSpeedMultiplier
+ * @tc.type: FUNC
+ */
+HWTEST_F(SessionStageStubTest, HandleApplyAnimationSpeedMultiplier, TestSize.Level1)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    ASSERT_TRUE(sessionStageStub_ != nullptr);
+    ASSERT_EQ(ERR_INVALID_DATA, sessionStageStub_->HandleApplyAnimationSpeedMultiplier(data, reply));
+    data.WriteFloat(2.0f);
+    ASSERT_EQ(0, sessionStageStub_->HandleApplyAnimationSpeedMultiplier(data, reply));
+}
+
 /**
  * @tc.name: HandleNotifySessionFullScreen
  * @tc.desc: test function : HandleNotifySessionFullScreen
diff --git a/wm/include/window_adapter.h b/wm/include/window_adapter.h
index 6367df9994be86ed99f70f85e9f930cab2d7f870..31c7777e0c1547e4580e0007bb87e5d78c55f0aa 100644
--- a/wm/include/window_adapter.h
+++ b/wm/include/window_adapter.h
@@ -153,6 +153,7 @@ public:
     virtual WMError NotifyWatchGestureConsumeResult(int32_t keyCode, bool isConsumed);
     virtual WMError NotifyWatchFocusActiveChange(bool isActive);
     virtual WMError MinimizeByWindowId(const std::vector<int32_t>& windowIds);
+    virtual WMError UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier);
     virtual WMError SetForegroundWindowNum(uint32_t windowNum);
     virtual WMError SetStartWindowBackgroundColor(
         const std::string& moduleName, const std::string& abilityName, uint32_t color, int32_t uid);
diff --git a/wm/include/window_scene_session_impl.h b/wm/include/window_scene_session_impl.h
index ab6fe0d41e38b9704a5c976fc759995229d99098..0ea1a881a0b2d80b75b0bd79be9eda6bbb8929fd 100644
--- a/wm/include/window_scene_session_impl.h
+++ b/wm/include/window_scene_session_impl.h
@@ -41,6 +41,7 @@ public:
     WMError DestroyHookWindow();
     WMError NotifyDrawingCompleted() override;
     WMError SetTextFieldAvoidInfo(double textFieldPositionY, double textFieldHeight) override;
+    void ApplyAnimationSpeedMultiplierIfEnabled();
     void PreProcessCreate();
     void SetDefaultProperty();
     WMError Minimize() override;
diff --git a/wm/include/window_session_impl.h b/wm/include/window_session_impl.h
index 0009e6d412494e24b50394451603544f019118c9..087ac626409075182b30064db39402424a01623d 100644
--- a/wm/include/window_session_impl.h
+++ b/wm/include/window_session_impl.h
@@ -57,6 +57,8 @@ using EnableIfSame = typename std::enable_if<std::is_same_v<T1, T2>, Ret>::type;
 const std::string SET_UICONTENT_TIMEOUT_LISTENER_TASK_NAME = "SetUIContentTimeoutListener";
 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_MS = 4000;
 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_AFTER_FREEZE_MS = 5000;
+static std::atomic<float> animationSpeedMultiplier = 1.0f;
+static std::atomic<bool> isEnableAnimationSpeedMultiplier = false;
 }
 
 struct WindowTitleVisibleFlags {
@@ -222,6 +224,8 @@ public:
         const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}) override;
     void UpdateDensity() override;
     void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) override;
+    void ApplyAnimationSpeedMultiplier(float multiplier) override;
+    void ApplyToAllWindowSessions(float multiplier);
     WSError UpdateOrientation() override;
     WSError UpdateDisplayId(uint64_t displayId) override;
     WSError UpdateFocus(bool focus) override;
diff --git a/wm/src/window_adapter.cpp b/wm/src/window_adapter.cpp
index 5f67dcc97139640c7266a61776c52abaa8a879c3..9a18b2df15389755207eff0395135ea9206928b9 100644
--- a/wm/src/window_adapter.cpp
+++ b/wm/src/window_adapter.cpp
@@ -1365,6 +1365,14 @@ WMError WindowAdapter::MinimizeByWindowId(const std::vector<int32_t>& windowIds)
     return wmsProxy->MinimizeByWindowId(windowIds);
 }
 
+WMError WindowAdapter::UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier)
+{
+    INIT_PROXY_CHECK_RETURN(WMError::WM_ERROR_SAMGR);
+    auto wmsProxy = GetWindowManagerServiceProxy();
+    CHECK_PROXY_RETURN_ERROR_IF_NULL(wmsProxy, WMError::WM_ERROR_SAMGR);
+    return wmsProxy->UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+}
+
 WMError WindowAdapter::SetForegroundWindowNum(uint32_t windowNum)
 {
     INIT_PROXY_CHECK_RETURN(WMError::WM_ERROR_SAMGR);
diff --git a/wm/src/window_manager.cpp b/wm/src/window_manager.cpp
index aeff5a314cc6fecdb62a2dafdc61944f7cbf6189..ead2dd49646334d2a356dce67728efbd04fd3ddb 100644
--- a/wm/src/window_manager.cpp
+++ b/wm/src/window_manager.cpp
@@ -2257,6 +2257,15 @@ WMError WindowManager::MinimizeByWindowId(const std::vector<int32_t>& windowIds)
     return ret;
 }
 
+WMError WindowManager::UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier)
+{
+    WMError ret = SingletonContainer::Get<WindowAdapter>().UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    if (ret != WMError::WM_OK) {
+        TLOGE(WmsLogTag::WMS_ANIMATION, "failed");
+    }
+    return ret;
+}
+
 WMError WindowManager::SetForegroundWindowNum(uint32_t windowNum)
 {
     WMError ret = WindowAdapter::GetInstance(userId_)->SetForegroundWindowNum(windowNum);
diff --git a/wm/src/window_scene_session_impl.cpp b/wm/src/window_scene_session_impl.cpp
index 6c22a3d99cb926ab88c277edf211c737fb631bf0..6a89bdf7bb420d042b0dc2542d49ca2b5ec41bc0 100644
--- a/wm/src/window_scene_session_impl.cpp
+++ b/wm/src/window_scene_session_impl.cpp
@@ -672,6 +672,7 @@ WMError WindowSceneSessionImpl::Create(const std::shared_ptr<AbilityRuntime::Con
         SetPcAppInpadSpecificSystemBarInvisible();
         SetPcAppInpadOrientationLandscape();
     }
+    ApplyAnimationSpeedMultiplierIfEnabled();
     TLOGI(WmsLogTag::WMS_LIFE, "Window Create success [name:%{public}s, id:%{public}d], state:%{public}u, "
         "mode:%{public}u, enableDefaultDensity:%{public}d, displayId:%{public}" PRIu64,
         property_->GetWindowName().c_str(), property_->GetPersistentId(), state_, GetWindowMode(),
@@ -679,6 +680,18 @@ WMError WindowSceneSessionImpl::Create(const std::shared_ptr<AbilityRuntime::Con
     return ret;
 }
 
+void WindowSceneSessionImpl::ApplyAnimationSpeedMultiplierIfEnabled()
+{
+    if (!isEnableAnimationSpeedMultiplier.load()) {
+        return;
+    }
+    auto rsUIContext = WindowSessionImpl::GetRSUIContext();
+    auto implicitAnimator = rsUIContext ? rsUIContext->GetRSImplicitAnimator() : nullptr;
+    if (implicitAnimator != nullptr) {
+        implicitAnimator->ApplyAnimationSpeedMultiplier(animationSpeedMultiplier.load());
+    }
+}
+
 WMError WindowSceneSessionImpl::SetPcAppInpadSpecificSystemBarInvisible()
 {
     TLOGI(WmsLogTag::WMS_COMPAT, "isPcAppInpadSpecificSystemBarInvisible: %{public}d",
diff --git a/wm/src/window_session_impl.cpp b/wm/src/window_session_impl.cpp
index 71678e79a04e57a4df22cfba1cc2e93be44a0702..61a8c724fa98fc4da75752ab4e8cb5c54a0a4064 100644
--- a/wm/src/window_session_impl.cpp
+++ b/wm/src/window_session_impl.cpp
@@ -1486,6 +1486,41 @@ void WindowSessionImpl::SetUniqueVirtualPixelRatio(bool useUniqueDensity, float
     }
 }
 
+void WindowSessionImpl::ApplyAnimationSpeedMultiplier(float multiplier)
+{
+    const char* const where = __func__;
+    auto task = [weakThis = wptr(this), multiplier, where, this] {
+        auto window = weakThis.promote();
+        if (window == nullptr) {
+            TLOGW(WmsLogTag::WMS_ANIMATION, "%{public}s: window is nullptr", where);
+            return;
+        }
+
+        ApplyToAllWindowSessions(multiplier);
+        
+        isEnableAnimationSpeedMultiplier.store(!FoldScreenStateInternel::FloatEqualAbs(multiplier, 1.0f));
+        animationSpeedMultiplier.store(multiplier);
+    };
+    handler_->PostTask(task, where, 0, AppExecFwk::EventQueue::Priority::HIGH);
+}
+
+void WindowSessionImpl::ApplyToAllWindowSessions(float multiplier)
+{
+    for (const auto& [_, pair] : windowSessionMap_) {
+        auto& WindowSession = pair.second;
+        if (!WindowSession) {
+            continue;
+        }
+        auto rsUIContext = WindowSession->GetRSUIContext();
+        auto implicitAnimator = rsUIContext ? rsUIContext->GetRSImplicitAnimator() : nullptr;
+        if (implicitAnimator == nullptr) {
+            TLOGE(WmsLogTag::WMS_ANIMATION, "Failed to open implicit animtion");
+            continue;
+        }
+        implicitAnimator->ApplyAnimationSpeedMultiplier(multiplier);
+    }
+}
+
 void WindowSessionImpl::CopyUniqueDensityParameter(sptr<WindowSessionImpl> parentWindow)
 {
     if (parentWindow) {
diff --git a/wm/test/unittest/window_adapter_test.cpp b/wm/test/unittest/window_adapter_test.cpp
index fc904dcc4f6b805427c49b81fd32205bfe398eaf..effb3490df0d37bc47f3a8afbf9839031bbfe6ad 100644
--- a/wm/test/unittest/window_adapter_test.cpp
+++ b/wm/test/unittest/window_adapter_test.cpp
@@ -1123,6 +1123,18 @@ HWTEST_F(WindowAdapterTest, MinimizeByWindowId, TestSize.Level1)
     ASSERT_EQ(ret, true);
 }
 
+/**
+ * @tc.name: UpdateAnimationSpeedMultiplierForPid
+ * @tc.desc: WindowAdapter/UpdateAnimationSpeedMultiplierForPid
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowAdapterTest, UpdateAnimationSpeedMultiplierForPid, TestSize.Level1)
+{
+    WindowAdapter windowAdapter;
+    auto err = windowAdapter.UpdateAnimationSpeedMultiplierForPid(10000, 2.0f);
+    ASSERT_EQ(WMError::WM_OK, err);
+}
+
 /**
  * @tc.name: ListWindowInfo01
  * @tc.desc: WindowAdapter/ListWindowInfo
diff --git a/wm/test/unittest/window_manager_test.cpp b/wm/test/unittest/window_manager_test.cpp
index 89d9f5f76862e3558d9a4867bab716aaf61e11b3..1e4af2a564085123ba8aa76ba71a1ea4c365026e 100644
--- a/wm/test/unittest/window_manager_test.cpp
+++ b/wm/test/unittest/window_manager_test.cpp
@@ -1699,6 +1699,23 @@ HWTEST_F(WindowManagerTest, MinimizeByWindowId, TestSize.Level1)
     ASSERT_EQ(WMError::WM_OK, ret_2);
 }
 
+/**
+ * @tc.name: UpdateAnimationSpeedMultiplierForPid
+ * @tc.desc: Check UpdateAnimationSpeedMultiplierForPid
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowManagerTest, UpdateAnimationSpeedMultiplierForPid, TestSize.Level1)
+{
+    auto& windowManager = WindowManager::GetInstance();
+    pid_t pid = 15234;
+    float multiplier = 2.0f;
+    WMError ret_1 = windowManager.UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    ASSERT_EQ(WMError::WM_OK, ret_1);
+    multiplier = 1.0f;
+    WMError ret_2 = windowManager.UpdateAnimationSpeedMultiplierForPid(pid, multiplier);
+    ASSERT_EQ(WMError::WM_OK, ret_2);
+}
+
 /**
  * @tc.name: ProcessRegisterWindowInfoChangeCallback01
  * @tc.desc: Check ProcessRegisterWindowInfoChangeCallback
diff --git a/wm/test/unittest/window_session_impl_test.cpp b/wm/test/unittest/window_session_impl_test.cpp
index 6a4ff804359080028856f5454eb6d0b4e7fd1022..27ec580ba69955d9ce4a3976a35419a7b1fa3b33 100644
--- a/wm/test/unittest/window_session_impl_test.cpp
+++ b/wm/test/unittest/window_session_impl_test.cpp
@@ -1960,6 +1960,22 @@ HWTEST_F(WindowSessionImplTest, SetUniqueVirtualPixelRatio, TestSize.Level1)
     window->SetUniqueVirtualPixelRatio(false, 3.25f);
 }
 
+/**
+ * @tc.name: ApplyAnimationSpeedMultiplier
+ * @tc.desc: ApplyAnimationSpeedMultiplier
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSessionImplTest, ApplyAnimationSpeedMultiplier, TestSize.Level1)
+{
+    sptr<WindowOption> option = new (std::nothrow) WindowOption();
+    ASSERT_NE(option, nullptr);
+    option->SetWindowName("ApplyAnimationSpeedMultiplier");
+    sptr<WindowSessionImpl> window = new (std::nothrow) WindowSessionImpl(option);
+    ASSERT_NE(window, nullptr);
+    window->ApplyAnimationSpeedMultiplier(1.0f);
+    window->ApplyAnimationSpeedMultiplier(2.0f);
+}
+
 /**
  * @tc.name: EnableDrag
  * @tc.desc: EnableDrag Test
diff --git a/wmserver/include/zidl/window_manager_interface.h b/wmserver/include/zidl/window_manager_interface.h
index 8fabfad55df58cc213081d83a4c1b03ba2538b7c..d15a91077faa4795f26e21aac3fb663f7cf4b46e 100644
--- a/wmserver/include/zidl/window_manager_interface.h
+++ b/wmserver/include/zidl/window_manager_interface.h
@@ -317,6 +317,7 @@ public:
     virtual WMError HasFloatingWindowForeground(const sptr<IRemoteObject>& abilityToken,
         bool& hasOrNot) { return WMError::WM_OK; }
     virtual WMError MinimizeByWindowId(const std::vector<int32_t>& windowIds) { return WMError::WM_OK; }
+    virtual WMError UpdateAnimationSpeedMultiplierForPid(pid_t pid, float multiplier) { return WMError::WM_OK; }
     virtual WMError SetForegroundWindowNum(uint32_t windowNum) { return WMError::WM_OK; }
     virtual WSError UseImplicitAnimation(int32_t hostWindowId, bool useImplicit) { return WSError::WS_OK; }
     virtual WMError AnimateTo(int32_t windowId, const WindowAnimationProperty& animationProperty,