diff --git a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h
index f981c133d4429bf068c931fc153b77ab03bfe869..ac4d77215d30cd8f0da02edf7ebb3f2702288295 100644
--- a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h
+++ b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h
@@ -97,6 +97,9 @@ enum AudioByteSize : int32_t {
     BYTE_SIZE_SAMPLE_S32 = 4,
 };
 
+#define PRESTORE_INFO_AUDIO_BALANCE "audio_balance"
+#define PRESTORE_INFO_AUDIO_MONO "audio_mono"
+
 #define TIMEOUT_SECONDS_10 10
 #define TIMEOUT_SECONDS_5 5
 #define MAX_MIX_CHANNELS 32
diff --git a/frameworks/native/hdiadapter_new/include/manager/hdi_adapter_manager.h b/frameworks/native/hdiadapter_new/include/manager/hdi_adapter_manager.h
index 3903802371672677dd7fa04c23b5751bb9fa032a..24721d144201a43e7f81bca38472dbee836418ef 100644
--- a/frameworks/native/hdiadapter_new/include/manager/hdi_adapter_manager.h
+++ b/frameworks/native/hdiadapter_new/include/manager/hdi_adapter_manager.h
@@ -26,6 +26,7 @@
 #include "source/i_audio_capture_source.h"
 #include "adapter/i_device_manager.h"
 #include "util/callback_wrapper.h"
+#include "util/kv_pair.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -78,6 +79,12 @@ public:
         const std::function<std::shared_ptr<IAudioSourceCallback>(uint32_t)> cbGenerator,
         const std::function<bool(uint32_t)> &limitFunc = [](uint32_t id) -> bool { return false; });
 
+    template<typename T>
+    void UpdateSinkPrestoreInfo(const std::string infoKey, const T &info)
+    {
+        sinkPrestoreInfo_.Set(infoKey, info);
+    }
+
     void DumpInfo(std::string &dumpString);
 
 private:
@@ -92,6 +99,7 @@ private:
     void DecRefCount(uint32_t id);
     void DoRegistSinkCallback(uint32_t id, std::shared_ptr<IAudioRenderSink> sink);
     void DoRegistSourceCallback(uint32_t id, std::shared_ptr<IAudioCaptureSource> source);
+    void DoSetSinkPrestoreInfo(std::shared_ptr<IAudioRenderSink> sink);
 
 private:
     std::unordered_map<uint32_t, RenderSinkInfo> renderSinks_;
@@ -104,6 +112,8 @@ private:
     SinkCallbackWrapper sinkCbs_;
     SourceCallbackWrapper sourceCbs_;
     std::function<bool(uint32_t)> cbLimitFunc_[HDI_ID_BASE_NUM][HDI_CB_TYPE_NUM];
+    // prestore
+    KvPair<std::string> sinkPrestoreInfo_;
 };
 
 } // namespace AudioStandard
diff --git a/frameworks/native/hdiadapter_new/include/util/kv_pair.h b/frameworks/native/hdiadapter_new/include/util/kv_pair.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6c430eb5121fdebb2414bbc48ce3ed439df4d53
--- /dev/null
+++ b/frameworks/native/hdiadapter_new/include/util/kv_pair.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KV_PAIR_H
+#define KV_PAIR_H
+
+#include <iostream>
+#include <unordered_map>
+#include <mutex>
+#include "audio_errors.h"
+
+namespace OHOS {
+namespace AudioStandard {
+class Value {
+public:
+    Value() = default;
+    template<typename T>
+    explicit Value(const T &v) : dataWrapper_(new DataWrapperImpl<T>(v)) {}
+    ~Value() = default;
+    Value(const Value &) = delete;
+    Value &operator=(const Value &) = delete;
+    Value(const Value &&) = delete;
+    Value &operator=(const Value &&) = delete;
+
+    template<typename T>
+    void SetData(const T &v)
+    {
+        dataWrapper_.reset(new DataWrapperImpl<T>(v));
+    }
+    template<typename T>
+    int32_t GetData(T &v)
+    {
+        if (dataWrapper_ == nullptr) {
+            return ERR_INVALID_HANDLE;
+        }
+        v = static_cast<DataWrapperImpl<T> *>(dataWrapper_.get())->data_;
+        return SUCCESS;
+    }
+
+private:
+    struct DataWrapper {
+        virtual ~DataWrapper() = default;
+    };
+
+    template<typename T>
+    struct DataWrapperImpl : DataWrapper {
+        explicit DataWrapperImpl(const T &data) : data_(data) {}
+
+        T data_;
+    };
+    std::unique_ptr<DataWrapper> dataWrapper_;
+};
+
+template<typename K>
+class KvPair {
+public:
+    template<typename V>
+    void Set(const K &key, const V &value)
+    {
+        std::lock_guard<std::mutex> lock(kvMtx_);
+        kv_[key].template SetData<V>(value);
+    }
+    template<typename V>
+    int32_t Get(const K &key, V &value)
+    {
+        std::lock_guard<std::mutex> lock(kvMtx_);
+        if (kv_.count(key) == 0) {
+            return ERR_INVALID_HANDLE;
+        }
+        return kv_[key].template GetData<V>(value);
+    }
+    void Erase(const K &key)
+    {
+        std::lock_guard<std::mutex> lock(kvMtx_);
+        kv_.erase(key);
+    }
+
+private:
+    std::unordered_map<K, Value> kv_;
+    std::mutex kvMtx_;
+};
+} // namespace AudioStandard
+} // namespace OHOS
+
+#endif // KV_PAIR_H
diff --git a/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp b/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp
index 748a60ef6c4e5102740cfd083570d3976d5e31d8..06bfa03f3907e22f94f18d3364c9b06677ed36ec 100644
--- a/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp
+++ b/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp
@@ -145,6 +145,7 @@ std::shared_ptr<IAudioRenderSink> HdiAdapterManager::GetRenderSink(uint32_t rend
         return nullptr;
     }
     DoRegistSinkCallback(renderId, renderSink);
+    DoSetSinkPrestoreInfo(renderSink);
     renderSinks_[renderId].sink_ = renderSink;
     return renderSinks_[renderId].sink_;
 }
@@ -403,5 +404,24 @@ void HdiAdapterManager::DoRegistSourceCallback(uint32_t id, std::shared_ptr<IAud
     }
 }
 
+void HdiAdapterManager::DoSetSinkPrestoreInfo(std::shared_ptr<IAudioRenderSink> sink)
+{
+    float audioBalance = 0.0;
+    int32_t ret = sinkPrestoreInfo_.Get(PRESTORE_INFO_AUDIO_BALANCE, audioBalance);
+    if (ret == SUCCESS) {
+        sink->SetAudioBalanceValue(audioBalance);
+    } else {
+        AUDIO_WARNING_LOG("get %s fail", PRESTORE_INFO_AUDIO_BALANCE);
+    }
+
+    bool audioMono = false;
+    ret = sinkPrestoreInfo_.Get(PRESTORE_INFO_AUDIO_MONO, audioMono);
+    if (ret == SUCCESS) {
+        sink->SetAudioMonoState(audioMono);
+    } else {
+        AUDIO_WARNING_LOG("get %s fail", PRESTORE_INFO_AUDIO_MONO);
+    }
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/frameworks/native/hdiadapter_new/test/unittest/manager_unit_test.cpp b/frameworks/native/hdiadapter_new/test/unittest/manager_unit_test.cpp
index a650d61c47c4cec1fc5d00467aeaa7b892b60b71..cceab91dd362a32a4ab8ebe931184f9ea619f929 100644
--- a/frameworks/native/hdiadapter_new/test/unittest/manager_unit_test.cpp
+++ b/frameworks/native/hdiadapter_new/test/unittest/manager_unit_test.cpp
@@ -67,6 +67,8 @@ HWTEST_F(ManagerUnitTest, ManagerUnitTest_001, TestSize.Level1)
     ret = manager.ProcessSource(sourceProcessFunc);
     EXPECT_EQ(ret, SUCCESS);
 
+    manager.UpdateSinkPrestoreInfo<bool>("test", true);
+
     std::shared_ptr<IDeviceManager> deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL);
     EXPECT_NE(deviceManager, nullptr);
 
diff --git a/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp b/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp
index 0ba0851e12bc91fca843f39a6ba0dac8ffa9e33f..46491d4bddb92b539c5aa5eba047717a318bbac3 100644
--- a/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp
+++ b/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp
@@ -24,6 +24,7 @@
 #include "util/audio_running_lock.h"
 #include "util/ring_buffer_handler.h"
 #include "util/callback_wrapper.h"
+#include "util/kv_pair.h"
 
 using namespace testing::ext;
 
@@ -168,5 +169,23 @@ HWTEST_F(UtilUnitTest, CallbackWrapperUnitTest_002, TestSize.Level1)
     sourceCbWrapper.OnWakeupClose();
 }
 
+/**
+ * @tc.name   : Test KvPair API
+ * @tc.number : KvPairUnitTest_001
+ * @tc.desc   : Test KvPair action
+ */
+HWTEST_F(UtilUnitTest, KvPairUnitTest_001, TestSize.Level1)
+{
+    KvPair<std::string> kv;
+    kv.Set<uint32_t>("test", 1);
+    uint32_t value = 0;
+    auto ret = kv.Get<uint32_t>("test", value);
+    EXPECT_EQ(ret, SUCCESS);
+    EXPECT_EQ(value, 1);
+    kv.Erase("test");
+    ret = kv.Get<uint32_t>("test_1", value);
+    EXPECT_FALSE(ret);
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/server/src/audio_server.cpp b/services/audio_service/server/src/audio_server.cpp
index 6fe1f786f99ada05dc980312858ba41b1a2e9356..fc24b844363450ab48a06420b1d0589038dfef8d 100644
--- a/services/audio_service/server/src/audio_server.cpp
+++ b/services/audio_service/server/src/audio_server.cpp
@@ -1228,6 +1228,7 @@ void AudioServer::SetAudioMonoState(bool audioMono)
         return SUCCESS;
     };
     (void)HdiAdapterManager::GetInstance().ProcessSink(processFunc);
+    HdiAdapterManager::GetInstance().UpdateSinkPrestoreInfo<bool>(PRESTORE_INFO_AUDIO_MONO, audioMono);
 }
 
 void AudioServer::SetAudioBalanceValue(float audioBalance)
@@ -1260,6 +1261,7 @@ void AudioServer::SetAudioBalanceValue(float audioBalance)
         return SUCCESS;
     };
     (void)HdiAdapterManager::GetInstance().ProcessSink(processFunc);
+    HdiAdapterManager::GetInstance().UpdateSinkPrestoreInfo<float>(PRESTORE_INFO_AUDIO_BALANCE, audioBalance);
 }
 
 void AudioServer::NotifyDeviceInfo(std::string networkId, bool connected)