diff --git a/frameworks/kitsimpl/audio_manager/src/audio_manager_napi.cpp b/frameworks/kitsimpl/audio_manager/src/audio_manager_napi.cpp
index 4f3f833f8dbf9d1c1cc1a67fb628ac0cb8a22d81..0b6b9595247ece4299cfe3cbe2ca7ea7cab3ccc4 100644
--- a/frameworks/kitsimpl/audio_manager/src/audio_manager_napi.cpp
+++ b/frameworks/kitsimpl/audio_manager/src/audio_manager_napi.cpp
@@ -34,7 +34,7 @@ napi_ref AudioManagerNapi::audioRingModeRef_ = nullptr;
     size_t argc = num;             \
     napi_value argv[num] = {0};    \
     napi_value thisVar = nullptr;  \
-    void* data;                    \
+    void *data;                    \
     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)
 
 struct AudioManagerAsyncContext {
@@ -43,6 +43,7 @@ struct AudioManagerAsyncContext {
     napi_deferred deferred;
     napi_ref callbackRef = nullptr;
     int32_t volType;
+    int32_t volLevel;
     int32_t deviceType;
     int32_t ringMode;
     int32_t deviceFlag;
@@ -51,11 +52,9 @@ struct AudioManagerAsyncContext {
     bool isMute;
     bool isActive;
     bool isTrue;
-    double volLevel;
-    double doubleValue;
     string key;
     string valueStr;
-    AudioManagerNapi* objectInfo;
+    AudioManagerNapi *objectInfo;
     vector<sptr<AudioDeviceDescriptor>> deviceDescriptors;
 };
 
@@ -229,14 +228,14 @@ napi_value AudioManagerNapi::CreateAudioVolumeTypeObject(napi_env env)
 
     status = napi_create_object(env, &result);
     if (status == napi_ok) {
-        for (int i = AudioManagerNapi::MEDIA; i <= AudioManagerNapi::RINGTONE; i++) {
+        for (int i = AudioManagerNapi::RINGTONE; i <= AudioManagerNapi::MEDIA; i++) {
             switch (i) {
-                case AudioManagerNapi::MEDIA:
-                    propName = "MEDIA";
-                    break;
                 case AudioManagerNapi::RINGTONE:
                     propName = "RINGTONE";
                     break;
+                case AudioManagerNapi::MEDIA:
+                    propName = "MEDIA";
+                    break;
                 default:
                     HiLog::Error(LABEL, "Invalid prop!");
                     continue;
@@ -408,17 +407,17 @@ napi_value AudioManagerNapi::CreateAudioRingModeObject(napi_env env)
 
     status = napi_create_object(env, &result);
     if (status == napi_ok) {
-        for (int i = RINGER_MODE_NORMAL; i <= RINGER_MODE_VIBRATE; i++) {
+        for (int i = AudioManagerNapi::RINGER_MODE_SILENT; i <= AudioManagerNapi::RINGER_MODE_NORMAL; i++) {
             switch (i) {
-                case RINGER_MODE_NORMAL:
-                    propName = "RINGER_MODE_NORMAL";
-                    break;
-                case RINGER_MODE_SILENT:
+                case AudioManagerNapi::RINGER_MODE_SILENT:
                     propName = "RINGER_MODE_SILENT";
                     break;
-                case RINGER_MODE_VIBRATE:
+                case AudioManagerNapi::RINGER_MODE_VIBRATE:
                     propName = "RINGER_MODE_VIBRATE";
                     break;
+                case AudioManagerNapi::RINGER_MODE_NORMAL:
+                    propName = "RINGER_MODE_NORMAL";
+                    break;
                 default:
                     HiLog::Error(LABEL, "Invalid prop!");
                     continue;
@@ -571,7 +570,7 @@ static string GetStringArgument(napi_env env, napi_value value)
 
     status = napi_get_value_string_utf8(env, value, nullptr, 0, &bufLength);
     if (status == napi_ok && bufLength > 0) {
-        buffer = (char *) malloc((bufLength + 1) * sizeof(char));
+        buffer = (char *)malloc((bufLength + 1) * sizeof(char));
         if (buffer != nullptr) {
             status = napi_get_value_string_utf8(env, value, buffer, bufLength + 1, &bufLength);
             if (status == napi_ok) {
@@ -617,7 +616,7 @@ static void CommonCallbackRoutine(napi_env env, AudioManagerAsyncContext* &async
     delete asyncContext;
 }
 
-static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, void* data)
+static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, void *data)
 {
     auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
     napi_value valueParam = nullptr;
@@ -632,7 +631,7 @@ static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, v
     }
 }
 
-static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void* data)
+static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data)
 {
     auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
     napi_value valueParam = nullptr;
@@ -647,22 +646,7 @@ static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void*
     }
 }
 
-static void GetDoubleValueAsyncCallbackComplete(napi_env env, napi_status status, void* data)
-{
-    auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
-    napi_value valueParam = nullptr;
-
-    if (asyncContext != nullptr) {
-        if (!asyncContext->status) {
-            napi_create_double(env, asyncContext->doubleValue, &valueParam);
-        }
-        CommonCallbackRoutine(env, asyncContext, valueParam);
-    } else {
-        HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!");
-    }
-}
-
-static void GetStringValueAsyncCallbackComplete(napi_env env, napi_status status, void* data)
+static void GetStringValueAsyncCallbackComplete(napi_env env, napi_status status, void *data)
 {
     auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
     napi_value valueParam = nullptr;
@@ -677,7 +661,7 @@ static void GetStringValueAsyncCallbackComplete(napi_env env, napi_status status
     }
 }
 
-static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void* data)
+static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data)
 {
     auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
     napi_value valueParam = nullptr;
@@ -730,7 +714,7 @@ napi_value AudioManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->status = context->objectInfo->audioMngr_->SetMicrophoneMute(context->isMute);
             },
@@ -785,7 +769,7 @@ napi_value AudioManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info i
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->isMute = context->objectInfo->audioMngr_->IsMicrophoneMute();
                 context->isTrue = context->isMute;
@@ -844,7 +828,7 @@ napi_value AudioManagerNapi::SetRingerMode(napi_env env, napi_callback_info info
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->status =
                     context->objectInfo->audioMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode));
@@ -900,7 +884,7 @@ napi_value AudioManagerNapi::GetRingerMode(napi_env env, napi_callback_info info
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->ringMode = GetJsAudioRingMode(context->objectInfo->audioMngr_->GetRingerMode());
                 context->intValue = context->ringMode;
@@ -962,7 +946,7 @@ napi_value AudioManagerNapi::SetStreamMute(napi_env env, napi_callback_info info
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->status = context->objectInfo->audioMngr_->SetMute(GetNativeAudioVolumeType(context->volType),
                                                                            context->isMute);
@@ -1021,7 +1005,7 @@ napi_value AudioManagerNapi::IsStreamMute(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->isMute =
                     context->objectInfo->audioMngr_->IsStreamMute(GetNativeAudioVolumeType(context->volType));
@@ -1082,7 +1066,7 @@ napi_value AudioManagerNapi::IsStreamActive(napi_env env, napi_callback_info inf
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->isActive =
                     context->objectInfo->audioMngr_->IsStreamActive(GetNativeAudioVolumeType(context->volType));
@@ -1145,7 +1129,7 @@ napi_value AudioManagerNapi::SetDeviceActive(napi_env env, napi_callback_info in
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->status = context->objectInfo->audioMngr_->SetDeviceActive(
                     GetNativeDeviceType(context->deviceType), context->isActive);
@@ -1204,7 +1188,7 @@ napi_value AudioManagerNapi::IsDeviceActive(napi_env env, napi_callback_info inf
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->isActive =
                     context->objectInfo->audioMngr_->IsDeviceActive(GetNativeDeviceType(context->deviceType));
@@ -1267,7 +1251,7 @@ napi_value AudioManagerNapi::SetAudioParameter(napi_env env, napi_callback_info
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->objectInfo->audioMngr_->SetAudioParameter(context->key, context->valueStr);
                 context->status = 0;
@@ -1325,7 +1309,7 @@ napi_value AudioManagerNapi::GetAudioParameter(napi_env env, napi_callback_info
         napi_create_string_utf8(env, "GetAudioParameter", NAPI_AUTO_LENGTH, &resource);
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->valueStr = context->objectInfo->audioMngr_->GetAudioParameter(context->key);
                 context->status = 0;
@@ -1366,7 +1350,7 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info)
             if (i == PARAM0 && valueType == napi_number) {
                 napi_get_value_int32(env, argv[i], &asyncContext->volType);
             } else if (i == PARAM1 && valueType == napi_number) {
-                napi_get_value_double(env, argv[i], &asyncContext->volLevel);
+                napi_get_value_int32(env, argv[i], &asyncContext->volLevel);
             } else if (i == PARAM2 && valueType == napi_function) {
                 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
                 break;
@@ -1386,10 +1370,10 @@ napi_value AudioManagerNapi::SetVolume(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->status = context->objectInfo->audioMngr_->SetVolume(GetNativeAudioVolumeType(context->volType),
-                                                                             static_cast<float>(context->volLevel));
+                                                                             context->volLevel);
             },
             SetFunctionAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
         if (status != napi_ok) {
@@ -1445,14 +1429,14 @@ napi_value AudioManagerNapi::GetVolume(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
-                context->volLevel = static_cast<double>(context->objectInfo->audioMngr_->GetVolume(
-                    GetNativeAudioVolumeType(context->volType)));
-                context->doubleValue = context->volLevel;
+                context->volLevel = context->objectInfo->audioMngr_->GetVolume(
+                    GetNativeAudioVolumeType(context->volType));
+                context->intValue = context->volLevel;
                 context->status = 0;
             },
-            GetDoubleValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
+            GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
         if (status != napi_ok) {
             result = nullptr;
         } else {
@@ -1506,14 +1490,14 @@ napi_value AudioManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
-                context->volLevel = static_cast<double>(context->objectInfo->audioMngr_->GetMaxVolume(
-                    GetNativeAudioVolumeType(context->volType)));
-                context->doubleValue = context->volLevel;
+                context->volLevel = context->objectInfo->audioMngr_->GetMaxVolume(
+                    GetNativeAudioVolumeType(context->volType));
+                context->intValue = context->volLevel;
                 context->status = 0;
             },
-            GetDoubleValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
+            GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
         if (status != napi_ok) {
             result = nullptr;
         } else {
@@ -1567,14 +1551,14 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
-                context->volLevel = static_cast<double>(context->objectInfo->audioMngr_->GetMinVolume(
-                    GetNativeAudioVolumeType(context->volType)));
-                context->doubleValue = context->volLevel;
+                context->volLevel = context->objectInfo->audioMngr_->GetMinVolume(
+                    GetNativeAudioVolumeType(context->volType));
+                context->intValue = context->volLevel;
                 context->status = 0;
             },
-            GetDoubleValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
+            GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
         if (status != napi_ok) {
             result = nullptr;
         } else {
@@ -1590,7 +1574,7 @@ napi_value AudioManagerNapi::GetMinVolume(napi_env env, napi_callback_info info)
     return result;
 }
 
-static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, void* data)
+static void GetDevicesAsyncCallbackComplete(napi_env env, napi_status status, void *data)
 {
     auto asyncContext = static_cast<AudioManagerAsyncContext*>(data);
     napi_value result[ARGS_TWO] = {0};
@@ -1659,7 +1643,7 @@ napi_value AudioManagerNapi::GetDevices(napi_env env, napi_callback_info info)
 
         status = napi_create_async_work(
             env, nullptr, resource,
-            [](napi_env env, void* data) {
+            [](napi_env env, void *data) {
                 auto context = static_cast<AudioManagerAsyncContext*>(data);
                 context->deviceDescriptors =
                     context->objectInfo->audioMngr_->GetDevices(GetNativeDeviceFlag(context->deviceFlag));
diff --git a/interfaces/innerkits/native/audiomanager/include/audio_system_manager.h b/interfaces/innerkits/native/audiomanager/include/audio_system_manager.h
index cde085460a19da073e9ea0912ba10d03c5be3b09..d2a2fd1f2f951b84568e38550b5b5c1bab91ee77 100644
--- a/interfaces/innerkits/native/audiomanager/include/audio_system_manager.h
+++ b/interfaces/innerkits/native/audiomanager/include/audio_system_manager.h
@@ -144,10 +144,10 @@ enum AudioVolumeType {
         STREAM_ACCESSIBILITY = 10
     };
     static AudioSystemManager* GetInstance();
-    int32_t SetVolume(AudioSystemManager::AudioVolumeType volumeType, float volume) const;
-    float GetVolume(AudioSystemManager::AudioVolumeType volumeType) const;
-    float GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) const;
-    float GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) const;
+    int32_t SetVolume(AudioSystemManager::AudioVolumeType volumeType, int32_t volume) const;
+    int32_t GetVolume(AudioSystemManager::AudioVolumeType volumeType) const;
+    int32_t GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) const;
+    int32_t GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) const;
     int32_t SetMute(AudioSystemManager::AudioVolumeType volumeType, bool mute) const;
     bool IsStreamMute(AudioSystemManager::AudioVolumeType volumeType) const;
     int32_t SetMicrophoneMute(bool isMute) const;
@@ -164,6 +164,11 @@ private:
     AudioSystemManager();
     virtual ~AudioSystemManager();
     void init();
+    float MapVolumeToHDI(int32_t volume) const;
+    int32_t MapVolumeFromHDI(float volume) const;
+    static constexpr int32_t MAX_VOLUME_LEVEL = 15;
+    static constexpr int32_t MIN_VOLUME_LEVEL = 0;
+    static constexpr int32_t CONST_FACTOR = 100;
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/include/audio_manager_base.h b/services/include/audio_manager_base.h
index 2927bae0d9208082668bdc0880db437c00c29eb2..6ff4f1027dcc3d599d15fe1e614afa4f54f66d2a 100644
--- a/services/include/audio_manager_base.h
+++ b/services/include/audio_manager_base.h
@@ -31,14 +31,14 @@ public:
      *
      * @return Returns the max volume.
      */
-    virtual float GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) = 0;
+    virtual int32_t GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) = 0;
 
     /**
      * Obtains min volume.
      *
      * @return Returns the min volume.
      */
-    virtual float GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) = 0;
+    virtual int32_t GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) = 0;
     
     /**
      * Sets Microphone Mute status.
diff --git a/services/include/client/audio_manager_proxy.h b/services/include/client/audio_manager_proxy.h
index 3b82f08d82be4bb23b2cfd3e90dcd401120fd27a..ac19fc4322fbd441ba6c2edb9956e359a7b10ca2 100644
--- a/services/include/client/audio_manager_proxy.h
+++ b/services/include/client/audio_manager_proxy.h
@@ -26,8 +26,8 @@ class AudioManagerProxy : public IRemoteProxy<IStandardAudioService> {
 public:
     explicit AudioManagerProxy(const sptr<IRemoteObject> &impl);
     virtual ~AudioManagerProxy() = default;
-    float GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) override;
-    float GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) override;
+    int32_t GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) override;
+    int32_t GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) override;
     int32_t SetMicrophoneMute(bool isMute) override;
     bool IsMicrophoneMute() override;
     std::vector<sptr<AudioDeviceDescriptor>> GetDevices(AudioDeviceDescriptor::DeviceFlag deviceFlag) override;
diff --git a/services/include/server/audio_server.h b/services/include/server/audio_server.h
index 2909574a0749e29b2b408ce3a40f050fd8daeb12..b9407f66d587bb23288ac684a205f9edb5e10a4c 100644
--- a/services/include/server/audio_server.h
+++ b/services/include/server/audio_server.h
@@ -35,8 +35,8 @@ public:
     void OnDump() override;
     void OnStart() override;
     void OnStop() override;
-    float GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) override;
-    float GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) override;
+    int32_t GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) override;
+    int32_t GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) override;
     int32_t SetMicrophoneMute(bool isMute) override;
     bool IsMicrophoneMute() override;
     std::vector<sptr<AudioDeviceDescriptor>> GetDevices(AudioDeviceDescriptor::DeviceFlag deviceFlag) override;
@@ -44,8 +44,8 @@ public:
     void SetAudioParameter(const std::string key, const std::string value) override;
     const std::string GetAudioParameter(const std::string key) override;
 private:
-    static constexpr float MAX_VOLUME = 1.0;
-    static constexpr float MIN_VOLUME = 0;
+    static constexpr int32_t MAX_VOLUME = 15;
+    static constexpr int32_t MIN_VOLUME = 0;
     static std::unordered_map<int, float> AudioStreamVolumeMap;
     std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptor_;
     static std::map<std::string, std::string> audioParameters;
diff --git a/services/src/client/audio_manager_proxy.cpp b/services/src/client/audio_manager_proxy.cpp
index 81627e9450018339309c5cf095128032b64cb355..56ea189463fe0b38617e08e6a41823c5cc1b10c3 100644
--- a/services/src/client/audio_manager_proxy.cpp
+++ b/services/src/client/audio_manager_proxy.cpp
@@ -24,7 +24,7 @@ AudioManagerProxy::AudioManagerProxy(const sptr<IRemoteObject> &impl)
 {
 }
 
-float AudioManagerProxy::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType)
+int32_t AudioManagerProxy::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType)
 {
     MessageParcel data;
     MessageParcel reply;
@@ -35,11 +35,11 @@ float AudioManagerProxy::GetMaxVolume(AudioSystemManager::AudioVolumeType volume
         MEDIA_ERR_LOG("Get max volume failed, error: %d", error);
         return error;
     }
-    float volume = reply.ReadFloat();
+    int32_t volume = reply.ReadInt32();
     return volume;
 }
 
-float AudioManagerProxy::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType)
+int32_t AudioManagerProxy::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType)
 {
     MessageParcel data;
     MessageParcel reply;
@@ -52,7 +52,7 @@ float AudioManagerProxy::GetMinVolume(AudioSystemManager::AudioVolumeType volume
         return error;
     }
 
-    float volume = reply.ReadFloat();
+    float volume = reply.ReadInt32();
     return volume;
 }
 
diff --git a/services/src/client/audio_system_manager.cpp b/services/src/client/audio_system_manager.cpp
index ffe8bfd4d7032ef07b716d839a9bd087cc1f327f..b2ee6c388db2790d1438966fc819a26467cd89dc 100644
--- a/services/src/client/audio_system_manager.cpp
+++ b/services/src/client/audio_system_manager.cpp
@@ -137,10 +137,10 @@ void AudioSystemManager::SetAudioParameter(const std::string key, const std::str
     g_sProxy->SetAudioParameter(key, value);
 }
 
-int32_t AudioSystemManager::SetVolume(AudioSystemManager::AudioVolumeType volumeType, float volume) const
+int32_t AudioSystemManager::SetVolume(AudioSystemManager::AudioVolumeType volumeType, int32_t volume) const
 {
     /* Validate and return INVALID_PARAMS error */
-    if ((volume < 0) || (volume > 1)) {
+    if ((volume < MIN_VOLUME_LEVEL) || (volume > MAX_VOLUME_LEVEL)) {
         MEDIA_ERR_LOG("Invalid Volume Input!");
         return ERR_INVALID_PARAM;
     }
@@ -156,10 +156,11 @@ int32_t AudioSystemManager::SetVolume(AudioSystemManager::AudioVolumeType volume
 
     /* Call Audio Policy SetStreamVolume */
     AudioStreamType StreamVolType = (AudioStreamType)volumeType;
-    return AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volume);
+    float volumeToHdi = MapVolumeToHDI(volume);
+    return AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volumeToHdi);
 }
 
-float AudioSystemManager::GetVolume(AudioSystemManager::AudioVolumeType volumeType) const
+int32_t AudioSystemManager::GetVolume(AudioSystemManager::AudioVolumeType volumeType) const
 {
     switch (volumeType) {
         case STREAM_MUSIC:
@@ -172,15 +173,31 @@ float AudioSystemManager::GetVolume(AudioSystemManager::AudioVolumeType volumeTy
 
     /* Call Audio Policy SetStreamMute */
     AudioStreamType StreamVolType = (AudioStreamType)volumeType;
-    return AudioPolicyManager::GetInstance().GetStreamVolume(StreamVolType);
+    float volumeFromHdi = AudioPolicyManager::GetInstance().GetStreamVolume(StreamVolType);
+
+    return MapVolumeFromHDI(volumeFromHdi);
+}
+
+float AudioSystemManager::MapVolumeToHDI(int32_t volume) const
+{
+    float value = (float)volume / MAX_VOLUME_LEVEL;
+    float roundValue = (int)(value * CONST_FACTOR);
+
+    return (float)roundValue / CONST_FACTOR;
+}
+
+int32_t AudioSystemManager::MapVolumeFromHDI(float volume) const
+{
+    float value = (float)volume * MAX_VOLUME_LEVEL;
+    return nearbyint(value);
 }
 
-float AudioSystemManager::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) const
+int32_t AudioSystemManager::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType) const
 {
     return g_sProxy->GetMaxVolume(volumeType);
 }
 
-float AudioSystemManager::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) const
+int32_t AudioSystemManager::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType) const
 {
     return g_sProxy->GetMinVolume(volumeType);
 }
diff --git a/services/src/server/audio_manager_stub.cpp b/services/src/server/audio_manager_stub.cpp
index f8a7853f8356b49da96fd2f028a860f21a03101b..8236b896f2eeb9d2725ee9232765645c0dbd8c1c 100644
--- a/services/src/server/audio_manager_stub.cpp
+++ b/services/src/server/audio_manager_stub.cpp
@@ -36,8 +36,8 @@ int AudioManagerStub::OnRemoteRequest(
             AudioSystemManager::AudioVolumeType volumeStreamConfig =
                    static_cast<AudioSystemManager::AudioVolumeType>(volumeType);
             MEDIA_DEBUG_LOG("GET_MAX_VOLUME volumeType= %{public}d", volumeStreamConfig);
-            float ret = GetMaxVolume(volumeStreamConfig);
-            reply.WriteFloat(ret);
+            int32_t ret = GetMaxVolume(volumeStreamConfig);
+            reply.WriteInt32(ret);
             return MEDIA_OK;
         }
         case GET_MIN_VOLUME: {
@@ -47,8 +47,8 @@ int AudioManagerStub::OnRemoteRequest(
             AudioSystemManager::AudioVolumeType volumeStreamConfig =
                    static_cast<AudioSystemManager::AudioVolumeType>(volumeType);
             MEDIA_DEBUG_LOG("GET_MIN_VOLUME volumeType= %{public}d", volumeStreamConfig);
-            float ret = GetMinVolume(volumeStreamConfig);
-            reply.WriteFloat(ret);
+            int32_t ret = GetMinVolume(volumeStreamConfig);
+            reply.WriteInt32(ret);
             return MEDIA_OK;
         }
         case GET_DEVICES: {
diff --git a/services/src/server/audio_server.cpp b/services/src/server/audio_server.cpp
index 7c92f2bc459797e33e81231b82b8dc0374a3af1e..872bc9c00194ad1b3dc0cec964ea38719697293d 100644
--- a/services/src/server/audio_server.cpp
+++ b/services/src/server/audio_server.cpp
@@ -98,13 +98,13 @@ const std::string AudioServer::GetAudioParameter(const std::string key)
     }
 }
 
-float AudioServer::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType)
+int32_t AudioServer::GetMaxVolume(AudioSystemManager::AudioVolumeType volumeType)
 {
     MEDIA_DEBUG_LOG("GetMaxVolume server");
     return MAX_VOLUME;
 }
 
-float AudioServer::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType)
+int32_t AudioServer::GetMinVolume(AudioSystemManager::AudioVolumeType volumeType)
 {
     MEDIA_DEBUG_LOG("GetMinVolume server");
     return MIN_VOLUME;