diff --git a/frameworks/native/audioeffect/include/audio_effect_chain_manager.h b/frameworks/native/audioeffect/include/audio_effect_chain_manager.h
index 00d96946b5e2eb3340484ede87bc53bf92b4f538..5b36fa567447971d54e28e6d17e38c71eb2ee3a3 100644
--- a/frameworks/native/audioeffect/include/audio_effect_chain_manager.h
+++ b/frameworks/native/audioeffect/include/audio_effect_chain_manager.h
@@ -112,6 +112,9 @@ public:
     void InitAudioEffectChainManager(std::vector<EffectChain> &effectChains,
         const EffectChainManagerParam &effectChainManagerParam,
         std::vector<std::shared_ptr<AudioEffectLibEntry>> &effectLibraryList);
+    void ConstructEffectChainMgrMaps(std::vector<EffectChain> &effectChains,
+        const EffectChainManagerParam &effectChainManagerParam,
+        std::vector<std::shared_ptr<AudioEffectLibEntry>> &effectLibraryList);
     bool CheckAndAddSessionID(const std::string &sessionID);
     int32_t CreateAudioEffectChainDynamic(const std::string &sceneType);
     bool CheckAndRemoveSessionID(const std::string &sessionID);
@@ -150,6 +153,7 @@ public:
     int32_t InitEffectBuffer(const std::string &sessionID);
     int32_t QueryEffectChannelInfo(const std::string &sceneType, uint32_t &channels, uint64_t &channelLayout);
     int32_t QueryHdiSupportedChannelInfo(uint32_t &channels, uint64_t &channelLayout);
+    void LoadEffectProperties();
 private:
     int32_t SetAudioEffectChainDynamic(const std::string &sceneType, const std::string &effectMode);
     void UpdateSensorState();
@@ -194,6 +198,8 @@ private:
     int32_t EffectVolumeUpdateInner(std::shared_ptr<AudioEffectVolume> audioEffectVolume);
     void InitHdiStateInner();
     void UpdateSpatializationEnabled(AudioSpatializationState spatializationState);
+    void ConfigureAudioEffectChain(std::shared_ptr<AudioEffectChain> audioEffectChain,
+        const std::string &effectMode);
     std::map<std::string, std::shared_ptr<AudioEffectLibEntry>> effectToLibraryEntryMap_;
     std::map<std::string, std::string> effectToLibraryNameMap_;
     std::map<std::string, std::vector<std::string>> effectChainToEffectsMap_;
@@ -207,6 +213,7 @@ private:
     std::set<std::string> sceneTypeToSpecialEffectSet_;
     std::vector<std::string> priorSceneList_;
     std::unordered_map<std::string, std::string> effectPropertyMap_;
+    std::unordered_map<std::string, std::string> defaultPropertyMap_;
     std::vector<std::pair<std::string, int32_t>> sceneTypeCountList_;
     DeviceType deviceType_ = DEVICE_TYPE_SPEAKER;
     std::string deviceSink_ = DEFAULT_DEVICE_SINK;
@@ -230,6 +237,7 @@ private:
     int32_t maxEffectChainCount_ = 1;
     uint32_t maxSessionID_ = 0;
     AudioSpatialDeviceType spatialDeviceType_{ EARPHONE_TYPE_OTHERS };
+    bool hasLoadedEffectProperties_ = false;
 
 #ifdef SENSOR_ENABLE
     std::shared_ptr<HeadTracker> headTracker_;
diff --git a/frameworks/native/audioeffect/libaudio_effect.versionscript b/frameworks/native/audioeffect/libaudio_effect.versionscript
index 48fed5a7afd850d60cc391454674e04737521ed4..1f74ea8f0d7e14e3834733ef7b91d6326daa810d 100644
--- a/frameworks/native/audioeffect/libaudio_effect.versionscript
+++ b/frameworks/native/audioeffect/libaudio_effect.versionscript
@@ -76,6 +76,7 @@
     *EnhanceChainManagerSendInitCommand*;
     *InitEffectBuffer*;
     *EffectChainManagerQueryHdiSupportedChannelLayout*;
+    *LoadEffectProperties*;
   local:
     *;
 };
diff --git a/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp b/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp
index a36ef729bf2aab670cefc5ce6fd19e06b16dcd8f..a77fdadfbaf4350201086c9d24b1ce35954724b1 100644
--- a/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp
+++ b/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp
@@ -21,9 +21,17 @@
 #include "audio_errors.h"
 #include "audio_effect_log.h"
 #include "securec.h"
+#include "system_ability_definition.h"
+#include "audio_setting_provider.h"
 
 namespace OHOS {
 namespace AudioStandard {
+namespace {
+const std::unordered_map<std::string, std::string> AUDIO_PERSISTENCE_EFFECT_KEY {
+    {"voip_down", "settings.sound_ai_voip_down_selection"},
+};
+const std::vector<std::string> AUDIO_PERSISTENCE_SCENE {"SCENE_VOIP_DOWN"};
+}
 static int32_t CheckValidEffectLibEntry(const std::shared_ptr<AudioEffectLibEntry> &libEntry, const std::string &effect,
     const std::string &libName)
 {
@@ -81,7 +89,7 @@ AudioEffectChainManager::AudioEffectChainManager()
     deviceSink_ = DEFAULT_DEVICE_SINK;
     spatialDeviceType_ = EARPHONE_TYPE_OTHERS;
     isInitialized_ = false;
-
+    defaultPropertyMap_.clear();
 #ifdef SENSOR_ENABLE
     headTracker_ = std::make_shared<HeadTracker>();
 #endif
@@ -230,16 +238,28 @@ void AudioEffectChainManager::InitAudioEffectChainManager(std::vector<EffectChai
     std::vector<std::shared_ptr<AudioEffectLibEntry>> &effectLibraryList)
 {
     std::lock_guard<std::mutex> lock(dynamicMutex_);
-    const std::unordered_map<std::string, std::string> &map = effectChainManagerParam.sceneTypeToChainNameMap;
     maxEffectChainCount_ = effectChainManagerParam.maxExtraNum + 1;
     priorSceneList_ = effectChainManagerParam.priorSceneList;
+    ConstructEffectChainMgrMaps(effectChains, effectChainManagerParam, effectLibraryList);
+    AUDIO_INFO_LOG("EffectToLibraryEntryMap size %{public}zu", effectToLibraryEntryMap_.size());
+    AUDIO_DEBUG_LOG("EffectChainToEffectsMap size %{public}zu, SceneTypeAndModeToEffectChainNameMap size %{public}zu",
+        effectChainToEffectsMap_.size(), sceneTypeAndModeToEffectChainNameMap_.size());
+    InitHdiStateInner();
+    isInitialized_ = true;
+    RecoverAllChains();
+}
+
+void AudioEffectChainManager::ConstructEffectChainMgrMaps(std::vector<EffectChain> &effectChains,
+    const EffectChainManagerParam &effectChainManagerParam,
+    std::vector<std::shared_ptr<AudioEffectLibEntry>> &effectLibraryList)
+{
+    const std::unordered_map<std::string, std::string> &map = effectChainManagerParam.sceneTypeToChainNameMap;
     std::set<std::string> effectSet;
     for (EffectChain efc: effectChains) {
         for (std::string effect: efc.apply) {
             effectSet.insert(effect);
         }
     }
-
     // Construct EffectToLibraryEntryMap that stores libEntry for each effect name
     std::shared_ptr<AudioEffectLibEntry> libEntry = nullptr;
     std::string libName;
@@ -274,16 +294,8 @@ void AudioEffectChainManager::InitAudioEffectChainManager(std::vector<EffectChai
     }
     // Construct effectPropertyMap_ that stores effect's property
     effectPropertyMap_ = effectChainManagerParam.effectDefaultProperty;
-
-    AUDIO_INFO_LOG("EffectToLibraryEntryMap size %{public}zu", effectToLibraryEntryMap_.size());
-    AUDIO_DEBUG_LOG("EffectChainToEffectsMap size %{public}zu, SceneTypeAndModeToEffectChainNameMap size %{public}zu",
-        effectChainToEffectsMap_.size(), sceneTypeAndModeToEffectChainNameMap_.size());
-    InitHdiStateInner();
-#ifdef WINDOW_MANAGER_ENABLE
-    AUDIO_DEBUG_LOG("Call RegisterDisplayListener.");
-#endif
-    isInitialized_ = true;
-    RecoverAllChains();
+    defaultPropertyMap_ = effectChainManagerParam.effectDefaultProperty;
+    LoadEffectProperties();
 }
 
 bool AudioEffectChainManager::CheckAndAddSessionID(const std::string &sessionID)
@@ -327,11 +339,12 @@ int32_t AudioEffectChainManager::SetAudioEffectChainDynamic(const std::string &s
         effectChain = effectNone;
     }
 
-    audioEffectChain->SetEffectMode(effectMode);
-    audioEffectChain->SetExtraSceneType(extraSceneType_);
-    audioEffectChain->SetSpatialDeviceType(spatialDeviceType_);
-    audioEffectChain->SetSpatializationSceneType(spatializationSceneType_);
-    audioEffectChain->SetSpatializationEnabled(spatializationEnabled_);
+    ConfigureAudioEffectChain(audioEffectChain, effectMode);
+    bool exists = std::find(AUDIO_PERSISTENCE_SCENE.begin(), AUDIO_PERSISTENCE_SCENE.end(), sceneType) !=
+        AUDIO_PERSISTENCE_SCENE.end();
+    if (exists && !hasLoadedEffectProperties_) {
+        LoadEffectProperties();
+    }
     std::string tSceneType = (sceneType == DEFAULT_SCENE_TYPE ? DEFAULT_PRESET_SCENE : sceneType);
     for (std::string effect: effectChainToEffectsMap_[effectChain]) {
         AudioEffectHandle handle = nullptr;
@@ -359,6 +372,16 @@ int32_t AudioEffectChainManager::SetAudioEffectChainDynamic(const std::string &s
     return SUCCESS;
 }
 
+void AudioEffectChainManager::ConfigureAudioEffectChain(std::shared_ptr<AudioEffectChain> audioEffectChain,
+    const std::string &effectMode)
+{
+    audioEffectChain->SetEffectMode(effectMode);
+    audioEffectChain->SetExtraSceneType(extraSceneType_);
+    audioEffectChain->SetSpatialDeviceType(spatialDeviceType_);
+    audioEffectChain->SetSpatializationSceneType(spatializationSceneType_);
+    audioEffectChain->SetSpatializationEnabled(spatializationEnabled_);
+}
+
 bool AudioEffectChainManager::CheckAndRemoveSessionID(const std::string &sessionID)
 {
     std::lock_guard<std::mutex> lock(dynamicMutex_);
@@ -1327,6 +1350,28 @@ int32_t AudioEffectChainManager::SetAudioEffectProperty(const AudioEffectPropert
     return ret;
 }
 
+void AudioEffectChainManager::LoadEffectProperties()
+{
+    hasLoadedEffectProperties_ = false;
+    AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
+    CHECK_AND_RETURN_LOG(settingProvider.CheckOsAccountReady(), "os account not ready");
+    for (const auto &[effect, key] : AUDIO_PERSISTENCE_EFFECT_KEY) {
+        std::string prop = "";
+        ErrCode ret = settingProvider.GetStringValue(key, prop, "system");
+        if (!prop.empty() && ret == SUCCESS) {
+            AUDIO_INFO_LOG("effect->name %{public}s prop %{public}s", effect.c_str(), prop.c_str());
+            effectPropertyMap_[effect] = prop;
+        } else {
+            AUDIO_ERR_LOG("get prop failed for key %{public}s", key.c_str());
+            if (defaultPropertyMap_.count(effect) != 0) {
+                AUDIO_INFO_LOG("effect->name %{public}s defaultProp %{public}s", effect.c_str(), prop.c_str());
+                effectPropertyMap_[effect] = defaultPropertyMap_[effect];
+            }
+        }
+    }
+    hasLoadedEffectProperties_ = true;
+}
+
 int32_t AudioEffectChainManager::SetAudioEffectProperty(const AudioEffectPropertyArray &propertyArray)
 {
     std::lock_guard<std::mutex> lock(dynamicMutex_);
diff --git a/frameworks/native/audioeffect/src/audio_enhance_chain_manager.cpp b/frameworks/native/audioeffect/src/audio_enhance_chain_manager.cpp
index 9284fa97b5d4fb9cee77f56070e82cf3a26d8d5c..c79c02984988ce4e3421857498acc710d69f186a 100644
--- a/frameworks/native/audioeffect/src/audio_enhance_chain_manager.cpp
+++ b/frameworks/native/audioeffect/src/audio_enhance_chain_manager.cpp
@@ -202,6 +202,7 @@ void AudioEnhanceChainManager::UpdateEnhancePropertyMapFromDb(DeviceType deviceT
     std::string deviceTypeName = "";
     GetDeviceTypeName(deviceType, deviceTypeName);
     AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
+    CHECK_AND_RETURN_LOG(settingProvider.CheckOsAccountReady(), "os account not ready");
     for (auto &[enhance, prop] : enhancePropertyMap_) {
         std::string property = "";
         if (deviceTypeName == "") {
@@ -214,13 +215,13 @@ void AudioEnhanceChainManager::UpdateEnhancePropertyMapFromDb(DeviceType deviceT
         } else {
             key = enhance +  "_&_" + deviceTypeName;
         }
-        ErrCode ret = settingProvider.GetStringValue(key, property);
+        ErrCode ret = settingProvider.GetStringValue(key, property, "system");
         if (ret == SUCCESS) {
             prop = property;
             AUDIO_INFO_LOG("Get Effect_&_DeviceType:%{public}s is Property:%{public}s",
                 key.c_str(), property.c_str());
         } else {
-            ret = settingProvider.PutStringValue(key, defaultPropertyMap_[enhance]);
+            ret = settingProvider.PutStringValue(key, defaultPropertyMap_[enhance], "system");
             if (ret != SUCCESS) {
                 AUDIO_ERR_LOG("set to default Property:%{public}s, failed, ErrCode : %{public}d",
                     defaultPropertyMap_[enhance].c_str(), ret);
@@ -884,7 +885,8 @@ int32_t AudioEnhanceChainManager::SetAudioEnhancePropertyToChains(AudioEnhancePr
 int32_t AudioEnhanceChainManager::WriteEnhancePropertyToDb(const std::string &key, const std::string &property)
 {
     AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
-    ErrCode ret = settingProvider.PutStringValue(key, property);
+    CHECK_AND_RETURN_RET_LOG(settingProvider.CheckOsAccountReady(), ERROR, "os account not ready");
+    ErrCode ret = settingProvider.PutStringValue(key, property, "system");
     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Write Enhance Property to Database failed");
     AUDIO_INFO_LOG("success, write Enhance_&_DeviceType:%{public}s is Property:%{public}s to Database",
         key.c_str(), property.c_str());
diff --git a/services/audio_policy/server/include/service/service/audio_server_proxy.h b/services/audio_policy/server/include/service/service/audio_server_proxy.h
index 3cf1edc6ee1198c5dae2002200d3fef80f9b2341..a59487459cb06318fee429ad57e902d4ca2741c4 100644
--- a/services/audio_policy/server/include/service/service/audio_server_proxy.h
+++ b/services/audio_policy/server/include/service/service/audio_server_proxy.h
@@ -94,6 +94,7 @@ public:
     void SetAudioBalanceValueProxy(float audioBalance);
     int32_t SetSupportStreamUsageProxy(std::vector<int32_t> usage);
     int32_t SetCaptureSilentStateProxy(bool state);
+    void NotifyAccountsChanged();
 private:
     AudioServerProxy() {}
     ~AudioServerProxy() {}
diff --git a/services/audio_policy/server/src/service/audio_policy_service.cpp b/services/audio_policy/server/src/service/audio_policy_service.cpp
index 4a8cb1d6d93825c4001247d82eb0c2ea1a1ce9c3..77a95356ded92aca533d32c86560c6fccc5e53e9 100644
--- a/services/audio_policy/server/src/service/audio_policy_service.cpp
+++ b/services/audio_policy/server/src/service/audio_policy_service.cpp
@@ -1696,6 +1696,7 @@ void AudioPolicyService::NotifyAccountsChanged(const int &id)
     audioPolicyManager_.NotifyAccountsChanged(id);
     RegisterDataObserver();
     SubscribeAccessibilityConfigObserver();
+    AudioServerProxy::GetInstance().NotifyAccountsChanged();
 }
 
 int32_t AudioPolicyService::GetCurActivateCount()
diff --git a/services/audio_policy/server/src/service/service/audio_server_proxy.cpp b/services/audio_policy/server/src/service/service/audio_server_proxy.cpp
index 8746bf5f989368b189311e1d26b43aa510444ab0..1ffd632813c5360040055cb7ee96dbc1eb6680ff 100644
--- a/services/audio_policy/server/src/service/service/audio_server_proxy.cpp
+++ b/services/audio_policy/server/src/service/service/audio_server_proxy.cpp
@@ -478,5 +478,14 @@ int32_t AudioServerProxy::SetCaptureSilentStateProxy(bool state)
 #endif
 }
 
+void AudioServerProxy::NotifyAccountsChanged()
+{
+    const sptr<IStandardAudioService> gsp = GetAudioServerProxy();
+    CHECK_AND_RETURN_LOG(gsp != nullptr, "Service proxy unavailable");
+    std::string identity = IPCSkeleton::ResetCallingIdentity();
+    gsp->NotifyAccountsChanged();
+    IPCSkeleton::SetCallingIdentity(identity);
+}
+ 
 }
 }
diff --git a/services/audio_service/client/include/audio_manager_base.h b/services/audio_service/client/include/audio_manager_base.h
index a72a99a1d8943eedf81af508e50ec1babb5929f0..18bea3ab119c1050805faabb61f0135a7a19f232 100644
--- a/services/audio_service/client/include/audio_manager_base.h
+++ b/services/audio_service/client/include/audio_manager_base.h
@@ -493,6 +493,8 @@ public:
      * @return Returns result 0 if success, error number else.
      */
     virtual int32_t GenerateSessionId(uint32_t &sessionId) = 0;
+
+    virtual void NotifyAccountsChanged() = 0;
 public:
     DECLARE_INTERFACE_DESCRIPTOR(u"IStandardAudioService");
 };
@@ -572,6 +574,7 @@ private:
     int HandleGetOfflineAudioEffectChains(MessageParcel &data, MessageParcel &reply);
     int HandleGetStandbyStatus(MessageParcel &data, MessageParcel &reply);
     int HandleGenerateSessionId(MessageParcel &data, MessageParcel &reply);
+    int HandleNotifyAccountsChanged(MessageParcel &data, MessageParcel &reply);
 
     int HandleSecondPartCode(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);
     int HandleThirdPartCode(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);
diff --git a/services/audio_service/client/include/audio_manager_proxy.h b/services/audio_service/client/include/audio_manager_proxy.h
index b0aa7cb30f10a91bb61faceed1f95323fc8b36d1..ef2d222f740b2a7d872031df1107697c9e67a6bb 100644
--- a/services/audio_service/client/include/audio_manager_proxy.h
+++ b/services/audio_service/client/include/audio_manager_proxy.h
@@ -113,6 +113,7 @@ public:
     int32_t GetOfflineAudioEffectChains(std::vector<std::string> &effectChains) override;
     int32_t GetStandbyStatus(uint32_t sessionId, bool &isStandby, int64_t &enterStandbyTime) override;
     int32_t GenerateSessionId(uint32_t &sessionId) override;
+    void NotifyAccountsChanged() override;
 private:
     static inline BrokerDelegator<AudioManagerProxy> delegator_;
 };
diff --git a/services/audio_service/client/include/pulseaudio_ipc_interface_code.h b/services/audio_service/client/include/pulseaudio_ipc_interface_code.h
index 6943f26eeb870a0c001bea71feb1a7f50bcf9a86..bb441e33b6f5e269b13fa8bdfef27851a6abeca4 100644
--- a/services/audio_service/client/include/pulseaudio_ipc_interface_code.h
+++ b/services/audio_service/client/include/pulseaudio_ipc_interface_code.h
@@ -89,7 +89,8 @@ namespace AudioStandard {
         GET_OFFLINE_AUDIO_EFFECT_CHAINS,
         GET_STANDBY_STATUS,
         GENERATE_SESSION_ID,
-        AUDIO_SERVER_CODE_MAX = GENERATE_SESSION_ID,
+        NOTIFY_ACCOUNTS_CHANGED,
+        AUDIO_SERVER_CODE_MAX = NOTIFY_ACCOUNTS_CHANGED,
     };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/client/src/audio_manager_proxy.cpp b/services/audio_service/client/src/audio_manager_proxy.cpp
index c474daa8af76f0cd37749633cf4ab223d7828b93..3cb15ee9c6c53129978f1d76ddda985aa35136c1 100644
--- a/services/audio_service/client/src/audio_manager_proxy.cpp
+++ b/services/audio_service/client/src/audio_manager_proxy.cpp
@@ -1428,5 +1428,19 @@ int32_t AudioManagerProxy::GenerateSessionId(uint32_t &sessionId)
     sessionId = reply.ReadUint32();
     return 0;
 }
+
+void AudioManagerProxy::NotifyAccountsChanged()
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    bool ret = data.WriteInterfaceToken(GetDescriptor());
+    CHECK_AND_RETURN_LOG(ret, "WriteInterfaceToken failed");
+
+    int32_t error = Remote()->SendRequest(
+        static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_ACCOUNTS_CHANGED), data, reply, option);
+    CHECK_AND_RETURN_LOG(error == ERR_NONE, "failed,error:%d", error);
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/server/include/audio_server.h b/services/audio_service/server/include/audio_server.h
index 44ae4da86ad8cae6c11bd74e41ccaca287d07dc5..941e338dd89c394f08da60fe03f8b98758159c75 100644
--- a/services/audio_service/server/include/audio_server.h
+++ b/services/audio_service/server/include/audio_server.h
@@ -185,6 +185,8 @@ public:
     int32_t GetStandbyStatus(uint32_t sessionId, bool &isStandby, int64_t &enterStandbyTime) override;
 
     int32_t GenerateSessionId(uint32_t &sessionId) override;
+    
+    void NotifyAccountsChanged() override;
 protected:
     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
 
diff --git a/services/audio_service/server/src/audio_manager_stub.cpp b/services/audio_service/server/src/audio_manager_stub.cpp
index a9d1e1f340086eac07e59d9f46864ed3bcc3c125..9d6b52b1bc1e2c84e77634317170421a3ba9b2d9 100644
--- a/services/audio_service/server/src/audio_manager_stub.cpp
+++ b/services/audio_service/server/src/audio_manager_stub.cpp
@@ -109,6 +109,7 @@ const char *g_audioServerCodeStrs[] = {
     "GET_OFFLINE_AUDIO_EFFECT_CHAINS",
     "GET_STANDBY_STATUS",
     "GENERATE_SESSION_ID",
+    "NOTIFY_ACCOUNTS_CHANGED",
 };
 constexpr size_t codeNums = sizeof(g_audioServerCodeStrs) / sizeof(const char *);
 static_assert(codeNums == (static_cast<size_t> (AudioServerInterfaceCode::AUDIO_SERVER_CODE_MAX) + 1),
@@ -787,6 +788,8 @@ int AudioManagerStub::HandleFourthPartCode(uint32_t code, MessageParcel &data, M
             return HandleLoadHdiEffectModel(data, reply);
         case static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_EFFECT_BT_OFFLOAD_SUPPORTED):
             return HandleUpdateEffectBtOffloadSupported(data, reply);
+        case static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_ACCOUNTS_CHANGED):
+            return HandleNotifyAccountsChanged(data, reply);
         default:
             return HandleFifthPartCode(code, data, reply, option);
     }
@@ -1105,5 +1108,12 @@ int AudioManagerStub::HandleGenerateSessionId(MessageParcel &data, MessageParcel
     reply.WriteUint32(sessionId);
     return AUDIO_OK;
 }
+
+int AudioManagerStub::HandleNotifyAccountsChanged(MessageParcel &data, MessageParcel &reply)
+{
+    NotifyAccountsChanged();
+    return AUDIO_OK;
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/server/src/audio_server_effect.cpp b/services/audio_service/server/src/audio_server_effect.cpp
index 1ba760cd3caeb11423178941e257a8c202af24bf..0e27b05c6d8e4abd87cf72bcb841dc55ea40764e 100644
--- a/services/audio_service/server/src/audio_server_effect.cpp
+++ b/services/audio_service/server/src/audio_server_effect.cpp
@@ -322,5 +322,16 @@ bool AudioServer::LoadAudioEffectLibraries(const std::vector<Library> libraries,
     }
     return loadSuccess;
 }
+
+void AudioServer::NotifyAccountsChanged()
+{
+    int32_t callingUid = IPCSkeleton::GetCallingUid();
+    CHECK_AND_RETURN_LOG(PermissionUtil::VerifyIsAudio(), "refused for %{public}d", callingUid);
+
+    AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
+    CHECK_AND_RETURN_LOG(audioEffectChainManager != nullptr, "audioEffectChainManager is nullptr");
+    audioEffectChainManager->LoadEffectProperties();
+}
+
 } // namespace AudioStandard
 } // namespace OHOS