From b65675615912f41c355523d17cf28c3bf8eadb80 Mon Sep 17 00:00:00 2001
From: Mateusz Piesta <mateusz.piesta@gmail.com>
Date: Tue, 9 Nov 2021 08:43:56 +0100
Subject: [PATCH] [BH-1117] Bell audio service

Added Bell audio service
Added volume scaling.
---
 image/user/db/settings_bell_002.sql           |   4 -
 module-audio/Audio/AudioCommon.hpp            |   7 +-
 module-audio/Audio/AudioMux.cpp               |   9 +-
 .../board/rt1051/bellpx/BellPxAudioCodec.cpp  |   5 +-
 .../rt1051/bellpx/bsp/audio/AW8898driver.cpp  |   4 +-
 .../rt1051/bellpx/bsp/audio/CodecAW8898.cpp   |  41 ++-
 .../rt1051/bellpx/bsp/audio/CodecAW8898.hpp   |  26 --
 products/BellHybrid/BellHybridMain.cpp        |   4 +-
 products/BellHybrid/CMakeLists.txt            |   4 +-
 products/BellHybrid/alarms/CMakeLists.txt     |   2 +-
 .../alarms/include/BellAlarmHandler.hpp       |   1 -
 .../alarms/src/actions/PlayAudioActions.cpp   |  14 +-
 .../alarms/src/actions/PlayAudioActions.hpp   |   3 +-
 .../ApplicationBellBackgroundSounds.cpp       |  19 +-
 .../CMakeLists.txt                            |   2 +-
 .../data/BGSoundsCommon.hpp                   |   1 -
 .../ApplicationBellBackgroundSounds.hpp       |   2 +
 .../presenter/BGSoundsProgressPresenter.cpp   |   5 +-
 .../presenter/BGSoundsProgressPresenter.hpp   |   9 +-
 .../BGSoundsTimerSelectPresenter.hpp          |   3 +-
 .../presenter/BGSoundsVolumePresenter.cpp     |  19 +-
 .../presenter/BGSoundsVolumePresenter.hpp     |  45 +--
 .../widgets/BGSoundsPlayer.cpp                | 114 ++-----
 .../widgets/BGSoundsPlayer.hpp                |  57 ++--
 .../windows/BGSoundsProgressWindow.cpp        |  12 +-
 .../windows/BGSoundsVolumeWindow.cpp          |  49 +--
 .../windows/BGSoundsVolumeWindow.hpp          |  15 +-
 .../ApplicationBellBedtime.cpp                |   2 +-
 .../ApplicationBellMain.cpp                   |   1 -
 .../CMakeLists.txt                            |   1 +
 .../windows/MeditationRunningWindow.cpp       |   7 +-
 .../ApplicationBellPowerNap.cpp               |   1 -
 .../presenter/PowerNapProgressPresenter.cpp   |  14 +-
 .../presenter/PowerNapProgressPresenter.hpp   |   1 -
 .../ApplicationBellSettings.cpp               |  12 +-
 .../application-bell-settings/CMakeLists.txt  |   1 +
 .../alarm_settings/AlarmSettingsModel.cpp     |  13 +-
 .../alarm_settings/AlarmSettingsModel.hpp     |  11 +-
 .../alarm_settings/PrewakeUpSettingsModel.cpp |  13 +-
 .../alarm_settings/PrewakeUpSettingsModel.hpp |  11 +-
 .../alarm_settings/SnoozeSettingsModel.cpp    |  12 +-
 .../alarm_settings/SnoozeSettingsModel.hpp    |  10 +-
 .../presenter/BedtimeSettingsPresenter.cpp    |  26 +-
 .../presenter/BedtimeSettingsPresenter.hpp    |   3 +-
 .../alarm_settings/AlarmSettingsPresenter.cpp |  24 +-
 .../alarm_settings/AlarmSettingsPresenter.hpp |   3 +-
 .../alarm_settings/PrewakeUpPresenter.cpp     |  27 +-
 .../alarm_settings/PrewakeUpPresenter.hpp     |   3 +-
 .../alarm_settings/SnoozePresenter.cpp        |  25 +-
 .../alarm_settings/SnoozePresenter.hpp        |   4 +-
 .../windows/BellSettingsBedtimeToneWindow.cpp |   3 +
 .../BellSettingsAlarmSettingsSnoozeWindow.cpp |   5 +
 .../BellSettingsAlarmSettingsWindow.cpp       |   3 +
 .../BellSettingsPrewakeUpWindow.cpp           |   3 +
 .../BellHybrid/apps/common/CMakeLists.txt     |   1 +
 .../common/models/AbstractAudioModel.hpp      |  33 +-
 .../common/models/AbstractSettingsModel.hpp   |  44 +++
 .../include/common/models/AudioModel.hpp      |  22 +-
 .../include/common/models/BedtimeModel.hpp    |  20 +-
 .../BellHybrid/apps/common/src/AudioModel.cpp | 161 ++++++++-
 .../apps/common/src/models/BedtimeModel.cpp   |  18 +-
 .../src/popups/BedtimeNotificationWindow.cpp  |   6 +-
 products/BellHybrid/services/CMakeLists.txt   |   1 +
 .../BellHybrid/services/audio/CMakeLists.txt  |  33 ++
 .../services/audio/ServiceAudio.cpp           | 307 ++++++++++++++++++
 .../audio/include/audio/AudioMessage.hpp      | 141 ++++++++
 .../audio/include/audio/ServiceAudio.hpp      |  87 +++++
 .../services/db/include/db/SystemSettings.hpp |   4 -
 .../services/evtmgr/WorkerEvent.cpp           |   1 -
 69 files changed, 1119 insertions(+), 475 deletions(-)
 create mode 100644 products/BellHybrid/services/audio/CMakeLists.txt
 create mode 100644 products/BellHybrid/services/audio/ServiceAudio.cpp
 create mode 100644 products/BellHybrid/services/audio/include/audio/AudioMessage.hpp
 create mode 100644 products/BellHybrid/services/audio/include/audio/ServiceAudio.hpp

diff --git a/image/user/db/settings_bell_002.sql b/image/user/db/settings_bell_002.sql
index 0e250a12e22bb77c3ecf0efed79a4186dd11fc26..f411e4594ae5da84e5dcf1d537b1b9a111be50c7 100644
--- a/image/user/db/settings_bell_002.sql
+++ b/image/user/db/settings_bell_002.sql
@@ -35,20 +35,16 @@ INSERT OR IGNORE INTO settings_tab (path, value) VALUES
     ('snooze_length','10'),
     ('snooze_interval','1'),
     ('snooze_tone','Gentle Chime'),
-    ('snooze_volume','5'),
     ('prewake_up_duration', '10'),
     ('prewake_up_tone','Joyful Awakening'),
-    ('prewake_up_volume','5'),
     ('prewake_up_light_duration','10'),
     ('alarm_tone','Gentle Daybreak'),
-    ('alarm_volume','5'),
     ('alarm_light_active','1'),
     ('alarm_duration','10000'),
     ('bedtime_active','0'),
     ('bedtime_time','21:00'),
     ('bedtime_tone','Evening Horizon'),
     ('bedtime_duration','5'),
-    ('bedtime_volume','1'),
     ('\ServiceEink\\display_inverted_mode', '0');
 
 
diff --git a/module-audio/Audio/AudioCommon.hpp b/module-audio/Audio/AudioCommon.hpp
index cf590b3e8d0cf067610191a1d1933c42eb4456ad..26819600553b1304172e981ccb5ecee0be695a86 100644
--- a/module-audio/Audio/AudioCommon.hpp
+++ b/module-audio/Audio/AudioCommon.hpp
@@ -66,7 +66,10 @@ namespace audio
         TextMessageRingtone,
         Meditation,
         Alarm,
-        Last = Alarm,
+        PreWakeUp,
+        Snooze,
+        Bedtime,
+        Last = Bedtime,
     };
 
     /// Used to describe audio operations
@@ -174,7 +177,7 @@ namespace audio
         std::bitset<magic_enum::enum_count<EventType>()> audioSinkState;
     };
 
-    enum class RetCode
+    enum class RetCode : std::uint8_t
     {
         Success = 0,
         InvokedInIncorrectState,
diff --git a/module-audio/Audio/AudioMux.cpp b/module-audio/Audio/AudioMux.cpp
index a65b2f9bf0366bf7c0d25119e1fe44dc9d10e055..b065f2cd100db5d0ffd4a926b4c894f0e41fa13e 100644
--- a/module-audio/Audio/AudioMux.cpp
+++ b/module-audio/Audio/AudioMux.cpp
@@ -163,20 +163,17 @@ namespace audio
     {
         switch (type) {
         case PlaybackType::None:
-            [[fallthrough]];
         case PlaybackType::Notifications:
-            [[fallthrough]];
         case PlaybackType::KeypadSound:
-            [[fallthrough]];
         case PlaybackType::TextMessageRingtone:
             return true;
         case PlaybackType::CallRingtone:
-            [[fallthrough]];
         case PlaybackType::Meditation:
-            [[fallthrough]];
         case PlaybackType::Alarm:
-            [[fallthrough]];
         case PlaybackType::Multimedia:
+        case PlaybackType::Bedtime:
+        case PlaybackType::PreWakeUp:
+        case PlaybackType::Snooze:
             return false;
         }
         return false;
diff --git a/module-audio/board/rt1051/bellpx/BellPxAudioCodec.cpp b/module-audio/board/rt1051/bellpx/BellPxAudioCodec.cpp
index bda9b1583ecbf9293bd7147556fdbfe99c45cf1e..d0b32ff9dea5eccfedb147397a816f8867fc5240 100644
--- a/module-audio/board/rt1051/bellpx/BellPxAudioCodec.cpp
+++ b/module-audio/board/rt1051/bellpx/BellPxAudioCodec.cpp
@@ -3,7 +3,6 @@
 
 #include "BellPxAudioCodec.hpp"
 #include "board.h"
-#include "dma_config.h"
 #include <log/log.hpp>
 
 #include "board/BoardDefinitions.hpp"
@@ -104,7 +103,7 @@ namespace audio
     AudioDevice::RetCode BellPxAudioCodec::setOutputVolume(float vol)
     {
         currentFormat.outputVolume = vol;
-        CodecParams params;
+        CodecParamsAW8898 params;
         params.outVolume = vol;
         params.opCmd     = CodecParams::Cmd::SetOutVolume;
         codec.Ioctrl(params);
@@ -114,7 +113,7 @@ namespace audio
     AudioDevice::RetCode BellPxAudioCodec::setInputGain(float gain)
     {
         currentFormat.inputGain = gain;
-        CodecParams params;
+        CodecParamsAW8898 params;
         params.inGain = gain;
         params.opCmd  = CodecParams::Cmd::SetInGain;
         codec.Ioctrl(params);
diff --git a/module-bsp/board/rt1051/bellpx/bsp/audio/AW8898driver.cpp b/module-bsp/board/rt1051/bellpx/bsp/audio/AW8898driver.cpp
index 4e76564c3315c3edf172c802bf0766bf2e6c8bb4..376b106026f9feaa5c9e9d60e0418fc169192a34 100644
--- a/module-bsp/board/rt1051/bellpx/bsp/audio/AW8898driver.cpp
+++ b/module-bsp/board/rt1051/bellpx/bsp/audio/AW8898driver.cpp
@@ -469,7 +469,7 @@ namespace bsp::audio::AW8898
         return res;
     }
 
-    status_t GetVolume(std::uint8_t *gian)
+    status_t GetVolume(std::uint8_t *gain)
     {
         status_t res      = kStatus_Success;
         std::uint16_t reg = 0;
@@ -480,7 +480,7 @@ namespace bsp::audio::AW8898
             return res;
         }
 
-        *gian = reg >> 8;
+        *gain = reg >> 8;
         return res;
     }
 
diff --git a/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.cpp b/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.cpp
index bdb06e908a72377a24793f6302e122904053ff57..ebd1df9d187ff6a07b7385cb9cc5515521b366b7 100644
--- a/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.cpp
+++ b/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.cpp
@@ -21,10 +21,23 @@ using namespace bsp::audio;
 
 namespace
 {
-    constexpr auto ReadStatusRetries  = 5;
-    constexpr auto OneByteAddressing  = 1;
-    constexpr auto PositiveLogic      = 0;
-    constexpr auto defaultVolumeLevel = 3.0f;
+    constexpr auto ReadStatusRetries = 5;
+    constexpr auto OneByteAddressing = 1;
+    constexpr auto PositiveLogic     = 0;
+    constexpr auto maxInVolume       = 10;
+    constexpr auto minInVolume       = 0;
+
+    /// Higher layers operate using 0-10 range. Here we are transforming it into more usable one.
+    /// Anything above 9 is going to distort the speaker and values below 5 are too quiet.
+    constexpr float transformVolumeLvl(float value)
+    {
+        constexpr auto maxOutVolume = 9;
+        constexpr auto minOutVolume = 5;
+        constexpr auto inputRange   = std::make_pair(minInVolume, maxInVolume);
+        constexpr auto outputRange  = std::make_pair(minOutVolume, maxOutVolume);
+        constexpr float slope = 1.0 * (outputRange.second - outputRange.first) / (inputRange.second - inputRange.first);
+        return outputRange.first + slope * (value - inputRange.first);
+    }
 } // namespace
 
 CodecAW8898::CodecAW8898()
@@ -83,10 +96,7 @@ CodecRetCode CodecAW8898::Start(const CodecParams &param)
     // Store param configuration
     currentParams = params;
 
-    auto currVol = currentParams.outVolume;
-    // remove this once volume control in application is working
-    currVol = defaultVolumeLevel;
-    SetOutputVolume(currVol);
+    SetOutputVolume(currentParams.outVolume);
 
     AW8898::ReadAllReg();
 
@@ -115,10 +125,8 @@ CodecRetCode CodecAW8898::Stop()
 
 CodecRetCode CodecAW8898::Ioctrl(const CodecParams &param)
 {
-
     const CodecParamsAW8898 &params = static_cast<const CodecParamsAW8898 &>(param);
-
-    CodecRetCode ret = CodecRetCode::Success;
+    CodecRetCode ret                = CodecRetCode::Success;
 
     switch (params.opCmd) {
     case CodecParamsAW8898::Cmd::SetOutVolume:
@@ -152,14 +160,13 @@ CodecRetCode CodecAW8898::Ioctrl(const CodecParams &param)
 
 std::uint8_t CodecAW8898::VolumeTo8Bit(const float vol)
 {
-    static constexpr auto maxVolumeLevel  = 10.0f;
-    static constexpr auto conversionRatio = static_cast<float>(UINT8_MAX) / maxVolumeLevel;
+    static constexpr auto conversionRatio = static_cast<float>(UINT8_MAX) / maxInVolume;
 
     if (vol < 0) {
         return 0;
     }
 
-    if (vol > maxVolumeLevel) {
+    if (vol > maxInVolume) {
         return UINT8_MAX;
     }
 
@@ -168,12 +175,10 @@ std::uint8_t CodecAW8898::VolumeTo8Bit(const float vol)
 
 CodecRetCode CodecAW8898::SetOutputVolume(const float vol)
 {
-    uint8_t mute = 0;
-
     // If volume set to 0 then mute output
     AW8898::RunMute(vol == 0); //(PWMCTRL.HMUTE=0) - disable mute
-
-    AW8898::SetVolume(VolumeTo8Bit(vol));
+    // AW8898 has "negative" gain control - higher the absolute value, lower the volume
+    AW8898::SetVolume(UINT8_MAX - VolumeTo8Bit(transformVolumeLvl(vol)));
     currentParams.outVolume = vol;
     return CodecRetCode::Success;
 }
diff --git a/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.hpp b/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.hpp
index 9e5e50ce5b0f63fd711c11362ebae668108cfb9e..2c7fc8d098a16aba6483ed644d8830394f90a929 100644
--- a/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.hpp
+++ b/module-bsp/board/rt1051/bellpx/bsp/audio/CodecAW8898.hpp
@@ -17,29 +17,6 @@ extern "C"
 class CodecParamsAW8898 : public CodecParams
 {
   public:
-    enum class Cmd
-    {
-        SetOutVolume,
-        SetInGain,
-        SetMute,
-        SetOutput,
-        SetInput,
-        Reset,
-        MicBiasCtrl,
-        None
-    };
-
-    enum class SampleRate
-    {
-        Rate8KHz   = 8000,
-        Rate16KHz  = 16000,
-        Rate44K1Hz = 44100,
-        Rate48KHz  = 48000,
-        Rate32KHz  = 32000,
-        Rate96KHz  = 96000,
-        Invalid
-    };
-
     enum class MonoStereo
     {
         Left,
@@ -97,10 +74,7 @@ class CodecParamsAW8898 : public CodecParams
         }
     }
 
-    Cmd opCmd             = Cmd::None;
-    float outVolume       = 0;
     MonoStereo monoStereo = MonoStereo::Mono;
-    SampleRate sampleRate = SampleRate ::Rate44K1Hz;
 };
 
 class CodecAW8898 : public Codec
diff --git a/products/BellHybrid/BellHybridMain.cpp b/products/BellHybrid/BellHybridMain.cpp
index e867e8b1a9eaa515f7b0053424635aa0a00f6a18..ffe8c833cfa6bbc61fd6295ae4d86e72f310d583 100644
--- a/products/BellHybrid/BellHybridMain.cpp
+++ b/products/BellHybrid/BellHybridMain.cpp
@@ -19,11 +19,11 @@
 
 // services
 #include <appmgr/ApplicationManager.hpp>
+#include <audio/ServiceAudio.hpp>
 #include <db/ServiceDB.hpp>
 #include <evtmgr/EventManager.hpp>
 #include <Service/ServiceCreator.hpp>
 #include <service-appmgr/Constants.hpp>
-#include <service-audio/ServiceAudio.hpp>
 #include <service-desktop/ServiceDesktop.hpp>
 #include <service-eink/ServiceEink.hpp>
 #include <service-gui/ServiceGUI.hpp>
@@ -68,7 +68,7 @@ int main()
     std::vector<std::unique_ptr<sys::BaseServiceCreator>> systemServices;
     systemServices.emplace_back(sys::CreatorFor<EventManager>());
     systemServices.emplace_back(sys::CreatorFor<ServiceDB>());
-    systemServices.emplace_back(sys::CreatorFor<ServiceAudio>());
+    systemServices.emplace_back(sys::CreatorFor<service::Audio>());
     systemServices.emplace_back(sys::CreatorFor<ServiceDesktop>());
     systemServices.emplace_back(sys::CreatorFor<stm::ServiceTime>(std::make_shared<alarms::AlarmOperationsFactory>()));
     systemServices.emplace_back(sys::CreatorFor<service::eink::ServiceEink>(service::eink::ExitAction::None));
diff --git a/products/BellHybrid/CMakeLists.txt b/products/BellHybrid/CMakeLists.txt
index fc347b50240215baccbd5087b235633b9021c14f..f4bccb7ad1c90eadab08efda0dc5b24294818bd9 100644
--- a/products/BellHybrid/CMakeLists.txt
+++ b/products/BellHybrid/CMakeLists.txt
@@ -48,12 +48,12 @@ target_link_libraries(BellHybrid
         bell::app-powernap
         bell::app-settings
         bell::db
-        evtmgr
+        bell::audio
+        bell::evtmgr
         log
         messagetype
         module-bsp
         module-vfs
-        service-audio
         service-desktop
         service-time
         sys
diff --git a/products/BellHybrid/alarms/CMakeLists.txt b/products/BellHybrid/alarms/CMakeLists.txt
index 41b542170a955356be2e4c96142eddcc8bfb9f7b..94e41c2573aad065c0cd062012c6b0107462057f 100644
--- a/products/BellHybrid/alarms/CMakeLists.txt
+++ b/products/BellHybrid/alarms/CMakeLists.txt
@@ -33,12 +33,12 @@ target_include_directories(alarms
 
 target_link_libraries(alarms
    PRIVATE
-        module-audio
         module-vfs
         bell::db
         bell::appmgr
         bell::app-common
         bell::evtmgr
+        bell::audio
         apps-common
    PUBLIC
         module-db
diff --git a/products/BellHybrid/alarms/include/BellAlarmHandler.hpp b/products/BellHybrid/alarms/include/BellAlarmHandler.hpp
index 732ac88113034b04694ccb80cee95ca9ed749f9e..2cf6f38bfd67ad101bf67cd03d379062b44aa35d 100644
--- a/products/BellHybrid/alarms/include/BellAlarmHandler.hpp
+++ b/products/BellHybrid/alarms/include/BellAlarmHandler.hpp
@@ -4,7 +4,6 @@
 #pragma once
 
 #include "AbstractAlarmAction.hpp"
-#include <service-audio/AudioServiceAPI.hpp>
 #include <service-time/AlarmHandler.hpp>
 #include <Service/Service.hpp>
 
diff --git a/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp b/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp
index 98c2eb058e4b16663ea3838237a757a6a338cace..117b95ae79fed0f12e2a5be11df084d3e0ef2950 100644
--- a/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp
+++ b/products/BellHybrid/alarms/src/actions/PlayAudioActions.cpp
@@ -4,7 +4,7 @@
 #include "AlarmSoundPaths.hpp"
 #include "PlayAudioActions.hpp"
 
-#include <service-time/ServiceTime.hpp>
+#include <audio/AudioMessage.hpp>
 #include <db/SystemSettings.hpp>
 #include <Timers/TimerFactory.hpp>
 
@@ -24,14 +24,16 @@ namespace alarms
         if (duration != InfiniteDuration) {
             spawnTimer(duration);
         }
-        return AudioServiceAPI::PlaybackStart(&service, playbackType, path);
+        return service.bus.sendUnicast(std::make_shared<service::AudioStartPlaybackRequest>(path, playbackType),
+                                       service::audioServiceName);
     }
 
     bool PlayAudioAction::turnOff()
     {
         detachTimer();
         auto stopPlaybackVec = std::vector<audio::PlaybackType>({playbackType});
-        return AudioServiceAPI::Stop(&service, stopPlaybackVec);
+        const auto msg       = std::make_shared<service::AudioStopRequest>(stopPlaybackVec);
+        return service.bus.sendUnicast(msg, service::audioServiceName);
     }
     bool PlayAudioAction::execute()
     {
@@ -66,7 +68,7 @@ namespace alarms
                                                      paths::getPreWakeUpChimesDir(),
                                                      bell::settings::PrewakeUp::tone,
                                                      bell::settings::PrewakeUp::duration,
-                                                     audio::PlaybackType::Multimedia);
+                                                     audio::PlaybackType::PreWakeUp);
         }
 
         std::unique_ptr<PlayAudioAction> createSnoozeChimeAction(sys::Service &service)
@@ -75,7 +77,7 @@ namespace alarms
                                                      paths::getSnoozeChimesDir(),
                                                      bell::settings::Snooze::tone,
                                                      bell::settings::Snooze::length,
-                                                     audio::PlaybackType::Multimedia);
+                                                     audio::PlaybackType::Snooze);
         }
         std::unique_ptr<PlayAudioAction> createAlarmToneAction(sys::Service &service)
         {
@@ -88,7 +90,7 @@ namespace alarms
                                                      paths::getBedtimeReminderChimesDir(),
                                                      bell::settings::Bedtime::tone,
                                                      bell::settings::Bedtime::duration,
-                                                     audio::PlaybackType::Multimedia);
+                                                     audio::PlaybackType::Bedtime);
         }
     } // namespace factory
 } // namespace alarms
diff --git a/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp b/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp
index 8d81e0427c467ad405627f02ccc87ef5bfba5ab3..b34260dbe5d4b87da8fa607564776a1edd57c490 100644
--- a/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp
+++ b/products/BellHybrid/alarms/src/actions/PlayAudioActions.hpp
@@ -4,9 +4,8 @@
 #pragma once
 
 #include "AbstractAlarmAction.hpp"
+#include <audio/AudioMessage.hpp>
 #include <common/SoundsRepository.hpp>
-#include <service-audio/AudioServiceAPI.hpp>
-#include <module-audio/Audio/AudioCommon.hpp>
 #include <service-db/Settings.hpp>
 #include <Timers/TimerHandle.hpp>
 #include <Service/Service.hpp>
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp b/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
index b3b656c75a405b65d1a3eb2c1d9bcb5d3b33b0dd..56cc8dbbf20572ce52b571642ee5386ca4d625dd 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/ApplicationBellBackgroundSounds.cpp
@@ -15,7 +15,8 @@
 #include "widgets/BGSoundsPlayer.hpp"
 #include <apps-common/messages/AppMessage.hpp>
 #include <common/models/TimeModel.hpp>
-#include <service-audio/AudioMessage.hpp>
+#include <common/models/AudioModel.hpp>
+#include <audio/AudioMessage.hpp>
 
 #include <log/log.hpp>
 namespace app
@@ -26,11 +27,12 @@ namespace app
                                                                      StartInBackground startInBackground,
                                                                      uint32_t stackDepth)
         : Application(std::move(name), std::move(parent), statusIndicators, startInBackground, stackDepth),
-          player{std::make_unique<bgSounds::BGSoundsPlayer>(this)}
+          audioModel{std::make_unique<AudioModel>(this)}, player{
+                                                              std::make_unique<bgSounds::BGSoundsPlayer>(*audioModel)}
     {
         bus.channels.push_back(sys::BusChannel::ServiceAudioNotifications);
-        connect(typeid(AudioEOFNotification), [&](sys::Message *msg) -> sys::MessagePointer {
-            auto notification = static_cast<AudioEOFNotification *>(msg);
+        connect(typeid(service::AudioEOFNotification), [&](sys::Message *msg) -> sys::MessagePointer {
+            auto notification = static_cast<service::AudioEOFNotification *>(msg);
             return player->handle(notification);
         });
     }
@@ -71,10 +73,11 @@ namespace app
             return std::make_unique<gui::BGSoundsPausedWindow>(app);
         });
 
-        windowsFactory.attach(gui::popup::window::volume_window, [](ApplicationCommon *app, const std::string &name) {
-            auto presenter = std::make_unique<bgSounds::BGSoundsVolumePresenter>(*app);
-            return std::make_unique<gui::BGSoundsVolumeWindow>(app, std::move(presenter));
-        });
+        windowsFactory.attach(gui::popup::window::volume_window,
+                              [this](ApplicationCommon *app, const std::string &name) {
+                                  auto presenter = std::make_unique<bgSounds::BGSoundsVolumePresenter>(*audioModel);
+                                  return std::make_unique<gui::BGSoundsVolumeWindow>(app, std::move(presenter));
+                              });
 
         attachPopups({gui::popup::ID::AlarmActivated,
                       gui::popup::ID::AlarmDeactivated,
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt b/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
index 281c587ef5c0f1f928f159cf4a73651bd54c045d..ece94e16e98c705ce95593158f2dfb4711519b68 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
+++ b/products/BellHybrid/apps/application-bell-background-sounds/CMakeLists.txt
@@ -47,8 +47,8 @@ target_sources(application-bell-background-sounds
 
 target_link_libraries(application-bell-background-sounds
     PRIVATE
-        app
         apps-common
+        bell::audio
 
     PUBLIC
         module-gui
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsCommon.hpp b/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsCommon.hpp
index 02b0e23eb6df11003eee908e1e1906ce90ece318..f893f602531a3799ebcc0bf16c61a3327897a274 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsCommon.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/data/BGSoundsCommon.hpp
@@ -6,5 +6,4 @@
 namespace app::bgSounds
 {
     constexpr auto timerValueDBRecordName = "BGSoundsTimerValue";
-    constexpr auto soundsVolumeDBRecordName = "BGSoundsVolume";
 }
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp b/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
index 8ebf113fa3b4c7653fe8cfa5f83a6b10ccdb8701..6062f7cb0ac219c1870bacaaff66bcc13ced6fb2 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/include/application-bell-background-sounds/ApplicationBellBackgroundSounds.hpp
@@ -4,6 +4,7 @@
 #pragma once
 
 #include <Application.hpp>
+#include <common/models/AbstractAudioModel.hpp>
 
 namespace gui::window::name
 {
@@ -21,6 +22,7 @@ namespace app
 
     class ApplicationBellBackgroundSounds : public Application
     {
+        std::unique_ptr<AbstractAudioModel> audioModel;
         std::unique_ptr<bgSounds::BGSoundsPlayer> player;
 
         sys::MessagePointer handleSwitchWindow(sys::Message *msgl) override;
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
index 0de7584e3b1e2f31f1eed10ec24f0f043082387a..0f31a0be801795e5c174ea9f7ca0420d207e93bc 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.cpp
@@ -20,7 +20,6 @@ namespace app::bgSounds
                                                          std::unique_ptr<AbstractTimeModel> timeModel)
         : settings{settings}, player{player}, timeModel{std::move(timeModel)}
     {}
-    BGSoundsProgressPresenter::~BGSoundsProgressPresenter() = default;
 
     void BGSoundsProgressPresenter::setTimer(std::unique_ptr<app::TimerWithCallbacks> &&_timer)
     {
@@ -89,4 +88,8 @@ namespace app::bgSounds
     {
         getView()->setTime(timeModel->getCurrentTime());
     }
+    bool BGSoundsProgressPresenter::isPaused()
+    {
+        return player.isPaused();
+    }
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
index 714232cb183fc81a7d0c5e77a27c1b3bb6db0cf9..565bd752d0beced5508ee50ee75d192e14ed4d2e 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsProgressPresenter.hpp
@@ -30,9 +30,9 @@ namespace app::bgSounds
         class View
         {
           public:
-            ~View()                   = default;
-            virtual void onFinished() = 0;
-            virtual void onPaused()   = 0;
+            virtual ~View()                                                 = default;
+            virtual void onFinished()                                       = 0;
+            virtual void onPaused()                                         = 0;
             virtual void setTime(std::time_t newTime)                       = 0;
             virtual void setTimeFormat(utils::time::Locale::TimeFormat fmt) = 0;
         };
@@ -46,6 +46,7 @@ namespace app::bgSounds
             virtual void resume()                                                   = 0;
             virtual void setTimer(std::unique_ptr<app::TimerWithCallbacks> &&timer) = 0;
             virtual void handleUpdateTimeEvent()                                    = 0;
+            virtual bool isPaused()                                                 = 0;
         };
     };
 
@@ -64,6 +65,7 @@ namespace app::bgSounds
         void resume() override;
         void setTimer(std::unique_ptr<app::TimerWithCallbacks> &&_timer) override;
         void handleUpdateTimeEvent() override;
+        bool isPaused() override;
 
         void onFinished();
 
@@ -71,6 +73,5 @@ namespace app::bgSounds
         BGSoundsProgressPresenter(settings::Settings *settings,
                                   AbstractBGSoundsPlayer &player,
                                   std::unique_ptr<AbstractTimeModel> timeModel);
-        ~BGSoundsProgressPresenter();
     };
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsTimerSelectPresenter.hpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsTimerSelectPresenter.hpp
index ee154efa617115856f4279f27e8aaa417e54dc57..88fcc3912b1721deb47e16c9dd9c96543cbbf8b3 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsTimerSelectPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsTimerSelectPresenter.hpp
@@ -30,12 +30,13 @@ namespace app::bgSounds
         class View
         {
           public:
-            ~View() = default;
+            virtual ~View() = default;
         };
 
         class Presenter : public BasePresenter<BGSoundsTimerSelectContract::View>
         {
           public:
+            virtual ~Presenter()                                      = default;
             virtual const Range &getTimerValuesRange() const noexcept = 0;
             virtual std::chrono::minutes getCurrentTimerValue() const = 0;
             virtual void setTimerValue(std::chrono::minutes)          = 0;
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.cpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.cpp
index 59e28804f271bb7669c189a87f595d489e1217ac..fb286bd35d6609f7753c1cc69c223012a7a6d971 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.cpp
@@ -2,11 +2,10 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "BGSoundsVolumePresenter.hpp"
-#include <Application.hpp>
 
 namespace app::bgSounds
 {
-    BGSoundsVolumePresenter::BGSoundsVolumePresenter(app::ApplicationCommon &app) : app{app}
+    BGSoundsVolumePresenter::BGSoundsVolumePresenter(AbstractAudioModel &audioModel) : audioModel{audioModel}
     {}
 
     VolumeData BGSoundsVolumePresenter::getVolumeData()
@@ -14,20 +13,12 @@ namespace app::bgSounds
         return volumeData;
     }
 
-    audio::Volume BGSoundsVolumePresenter::getDefaultVolume()
+    void BGSoundsVolumePresenter::setVolume(AbstractAudioModel::Volume volume)
     {
-        return audio::defaultVolume;
+        audioModel.setVolume(volume, AbstractAudioModel::PlaybackType::Multimedia, {});
     }
-
-    void BGSoundsVolumePresenter::increaseVolume()
-    {
-        app.increaseCurrentVolume();
-    }
-
-    void BGSoundsVolumePresenter::decreaseVolume()
+    AbstractAudioModel::Volume BGSoundsVolumePresenter::getVolume()
     {
-        if (getView()->getCurrentVolume() != minVolume) {
-            app.decreaseCurrentVolume();
-        }
+        return audioModel.getVolume(AbstractAudioModel::PlaybackType::Multimedia).value_or(defaultVolume);
     }
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.hpp b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.hpp
index e22864d6c23546f7c065d36645a14ae47aba2eb2..d7d3a085f1c575235a0fc5152137e50a838859f2 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/presenter/BGSoundsVolumePresenter.hpp
@@ -3,8 +3,7 @@
 
 #pragma once
 
-#include <apps-common/BasePresenter.hpp>
-#include <module-audio/Audio/AudioCommon.hpp>
+#include <common/models/AbstractAudioModel.hpp>
 
 namespace app
 {
@@ -12,47 +11,37 @@ namespace app
 }
 namespace app::bgSounds
 {
-    constexpr audio::Volume minVolume = 1u;
     using VolumeData = struct VolumeData
     {
-        audio::Volume min;
-        audio::Volume max;
-        audio::Volume step;
+        AbstractAudioModel::Volume min;
+        AbstractAudioModel::Volume max;
+        AbstractAudioModel::Volume step;
     };
 
-    class BGSoundsVolumeContract
+    class AbstractBGSoundsVolumePresenter
     {
       public:
-        class View
-        {
-          public:
-            virtual ~View() = default;
-            virtual audio::Volume getCurrentVolume() const noexcept = 0;
-        };
-        class Presenter : public BasePresenter<BGSoundsVolumeContract::View>
-        {
-          public:
-            virtual VolumeData getVolumeData()       = 0;
-            virtual audio::Volume getDefaultVolume() = 0;
-            virtual void increaseVolume()            = 0;
-            virtual void decreaseVolume()            = 0;
-        };
+        virtual ~AbstractBGSoundsVolumePresenter()                = default;
+        virtual VolumeData getVolumeData()                        = 0;
+        virtual void setVolume(AbstractAudioModel::Volume volume) = 0;
+        virtual AbstractAudioModel::Volume getVolume()            = 0;
     };
 
-    class BGSoundsVolumePresenter : public BGSoundsVolumeContract::Presenter
+    class BGSoundsVolumePresenter : public AbstractBGSoundsVolumePresenter
     {
-        app::ApplicationCommon &app;
         constexpr static struct VolumeData volumeData
         {
-            bgSounds::minVolume, audio::maxVolume, audio::defaultVolumeStep
+            AbstractAudioModel::minVolume, AbstractAudioModel::maxVolume, 1
         };
+        static constexpr AbstractAudioModel::Volume defaultVolume = 5;
+
+        AbstractAudioModel &audioModel;
 
         VolumeData getVolumeData() override;
-        audio::Volume getDefaultVolume() override;
-        void increaseVolume() override;
-        void decreaseVolume() override;
+        void setVolume(AbstractAudioModel::Volume volume) override;
+        AbstractAudioModel::Volume getVolume() override;
 
       public:
-        explicit BGSoundsVolumePresenter(app::ApplicationCommon &app);
+        explicit BGSoundsVolumePresenter(AbstractAudioModel &audioModel);
     };
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.cpp b/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.cpp
index 224c708797d7195c7ab2549826ae5a809f4181e6..dde46ef59f6d1bc5fee84a5c4e0a0abad4beba42 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.cpp
@@ -2,104 +2,48 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "BGSoundsPlayer.hpp"
-#include <service-audio/AudioMessage.hpp>
-#include <service-audio/AudioServiceName.hpp>
+#include <audio/AudioMessage.hpp>
 
 namespace app::bgSounds
 {
-    BGSoundsPlayer::BGSoundsPlayer(app::ApplicationCommon *app) : app::AsyncCallbackReceiver{app}, app{app}
-    {}
-    void BGSoundsPlayer::start(const std::string &filePath, PlaybackMode mode, OnStateChangeCallback callback)
+    auto BGSoundsPlayer::handle(service::AudioEOFNotification *msg) -> std::shared_ptr<sys::Message>
     {
-        auto msg  = std::make_unique<AudioStartPlaybackRequest>(filePath, audio::PlaybackType::Multimedia);
-        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-        auto cb   = [this, _callback = std::move(callback), filePath, mode](auto response) {
-            auto result = dynamic_cast<AudioStartPlaybackResponse *>(response);
-            if (result == nullptr) {
-                return false;
-            }
-            token          = result->token;
-            recentFilePath = std::move(filePath);
-            playbackMode   = mode;
-            if (_callback) {
-                _callback(result->retCode);
-            }
-            return true;
-        };
-        task->execute(app, this, std::move(cb));
+        if (playbackMode == PlaybackMode::Looped) {
+            audioModel.play(recentFilePath, AbstractAudioModel::PlaybackType::Multimedia, {});
+        }
+        return sys::msgHandled();
     }
-    void BGSoundsPlayer::stop(OnStateChangeCallback callback)
+    AbstractBGSoundsPlayer::PlaybackMode BGSoundsPlayer::getCurrentMode() const noexcept
     {
-        if (token.IsValid()) {
-            auto msg  = std::make_unique<AudioStopRequest>(token);
-            auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-            auto cb   = [_callback = std::move(callback)](auto response) {
-                auto result = dynamic_cast<AudioStopResponse *>(response);
-                if (result == nullptr) {
-                    return false;
-                }
-                if (_callback) {
-                    _callback(result->retCode);
-                }
-                return true;
-            };
-            task->execute(app, this, std::move(cb));
-        }
+        return playbackMode;
     }
-    void BGSoundsPlayer::pause(OnStateChangeCallback callback)
+    BGSoundsPlayer::BGSoundsPlayer(AbstractAudioModel &audioModel) : audioModel{audioModel}
+    {}
+    void BGSoundsPlayer::start(const std::string &filePath,
+                               AbstractBGSoundsPlayer::PlaybackMode mode,
+                               AbstractAudioModel::OnStateChangeCallback &&callback)
     {
-        if (token.IsValid()) {
-            auto msg  = std::make_unique<AudioPauseRequest>(token);
-            auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-            auto cb   = [_callback = std::move(callback)](auto response) {
-                auto result = dynamic_cast<AudioPauseResponse *>(response);
-                if (result == nullptr) {
-                    return false;
-                }
-                if (_callback) {
-                    _callback(result->retCode);
-                }
-                return true;
-            };
-            task->execute(app, this, std::move(cb));
-        }
+        recentFilePath = filePath;
+        playbackMode   = mode;
+        audioModel.play(filePath, AbstractAudioModel::PlaybackType::Multimedia, std::move(callback));
     }
-    void BGSoundsPlayer::resume(OnStateChangeCallback callback)
+    void BGSoundsPlayer::stop(AbstractAudioModel::OnStateChangeCallback &&callback)
     {
-        auto msg  = std::make_unique<AudioResumeRequest>(token);
-        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-        auto cb   = [_callback = std::move(callback)](auto response) {
-            auto result = dynamic_cast<AudioResumeResponse *>(response);
-            if (result == nullptr) {
-                return false;
-            }
-            if (_callback) {
-                _callback(result->retCode);
-            }
-            return true;
-        };
-        task->execute(app, this, std::move(cb));
+        paused = false;
+        audioModel.stop(std::move(callback));
     }
-
-    auto BGSoundsPlayer::handle(AudioEOFNotification *msg) -> std::shared_ptr<sys::Message>
+    void BGSoundsPlayer::pause(AbstractAudioModel::OnStateChangeCallback &&callback)
     {
-        if (token == msg->token && playbackMode == PlaybackMode::Looped) {
-            auto msg  = std::make_unique<AudioStartPlaybackRequest>(recentFilePath, audio::PlaybackType::Multimedia);
-            auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
-            auto cb   = [this](auto response) {
-                auto result = dynamic_cast<AudioStartPlaybackResponse *>(response);
-                if (result == nullptr) {
-                    return false;
-                }
-                token = result->token;
-                return true;
-            };
-            task->execute(app, this, std::move(cb));
-        }
-        return sys::msgHandled();
+        paused = true;
+        audioModel.pause(std::move(callback));
     }
-    AbstractBGSoundsPlayer::PlaybackMode BGSoundsPlayer::getCurrentMode() const noexcept
+    void BGSoundsPlayer::resume(AbstractAudioModel::OnStateChangeCallback &&callback)
     {
-        return playbackMode;
+        paused = false;
+        audioModel.resume(std::move(callback));
+    }
+    bool BGSoundsPlayer::isPaused()
+    {
+        return paused;
     }
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.hpp b/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.hpp
index c97e362c64c18d09e807c5ba3cce8b5bdbbf52d8..317e349139d96b38766a80f724fdd574bb469483 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/widgets/BGSoundsPlayer.hpp
@@ -2,14 +2,18 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once
-#include <module-audio/Audio/AudioCommon.hpp>
-#include <AsyncTask.hpp>
+
+#include <common/models/AbstractAudioModel.hpp>
 
 namespace app
 {
     class ApplicationCommon;
 }
-class AudioEOFNotification;
+namespace service
+{
+    class AudioEOFNotification;
+}
+
 namespace app::bgSounds
 {
     class AbstractBGSoundsPlayer
@@ -21,32 +25,37 @@ namespace app::bgSounds
             SingleShot
         };
 
-        virtual ~AbstractBGSoundsPlayer() = default;
-
-        using OnStateChangeCallback = std::function<void(audio::RetCode retCode)>;
-        virtual void start(const std::string &filePath, PlaybackMode mode, OnStateChangeCallback callback) = 0;
-        virtual void stop(OnStateChangeCallback callback)                                                  = 0;
-        virtual void pause(OnStateChangeCallback callback)                                                 = 0;
-        virtual void resume(OnStateChangeCallback callback)                                                = 0;
-        virtual PlaybackMode getCurrentMode() const noexcept                                               = 0;
+        virtual ~AbstractBGSoundsPlayer()                                         = default;
+        virtual void start(const std::string &filePath,
+                           PlaybackMode mode,
+                           AbstractAudioModel::OnStateChangeCallback &&callback)  = 0;
+        virtual void stop(AbstractAudioModel::OnStateChangeCallback &&callback)   = 0;
+        virtual void pause(AbstractAudioModel::OnStateChangeCallback &&callback)  = 0;
+        virtual void resume(AbstractAudioModel::OnStateChangeCallback &&callback) = 0;
+        virtual PlaybackMode getCurrentMode() const noexcept                      = 0;
+        virtual bool isPaused()                                                   = 0;
     };
 
-    class BGSoundsPlayer : public AbstractBGSoundsPlayer, public app::AsyncCallbackReceiver
+    class BGSoundsPlayer : public AbstractBGSoundsPlayer
     {
-        app::ApplicationCommon *app{};
-        audio::Token token;
-        std::string recentFilePath;
-        PlaybackMode playbackMode = PlaybackMode::SingleShot;
+      public:
+        explicit BGSoundsPlayer(AbstractAudioModel &audioModel);
 
-        void start(const std::string &filePath, PlaybackMode mode, OnStateChangeCallback callback) override;
-        void stop(OnStateChangeCallback callback) override;
-        void pause(OnStateChangeCallback callback) override;
-        void resume(OnStateChangeCallback callback) override;
-        PlaybackMode getCurrentMode() const noexcept override;
+        auto handle(service::AudioEOFNotification *msg) -> std::shared_ptr<sys::Message>;
 
-      public:
-        explicit BGSoundsPlayer(app::ApplicationCommon *app);
+      private:
+        void start(const std::string &filePath,
+                   PlaybackMode mode,
+                   AbstractAudioModel::OnStateChangeCallback &&callback) override;
+        void stop(AbstractAudioModel::OnStateChangeCallback &&callback) override;
+        void pause(AbstractAudioModel::OnStateChangeCallback &&callback) override;
+        void resume(AbstractAudioModel::OnStateChangeCallback &&callback) override;
+        PlaybackMode getCurrentMode() const noexcept override;
+        bool isPaused() override;
 
-        auto handle(AudioEOFNotification *msg) -> std::shared_ptr<sys::Message>;
+        AbstractAudioModel &audioModel;
+        std::string recentFilePath;
+        PlaybackMode playbackMode = PlaybackMode::SingleShot;
+        bool paused{false};
     };
 } // namespace app::bgSounds
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
index 2b79e10f3b28b4e405890d28477610453a7c84af..c900e4dde28f3f60439cb82efc652bf4d11a6a0b 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsProgressWindow.cpp
@@ -12,7 +12,7 @@
 #include <time/dateCommon.hpp>
 namespace
 {
-    inline constexpr auto bgSoundsTimerName     = "BGSoundsProgressTimer";
+    inline constexpr auto bgSoundsTimerName = "BGSoundsProgressTimer";
     inline constexpr std::chrono::seconds timerTick{1};
 
     void decorateProgressItem(gui::Rect *item, gui::Alignment::Vertical alignment)
@@ -75,7 +75,7 @@ namespace gui
 
     void BGSoundsProgressWindow::onBeforeShow(ShowMode mode, SwitchData *data)
     {
-        if (mode == ShowMode::GUI_SHOW_RETURN) {
+        if (mode == ShowMode::GUI_SHOW_RETURN && presenter->isPaused()) {
             presenter->resume();
             return;
         }
@@ -133,12 +133,8 @@ namespace gui
                 presenter->pause();
                 return true;
             }
-            else if (inputEvent.is(KeyCode::KEY_DOWN)) {
-                application->decreaseCurrentVolume();
-                return true;
-            }
-            else if (inputEvent.is(KeyCode::KEY_UP)) {
-                application->increaseCurrentVolume();
+            else if (inputEvent.is(KeyCode::KEY_DOWN) || inputEvent.is(KeyCode::KEY_UP)) {
+                application->switchWindow(gui::popup::window::volume_window);
                 return true;
             }
         }
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.cpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.cpp
index dc3918460b8ef3ea580dbb11c14e46be107f1f4e..13e429dd2258d5cd24ee28484832f9a93a292985 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.cpp
@@ -10,11 +10,10 @@
 namespace gui
 {
     BGSoundsVolumeWindow::BGSoundsVolumeWindow(
-        app::ApplicationCommon *app, std::unique_ptr<app::bgSounds::BGSoundsVolumeContract::Presenter> &&presenter)
+        app::ApplicationCommon *app, std::unique_ptr<app::bgSounds::AbstractBGSoundsVolumePresenter> &&presenter)
         : WindowWithTimer(app, gui::popup::window::volume_window), presenter{std::move(presenter)}
     {
         buildInterface();
-        this->presenter->attach(this);
     }
 
     void BGSoundsVolumeWindow::buildInterface()
@@ -45,47 +44,23 @@ namespace gui
         spinner->setFont(bgSoundsStyle::valumeValueFont);
         spinner->setAlignment(Alignment(Alignment::Horizontal::Center, Alignment::Vertical::Center));
         spinner->setFocusEdges(RectangleEdge::None);
-        spinner->setCurrentValue(static_cast<UIntegerSpinner::Type>(presenter->getDefaultVolume()));
+        spinner->setCurrentValue(static_cast<UIntegerSpinner::Type>(presenter->getVolume()));
         body->getCenterBox()->addWidget(spinner);
 
-        setFocusItem(spinner);
+        spinner->onValueChanged = [this](const auto &value) { presenter->setVolume(value); };
+        body->setMinMaxArrowsVisibility(spinner->getCurrentValue() == data.min, spinner->getCurrentValue() == data.max);
+
+        setFocusItem(body);
         body->resize();
     }
 
-    bool BGSoundsVolumeWindow::onInput(const gui::InputEvent &inputEvent)
+    bool BGSoundsVolumeWindow::onInput(const InputEvent &inputEvent)
     {
         resetTimer();
-
-        if (inputEvent.isShortRelease(KeyCode::KEY_DOWN)) {
-            presenter->decreaseVolume();
-            return true;
-        }
-        else if (inputEvent.isShortRelease(KeyCode::KEY_UP)) {
-            presenter->increaseVolume();
-            return true;
-        }
-        return WindowWithTimer::onInput(inputEvent);
-    }
-
-    void BGSoundsVolumeWindow::onBeforeShow(ShowMode mode, SwitchData *data)
-    {
-        WindowWithTimer::onBeforeShow(mode, data);
-        const auto popupData = dynamic_cast<VolumePopupData *>(data);
-        if (popupData) {
-            volume       = popupData->getVolume();
-            audioContext = popupData->getAudioContext();
-            spinner->setCurrentValue(static_cast<UIntegerSpinner::Type>(volume));
-            auto currentVolume = spinner->getCurrentValue();
-
-            auto isMax = currentVolume == presenter->getVolumeData().max;
-            auto isMin = currentVolume == presenter->getVolumeData().min;
-            body->setArrowVisible(BellBaseLayout::Arrow::Left, not isMin);
-            body->setArrowVisible(BellBaseLayout::Arrow::Right, not isMax);
-        }
-    }
-
-    audio::Volume BGSoundsVolumeWindow::getCurrentVolume() const noexcept
-    {
-        return spinner->getCurrentValue();
+        auto data              = presenter->getVolumeData();
+        const auto ret         = body->onInput(inputEvent);
+        const auto selectedVal = spinner->getCurrentValue();
+        body->setMinMaxArrowsVisibility(selectedVal == data.min, selectedVal == data.max);
+        return ret;
     }
 } // namespace gui
diff --git a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.hpp b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.hpp
index 9a8debbba089d6e5952115769dab0ddf75bf6d62..fad045f8f53b785cfddae5e5404e2a6c536b1280 100644
--- a/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.hpp
+++ b/products/BellHybrid/apps/application-bell-background-sounds/windows/BGSoundsVolumeWindow.hpp
@@ -7,29 +7,22 @@
 
 #include <apps-common/popups/WindowWithTimer.hpp>
 #include <apps-common/widgets/spinners/Spinners.hpp>
+#include <common/models/AbstractAudioModel.hpp>
 
-#include <module-audio/Audio/AudioCommon.hpp>
-#include <module-audio/Audio/Profiles/Profile.hpp>
 namespace gui
 {
     class BellBaseLayout;
-    class BGSoundsVolumeWindow : public WindowWithTimer, public app::bgSounds::BGSoundsVolumeContract::View
+    class BGSoundsVolumeWindow : public WindowWithTimer
     {
-        std::unique_ptr<app::bgSounds::BGSoundsVolumeContract::Presenter> presenter;
-        audio::Volume volume = 1;
-        audio::Context audioContext;
-
+        std::unique_ptr<app::bgSounds::AbstractBGSoundsVolumePresenter> presenter;
         BellBaseLayout *body{};
         UIntegerSpinner *spinner = nullptr;
 
         void buildInterface() override;
         bool onInput(const gui::InputEvent &inputEvent) override;
-        void onBeforeShow(ShowMode mode, SwitchData *data);
-
-        audio::Volume getCurrentVolume() const noexcept override;
 
       public:
         BGSoundsVolumeWindow(app::ApplicationCommon *app,
-                             std::unique_ptr<app::bgSounds::BGSoundsVolumeContract::Presenter> &&windowPresenter);
+                             std::unique_ptr<app::bgSounds::AbstractBGSoundsVolumePresenter> &&windowPresenter);
     };
 } // namespace gui
diff --git a/products/BellHybrid/apps/application-bell-bedtime/ApplicationBellBedtime.cpp b/products/BellHybrid/apps/application-bell-bedtime/ApplicationBellBedtime.cpp
index 1d0082e4138ec64195ddb59842484c93a7ed09c7..3bcc3c3f591a7e6adb35c4fcd77ddece1d5c1834 100644
--- a/products/BellHybrid/apps/application-bell-bedtime/ApplicationBellBedtime.cpp
+++ b/products/BellHybrid/apps/application-bell-bedtime/ApplicationBellBedtime.cpp
@@ -32,7 +32,7 @@ namespace app
 
     void ApplicationBellBedtime::createUserInterface()
     {
-        windowsFactory.attach(gui::name::window::main_window, [this](ApplicationCommon *app, const std::string &) {
+        windowsFactory.attach(gui::name::window::main_window, [](ApplicationCommon *app, const std::string &) {
             auto bedtimeModel = std::make_unique<bell_bedtime::BedtimeModel>(app);
             auto provider     = std::make_shared<bell_bedtime::BedtimeListItemProvider>(std::move(bedtimeModel));
             auto presenter    = std::make_unique<bell_bedtime::BellBedtimeWindowPresenter>(provider);
diff --git a/products/BellHybrid/apps/application-bell-main/ApplicationBellMain.cpp b/products/BellHybrid/apps/application-bell-main/ApplicationBellMain.cpp
index 9b338cabd6ff63f802683cb02a061a0af774c564..c5299f234ec5667773b1db0d5638a8a684a5cffe 100644
--- a/products/BellHybrid/apps/application-bell-main/ApplicationBellMain.cpp
+++ b/products/BellHybrid/apps/application-bell-main/ApplicationBellMain.cpp
@@ -19,7 +19,6 @@
 #include <common/windows/BellFactoryReset.hpp>
 #include <service-db/DBNotificationMessage.hpp>
 #include <windows/Dialog.hpp>
-#include <service-audio/AudioMessage.hpp>
 #include <common/popups/BedtimeNotificationWindow.hpp>
 
 namespace app
diff --git a/products/BellHybrid/apps/application-bell-meditation-timer/CMakeLists.txt b/products/BellHybrid/apps/application-bell-meditation-timer/CMakeLists.txt
index e19453f645cbe463f5cdede5dd3256b16386b495..47442cd0e70424dee4f417725477c1c3d80dfbfc 100644
--- a/products/BellHybrid/apps/application-bell-meditation-timer/CMakeLists.txt
+++ b/products/BellHybrid/apps/application-bell-meditation-timer/CMakeLists.txt
@@ -37,6 +37,7 @@ target_sources(application-bell-meditation-timer
 target_link_libraries(application-bell-meditation-timer
     PRIVATE
         app
+        bell::audio
         bell::app-common
         bell::app-main
         bellgui
diff --git a/products/BellHybrid/apps/application-bell-meditation-timer/windows/MeditationRunningWindow.cpp b/products/BellHybrid/apps/application-bell-meditation-timer/windows/MeditationRunningWindow.cpp
index 3bb863ffbc22de1705aeb524f23a448a0c122d79..eb97b1684272f0bb6a5317d42f67c8bf806b0a84 100644
--- a/products/BellHybrid/apps/application-bell-meditation-timer/windows/MeditationRunningWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-meditation-timer/windows/MeditationRunningWindow.cpp
@@ -5,10 +5,10 @@
 #include "MeditationRunningWindow.hpp"
 #include "MeditationStyle.hpp"
 
+#include <audio/AudioMessage.hpp>
 #include <apps-common/widgets/BellBaseLayout.hpp>
 #include <apps-common/widgets/ProgressTimerWithBarGraphAndCounter.hpp>
 #include <purefs/filesystem_paths.hpp>
-#include <service-audio/AudioServiceAPI.hpp>
 
 namespace
 {
@@ -182,7 +182,8 @@ namespace gui
 
     void MeditationRunningWindow::playGong()
     {
-        AudioServiceAPI::PlaybackStart(
-            application, audio::PlaybackType::Meditation, purefs::dir::getCurrentOSPath() / meditationAudioPath);
+        auto msg = std::make_shared<service::AudioStartPlaybackRequest>(
+            purefs::dir::getCurrentOSPath() / meditationAudioPath, audio::PlaybackType::Meditation);
+        application->bus.sendUnicast(std::move(msg), service::audioServiceName);
     }
 } // namespace gui
diff --git a/products/BellHybrid/apps/application-bell-powernap/ApplicationBellPowerNap.cpp b/products/BellHybrid/apps/application-bell-powernap/ApplicationBellPowerNap.cpp
index 82101d1572df1c09f8a18f6412999ce47b4dcebc..7560fc528fb4012cf1df68316dbdc0523c4ecc28 100644
--- a/products/BellHybrid/apps/application-bell-powernap/ApplicationBellPowerNap.cpp
+++ b/products/BellHybrid/apps/application-bell-powernap/ApplicationBellPowerNap.cpp
@@ -10,7 +10,6 @@
 #include "windows/PowerNapSessionEndedWindow.hpp"
 #include <common/models/TimeModel.hpp>
 #include <AlarmSoundPaths.hpp>
-#include <service-audio/AudioMessage.hpp>
 
 namespace app
 {
diff --git a/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.cpp b/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.cpp
index baca4f80c8c8d87905a47ed473ffb8fb811c1c20..7a92c98b144eb1f567ae201035ecc63a3ef0092a 100644
--- a/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.cpp
@@ -59,22 +59,14 @@ namespace app::powernap
     {
         const auto filePath = soundsRepository->titleToPath(
             settings->getValue(bell::settings::Alarm::tone, settings::SettingsScope::Global));
-        auto playResponseCb = [this](audio::RetCode retCode, audio::Token token) {
-            if (retCode != audio::RetCode::Success || !token.IsValid()) {
-                LOG_ERROR("Audio preview callback failed with retcode = %s. Token validity: %d",
-                          str(retCode).c_str(),
-                          token.IsValid());
-                return;
-            }
-            this->currentToken = token;
-        };
-        audioModel->play(filePath.value_or(""), playResponseCb, AbstractAudioModel::PlaybackType::Alarm);
+
+        audioModel->play(filePath.value_or(""), AbstractAudioModel::PlaybackType::Alarm, {});
         napAlarmTimer.start();
         napFinished = true;
     }
     void PowerNapProgressPresenter::onNapAlarmFinished()
     {
-        audioModel->stop(currentToken, nullptr);
+        audioModel->stop({});
         getView()->napEnded();
     }
 
diff --git a/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.hpp b/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.hpp
index 86db7414c97e7dd64a3c50a1793b9d151105573e..c8ae5bd7c82c79a59de59e9dd342b027e6e77978 100644
--- a/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-powernap/presenter/PowerNapProgressPresenter.hpp
@@ -58,7 +58,6 @@ namespace app::powernap
         std::unique_ptr<app::TimerWithCallbacks> timer;
         std::unique_ptr<AbstractTimeModel> timeModel;
         sys::TimerHandle napAlarmTimer;
-        audio::Token currentToken;
         bool napFinished{false};
 
         void activate() override;
diff --git a/products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp b/products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp
index 39da3725f89c36828f098d27b41d4373203558b1..7a1d21035e326e1f7f7e2471fbc719ad2b3c3584 100644
--- a/products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/ApplicationBellSettings.cpp
@@ -144,16 +144,16 @@ namespace app
 
         windowsFactory.attach(
             gui::BellSettingsPrewakeUpWindow::name, [this](ApplicationCommon *app, const std::string &name) {
+                auto audioModel         = std::make_unique<AudioModel>(this);
                 auto chimeDurationModel = std::make_unique<bell_settings::PrewakeUpChimeDurationModel>(this);
                 auto chimeToneModel     = std::make_unique<bell_settings::PrewakeUpChimeToneModel>(this);
-                auto chimeVolumeModel   = std::make_unique<bell_settings::PrewakeUpChimeVolumeModel>(this);
+                auto chimeVolumeModel   = std::make_unique<bell_settings::PrewakeUpChimeVolumeModel>(*audioModel);
                 auto lightDurationModel = std::make_unique<bell_settings::PrewakeUpLightDurationModel>(this);
                 auto prewakeUpSettingsModel =
                     std::make_unique<bell_settings::PrewakeUpSettingsModel>(std::move(chimeDurationModel),
                                                                             std::move(chimeToneModel),
                                                                             std::move(chimeVolumeModel),
                                                                             std::move(lightDurationModel));
-                auto audioModel       = std::make_unique<AudioModel>(this);
                 auto soundsRepository = std::make_unique<SoundsRepository>(alarms::paths::getPreWakeUpChimesDir());
                 auto provider         = std::make_shared<bell_settings::PrewakeUpListItemProvider>(
                     *prewakeUpSettingsModel, soundsRepository->getSongTitles());
@@ -169,18 +169,18 @@ namespace app
                               });
         windowsFactory.attach(
             gui::BellSettingsAlarmSettingsSnoozeWindow::name, [this](ApplicationCommon *app, const std::string &) {
+                auto audioModel               = std::make_unique<AudioModel>(this);
                 auto snoozeOnOffModel         = std::make_unique<bell_settings::SnoozeOnOffModel>(this);
                 auto snoozeLengthModel        = std::make_unique<bell_settings::SnoozeLengthModel>(this);
                 auto snoozeChimeIntervalModel = std::make_unique<bell_settings::SnoozeChimeIntervalModel>(this);
                 auto snoozeChimeToneModel     = std::make_unique<bell_settings::SnoozeChimeToneModel>(this);
-                auto snoozeChimeVolumeModel   = std::make_unique<bell_settings::SnoozeChimeVolumeModel>(this);
+                auto snoozeChimeVolumeModel   = std::make_unique<bell_settings::SnoozeChimeVolumeModel>(*audioModel);
                 auto snoozeSettingsModel =
                     std::make_unique<bell_settings::SnoozeSettingsModel>(std::move(snoozeOnOffModel),
                                                                          std::move(snoozeLengthModel),
                                                                          std::move(snoozeChimeIntervalModel),
                                                                          std::move(snoozeChimeToneModel),
                                                                          std::move(snoozeChimeVolumeModel));
-                auto audioModel       = std::make_unique<AudioModel>(this);
                 auto soundsRepository = std::make_unique<SoundsRepository>(alarms::paths::getSnoozeChimesDir());
                 auto provider         = std::make_shared<bell_settings::SnoozeListItemProvider>(
                     *snoozeSettingsModel, soundsRepository->getSongTitles());
@@ -190,12 +190,12 @@ namespace app
             });
         windowsFactory.attach(
             gui::BellSettingsAlarmSettingsWindow::name, [this](ApplicationCommon *app, const std::string &) {
+                auto audioModel           = std::make_unique<AudioModel>(this);
                 auto alarmToneModel       = std::make_unique<bell_settings::AlarmToneModel>(this);
-                auto alarmVolumeModel     = std::make_unique<bell_settings::AlarmVolumeModel>(this);
+                auto alarmVolumeModel     = std::make_unique<bell_settings::AlarmVolumeModel>(*audioModel);
                 auto alarmLightOnOffModel = std::make_unique<bell_settings::AlarmLightOnOffModel>(this);
                 auto alarmSettingsModel   = std::make_unique<bell_settings::AlarmSettingsModel>(
                     std::move(alarmToneModel), std::move(alarmVolumeModel), std::move(alarmLightOnOffModel));
-                auto audioModel       = std::make_unique<AudioModel>(this);
                 auto soundsRepository = std::make_unique<SoundsRepository>(alarms::paths::getAlarmDir());
                 auto provider         = std::make_shared<bell_settings::AlarmSettingsListItemProvider>(
                     *alarmSettingsModel, soundsRepository->getSongTitles());
diff --git a/products/BellHybrid/apps/application-bell-settings/CMakeLists.txt b/products/BellHybrid/apps/application-bell-settings/CMakeLists.txt
index ca81b1ddc8588f7b069c2619a4ecc30b4ace10d7..56ca4499da6ca05078a90fa07fabe894269396ea 100644
--- a/products/BellHybrid/apps/application-bell-settings/CMakeLists.txt
+++ b/products/BellHybrid/apps/application-bell-settings/CMakeLists.txt
@@ -120,6 +120,7 @@ target_sources(application-bell-settings
 target_link_libraries(application-bell-settings
     PRIVATE
         app
+        bell::audio
         bellgui
         bell::db
         bell::alarms
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
index 3b9c8a241c2b82d834f4366a03c0a6cd8b1deb4e..7af358287abdc714a16480a634a1d12e692301c1 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.cpp
@@ -21,13 +21,20 @@ namespace app::bell_settings
     void AlarmVolumeModel::setValue(std::uint8_t value)
     {
         const auto valStr = std::to_string(value);
-        settings.setValue(bell::settings::Alarm::volume, valStr, settings::SettingsScope::Global);
+        audioModel.setVolume(value, AbstractAudioModel::PlaybackType::Alarm, {});
     }
 
     std::uint8_t AlarmVolumeModel::getValue() const
     {
-        const auto str = settings.getValue(bell::settings::Alarm::volume, settings::SettingsScope::Global);
-        return std::stoi(str);
+        return defaultValue;
+    }
+    void AlarmVolumeModel::restoreDefault()
+    {
+        setValue(defaultValue);
+    }
+    AlarmVolumeModel::AlarmVolumeModel(AbstractAudioModel &audioModel) : audioModel{audioModel}
+    {
+        defaultValue = audioModel.getVolume(AbstractAudioModel::PlaybackType::Alarm).value_or(0);
     }
 
     void AlarmLightOnOffModel::setValue(bool value)
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.hpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.hpp
index 758293c384b8acc73aaf8d58a5a1c82615e71cd5..182e45d5b24f63e69eac14c081f00de18e79350d 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/AlarmSettingsModel.hpp
@@ -5,6 +5,7 @@
 
 #include "AbstractAlarmSettingsModel.hpp"
 #include <common/models/SettingsModel.hpp>
+#include <common/models/AudioModel.hpp>
 
 namespace app::bell_settings
 {
@@ -17,13 +18,17 @@ namespace app::bell_settings
         UTF8 getValue() const override;
     };
 
-    class AlarmVolumeModel : public gui::SettingsModel<std::uint8_t>
+    class AlarmVolumeModel : public gui::AbstractSettingsModel<std::uint8_t>
     {
       public:
-        using SettingsModel::SettingsModel;
-
+        explicit AlarmVolumeModel(AbstractAudioModel &audioModel);
         void setValue(std::uint8_t value) override;
         std::uint8_t getValue() const override;
+        void restoreDefault() override;
+
+      private:
+        AbstractAudioModel &audioModel;
+        std::uint8_t defaultValue;
     };
 
     class AlarmLightOnOffModel : public gui::SettingsModel<bool>
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.cpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.cpp
index 932b00b91cdd758e771a4f191691c00b9c05cd79..2d749d1fa31f2ccbee00c4098f451121c61a7ba6 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.cpp
@@ -33,13 +33,20 @@ namespace app::bell_settings
     void PrewakeUpChimeVolumeModel::setValue(std::uint8_t value)
     {
         const auto valStr = std::to_string(value);
-        settings.setValue(bell::settings::PrewakeUp::volume, valStr, settings::SettingsScope::Global);
+        audioModel.setVolume(value, AbstractAudioModel::PlaybackType::PreWakeup, {});
     }
 
     std::uint8_t PrewakeUpChimeVolumeModel::getValue() const
     {
-        const auto str = settings.getValue(bell::settings::PrewakeUp::volume, settings::SettingsScope::Global);
-        return std::stoi(str);
+        return defaultValue;
+    }
+    PrewakeUpChimeVolumeModel::PrewakeUpChimeVolumeModel(AbstractAudioModel &audioModel) : audioModel{audioModel}
+    {
+        defaultValue = audioModel.getVolume(AbstractAudioModel::PlaybackType::PreWakeup).value_or(0);
+    }
+    void PrewakeUpChimeVolumeModel::restoreDefault()
+    {
+        setValue(defaultValue);
     }
 
     void PrewakeUpLightDurationModel::setValue(std::uint8_t value)
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.hpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.hpp
index f095c74df7e732eff6359899d057c82a392a908c..3acd0fede4099b1d4d852444a9d1f70f50a570ed 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/PrewakeUpSettingsModel.hpp
@@ -5,6 +5,7 @@
 
 #include "AbstractPrewakeUpSettingsModel.hpp"
 #include <common/models/SettingsModel.hpp>
+#include <common/models/AudioModel.hpp>
 
 namespace app::bell_settings
 {
@@ -26,13 +27,17 @@ namespace app::bell_settings
         UTF8 getValue() const override;
     };
 
-    class PrewakeUpChimeVolumeModel : public gui::SettingsModel<std::uint8_t>
+    class PrewakeUpChimeVolumeModel : public gui::AbstractSettingsModel<std::uint8_t>
     {
       public:
-        using SettingsModel::SettingsModel;
-
+        explicit PrewakeUpChimeVolumeModel(AbstractAudioModel &audioModel);
         void setValue(std::uint8_t value) override;
         std::uint8_t getValue() const override;
+        void restoreDefault() override;
+
+      private:
+        AbstractAudioModel &audioModel;
+        std::uint8_t defaultValue;
     };
 
     class PrewakeUpLightDurationModel : public gui::SettingsModel<std::uint8_t>
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.cpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.cpp
index 00593bdc7b05b241e00884b9f7decf2c5c600555..e1be32958bd20e6e95a7fc9c0b9d9abb431d5d62 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.cpp
@@ -74,11 +74,19 @@ namespace app::bell_settings
     void SnoozeChimeVolumeModel::setValue(std::uint8_t value)
     {
         const auto valStr = std::to_string(value);
-        settings.setValue(bell::settings::Snooze::volume, valStr, settings::SettingsScope::Global);
+        audioModel.setVolume(value, AbstractAudioModel::PlaybackType::Snooze, {});
     }
 
     std::uint8_t SnoozeChimeVolumeModel::getValue() const
     {
-        return get_helper<std::uint8_t>(settings, bell::settings::Snooze::volume).value_or(0);
+        return defaultValue;
+    }
+    SnoozeChimeVolumeModel::SnoozeChimeVolumeModel(AbstractAudioModel &audioModel) : audioModel{audioModel}
+    {
+        defaultValue = audioModel.getVolume(AbstractAudioModel::PlaybackType::Snooze).value_or(0);
+    }
+    void SnoozeChimeVolumeModel::restoreDefault()
+    {
+        setValue(defaultValue);
     }
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.hpp b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.hpp
index e211ff4e7a62e5fff37a9725978dd8219b6b7330..8d35ad82bd597c2c90fdd09c32867314edb3342e 100644
--- a/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/models/alarm_settings/SnoozeSettingsModel.hpp
@@ -5,6 +5,7 @@
 
 #include "AbstractSnoozeSettingsModel.hpp"
 #include <common/models/SettingsModel.hpp>
+#include <common/models/AudioModel.hpp>
 
 namespace app::bell_settings
 {
@@ -44,13 +45,18 @@ namespace app::bell_settings
         UTF8 getValue() const override;
     };
 
-    class SnoozeChimeVolumeModel : public gui::SettingsModel<std::uint8_t>
+    class SnoozeChimeVolumeModel : public gui::AbstractSettingsModel<std::uint8_t>
     {
       public:
-        using SettingsModel::SettingsModel;
+        explicit SnoozeChimeVolumeModel(AbstractAudioModel &audioModel);
 
         void setValue(std::uint8_t value) override;
         std::uint8_t getValue() const override;
+        void restoreDefault() override;
+
+      private:
+        AbstractAudioModel &audioModel;
+        std::uint8_t defaultValue;
     };
 
     class SnoozeSettingsModel : public AbstractSnoozeSettingsModel
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.cpp b/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.cpp
index 366815440ee91134bcca027997440fd249acc699..42ce047b6a14a7196c0264e1566d87c756574a02 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.cpp
@@ -12,21 +12,11 @@ namespace app::bell_settings
         : provider(std::move(provider)),
           model(std::move(model)), audioModel{std::move(audioModel)}, soundsRepository{std::move(soundsRepository)}
     {
-        auto playResponseCb = [this](audio::RetCode retCode, audio::Token token) {
-            if (retCode != audio::RetCode::Success || !token.IsValid()) {
-                LOG_ERROR("Audio preview callback failed with retcode = %s. Token validity: %d",
-                          str(retCode).c_str(),
-                          token.IsValid());
-                return;
-            }
-            this->currentToken = token;
-        };
-
-        auto playSound = [this, playResponseCb](const UTF8 &val) {
+        auto playSound = [this](const UTF8 &val) {
             currentSoundPath = val;
             this->audioModel->play(this->soundsRepository->titleToPath(currentSoundPath).value_or(""),
-                                   playResponseCb,
-                                   AbstractAudioModel::PlaybackType::Bedtime);
+                                   AbstractAudioModel::PlaybackType::Bedtime,
+                                   {});
         };
 
         this->provider->onExit = [this]() { getView()->exit(); };
@@ -36,9 +26,9 @@ namespace app::bell_settings
         this->provider->onToneChange = playSound;
 
         this->provider->onVolumeEnter  = playSound;
-        this->provider->onVolumeExit   = [this](const auto &) { this->audioModel->stop(currentToken, nullptr); };
+        this->provider->onVolumeExit   = [this](const auto &) { this->stopSound(); };
         this->provider->onVolumeChange = [this, playSound](const auto &val) {
-            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Bedtime);
+            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Bedtime, {});
             playSound(currentSoundPath);
         };
     }
@@ -69,6 +59,10 @@ namespace app::bell_settings
 
     void BedtimeSettingsPresenter::stopSound()
     {
-        this->audioModel->stop(currentToken, nullptr);
+        this->audioModel->stop({});
+    }
+    void BedtimeSettingsPresenter::exitWithoutSave()
+    {
+        model->getBedtimeVolume().restoreDefault();
     }
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.hpp b/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.hpp
index 017683cbd54f3a63ba1ffa69562656c6b51dc5eb..52307d96a5668f3aa6a6f8ebead9f7ee0621140e 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/BedtimeSettingsPresenter.hpp
@@ -35,6 +35,7 @@ namespace app::bell_settings
             virtual auto saveData() -> void                                                 = 0;
             virtual auto loadData() -> void                                                 = 0;
             virtual auto eraseProviderData() -> void                                        = 0;
+            virtual void exitWithoutSave()                                                  = 0;
         };
     };
 
@@ -50,6 +51,7 @@ namespace app::bell_settings
         auto saveData() -> void override;
         auto loadData() -> void override;
         auto eraseProviderData() -> void override;
+        void exitWithoutSave() override;
 
       private:
         void stopSound();
@@ -58,7 +60,6 @@ namespace app::bell_settings
         std::shared_ptr<AbstractBedtimeModel> model;
         std::unique_ptr<AbstractAudioModel> audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
-        audio::Token currentToken;
         UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.cpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.cpp
index 6dd8ef20fa45571456e6e6e2fd9a553c6d13e967..e67776b3e8200aa870d7b74df433ea1a98996fe0 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.cpp
@@ -13,20 +13,10 @@ namespace app::bell_settings
         : provider(provider),
           model(std::move(model)), audioModel{std::move(audioModel)}, soundsRepository{std::move(soundsRepository)}
     {
-        auto playResponseCb = [this](audio::RetCode retCode, audio::Token token) {
-            if (retCode != audio::RetCode::Success || !token.IsValid()) {
-                LOG_ERROR("Audio preview callback failed with retcode = %s. Token validity: %d",
-                          str(retCode).c_str(),
-                          token.IsValid());
-                return;
-            }
-            this->currentToken = token;
-        };
 
-        auto playSound = [this, playResponseCb](const UTF8 &val) {
-            this->audioModel->play(this->soundsRepository->titleToPath(val).value_or(""),
-                                   playResponseCb,
-                                   AbstractAudioModel::PlaybackType::Alarm);
+        auto playSound = [this](const UTF8 &val) {
+            this->audioModel->play(
+                this->soundsRepository->titleToPath(val).value_or(""), AbstractAudioModel::PlaybackType::Alarm, {});
         };
 
         this->provider->onExit = [this]() { getView()->exit(); };
@@ -38,7 +28,7 @@ namespace app::bell_settings
         this->provider->onVolumeEnter  = playSound;
         this->provider->onVolumeExit   = [this](const auto &) { stopSound(); };
         this->provider->onVolumeChange = [this](const auto &val) {
-            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Alarm);
+            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Alarm, {});
         };
     }
 
@@ -67,6 +57,10 @@ namespace app::bell_settings
     }
     void AlarmSettingsPresenter::stopSound()
     {
-        this->audioModel->stop(currentToken, nullptr);
+        this->audioModel->stop({});
+    }
+    void AlarmSettingsPresenter::exitWithoutSave()
+    {
+        model->getAlarmVolume().restoreDefault();
     }
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.hpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.hpp
index b493eaa618c99c94b256728ede23275d4442aef6..8970382e7c52ee63c9b166d020990a9fea3d5f8e 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/AlarmSettingsPresenter.hpp
@@ -37,6 +37,7 @@ namespace app::bell_settings
             virtual auto saveData() -> void                                                 = 0;
             virtual auto loadData() -> void                                                 = 0;
             virtual auto eraseProviderData() -> void                                        = 0;
+            virtual void exitWithoutSave()                                                  = 0;
         };
     };
 
@@ -52,6 +53,7 @@ namespace app::bell_settings
         auto saveData() -> void override;
         auto loadData() -> void override;
         auto eraseProviderData() -> void override;
+        void exitWithoutSave() override;
 
       private:
         void stopSound();
@@ -60,6 +62,5 @@ namespace app::bell_settings
         std::unique_ptr<AbstractAlarmSettingsModel> model;
         std::unique_ptr<AbstractAudioModel> audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
-        audio::Token currentToken;
     };
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.cpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.cpp
index abc4d8e3b95974833e78a8b1bd76eedfc579d441..757e55b8f1055c497ab43b9b26a376e2010ecf4e 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.cpp
@@ -13,22 +13,11 @@ namespace app::bell_settings
         : provider(std::move(provider)),
           model(std::move(model)), audioModel{std::move(audioModel)}, soundsRepository{std::move(soundsRepository)}
     {
-
-        auto playResponseCb = [this](audio::RetCode retCode, audio::Token token) {
-            if (retCode != audio::RetCode::Success || !token.IsValid()) {
-                LOG_ERROR("Audio preview callback failed with retcode = %s. Token validity: %d",
-                          str(retCode).c_str(),
-                          token.IsValid());
-                return;
-            }
-            this->currentToken = token;
-        };
-
-        auto playSound = [this, playResponseCb](const UTF8 &val) {
+        auto playSound = [this](const UTF8 &val) {
             currentSoundPath = val;
             this->audioModel->play(this->soundsRepository->titleToPath(currentSoundPath).value_or(""),
-                                   playResponseCb,
-                                   AbstractAudioModel::PlaybackType::PreWakeup);
+                                   AbstractAudioModel::PlaybackType::PreWakeup,
+                                   {});
         };
 
         this->provider->onExit = [this]() { getView()->exit(); };
@@ -38,9 +27,9 @@ namespace app::bell_settings
         this->provider->onToneChange = playSound;
 
         this->provider->onVolumeEnter  = playSound;
-        this->provider->onVolumeExit   = [this](const auto &) { this->audioModel->stop(currentToken, nullptr); };
+        this->provider->onVolumeExit   = [this](const auto &) { this->stopSound(); };
         this->provider->onVolumeChange = [this, playSound](const auto &val) {
-            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::PreWakeup);
+            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::PreWakeup, {});
             playSound(currentSoundPath);
         };
     }
@@ -70,6 +59,10 @@ namespace app::bell_settings
     }
     void PrewakeUpWindowPresenter::stopSound()
     {
-        this->audioModel->stop(currentToken, nullptr);
+        this->audioModel->stop({});
+    }
+    void PrewakeUpWindowPresenter::exitWithoutSave()
+    {
+        model->getChimeVolume().restoreDefault();
     }
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.hpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.hpp
index 85921dd7451af63b11234e51fff6fb9418f28499..b03186283085ea7248aa22fb0be20373e9f082c9 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/PrewakeUpPresenter.hpp
@@ -37,6 +37,7 @@ namespace app::bell_settings
             virtual auto saveData() -> void                                                 = 0;
             virtual auto loadData() -> void                                                 = 0;
             virtual auto eraseProviderData() -> void                                        = 0;
+            virtual void exitWithoutSave()                                                  = 0;
         };
     };
 
@@ -52,6 +53,7 @@ namespace app::bell_settings
         auto saveData() -> void override;
         auto loadData() -> void override;
         auto eraseProviderData() -> void override;
+        void exitWithoutSave() override;
 
       private:
         void stopSound();
@@ -60,7 +62,6 @@ namespace app::bell_settings
         std::unique_ptr<AbstractPrewakeUpSettingsModel> model;
         std::unique_ptr<AbstractAudioModel> audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
-        audio::Token currentToken;
         UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.cpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.cpp
index 57c3679cbe5e8ef6e0377a487fd2306266f67389..eda797ac1a2a24db4bb198219e7d6cf3c46952fb 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.cpp
@@ -14,21 +14,11 @@ namespace app::bell_settings
         : provider{provider}, snoozeSettingsModel{std::move(snoozeSettingsModel)}, audioModel{std::move(audioModel)},
           soundsRepository{std::move(soundsRepository)}
     {
-        auto playResponseCb = [this](audio::RetCode retCode, audio::Token token) {
-            if (retCode != audio::RetCode::Success || !token.IsValid()) {
-                LOG_ERROR("Audio preview callback failed with retcode = %s. Token validity: %d",
-                          str(retCode).c_str(),
-                          token.IsValid());
-                return;
-            }
-            this->currentToken = token;
-        };
-
-        auto playSound = [this, playResponseCb](const UTF8 &val) {
+        auto playSound = [this](const UTF8 &val) {
             currentSoundPath = val;
             this->audioModel->play(this->soundsRepository->titleToPath(currentSoundPath).value_or(""),
-                                   playResponseCb,
-                                   AbstractAudioModel::PlaybackType::Chime);
+                                   AbstractAudioModel::PlaybackType::Snooze,
+                                   {});
         };
 
         this->provider->onExit = [this]() { getView()->exit(); };
@@ -38,8 +28,9 @@ namespace app::bell_settings
         this->provider->onToneChange = playSound;
 
         this->provider->onVolumeEnter  = playSound;
+        this->provider->onVolumeExit   = [this](const auto &) { stopSound(); };
         this->provider->onVolumeChange = [this, playSound](const auto &val) {
-            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Chime);
+            this->audioModel->setVolume(val, AbstractAudioModel::PlaybackType::Snooze, {});
             playSound(currentSoundPath);
         };
     }
@@ -65,10 +56,14 @@ namespace app::bell_settings
     }
     void SnoozePresenter::stopSound()
     {
-        audioModel->stop(currentToken, nullptr);
+        audioModel->stop({});
     }
     void SnoozePresenter::eraseProviderData()
     {
         provider->clearData();
     }
+    void SnoozePresenter::exitWithoutSave()
+    {
+        snoozeSettingsModel->getSnoozeChimeVolume().restoreDefault();
+    }
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.hpp b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.hpp
index a4f748857ec86be93fb89bd57778343c722732eb..fa7d8f85fd88617605fc89134b6ac25a258eefed 100644
--- a/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.hpp
+++ b/products/BellHybrid/apps/application-bell-settings/presenter/alarm_settings/SnoozePresenter.hpp
@@ -33,6 +33,7 @@ namespace app::bell_settings
         virtual void saveData()                                                         = 0;
         virtual void loadData()                                                         = 0;
         virtual void eraseProviderData()                                                = 0;
+        virtual void exitWithoutSave()                                                  = 0;
     };
 
     class SnoozePresenter : public AbstractSnoozePresenter
@@ -46,6 +47,7 @@ namespace app::bell_settings
         void saveData() override;
         void loadData() override;
         void eraseProviderData() override;
+        void exitWithoutSave() override;
 
       private:
         void stopSound();
@@ -54,8 +56,6 @@ namespace app::bell_settings
         std::unique_ptr<AbstractSnoozeSettingsModel> snoozeSettingsModel;
         std::unique_ptr<AbstractAudioModel> audioModel;
         std::unique_ptr<AbstractSoundsRepository> soundsRepository;
-
-        audio::Token currentToken;
         UTF8 currentSoundPath;
     };
 } // namespace app::bell_settings
diff --git a/products/BellHybrid/apps/application-bell-settings/windows/BellSettingsBedtimeToneWindow.cpp b/products/BellHybrid/apps/application-bell-settings/windows/BellSettingsBedtimeToneWindow.cpp
index a7107667e0aebdfcdf19f8ddca624705bf6d5e6d..e392a4d4c7867c6d1fe25734c22f551684153e95 100644
--- a/products/BellHybrid/apps/application-bell-settings/windows/BellSettingsBedtimeToneWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/windows/BellSettingsBedtimeToneWindow.cpp
@@ -51,6 +51,9 @@ namespace gui
             exit();
             return true;
         }
+        if (inputEvent.isShortRelease(KeyCode::KEY_RF)) {
+            presenter->exitWithoutSave();
+        }
 
         return AppWindow::onInput(inputEvent);
     }
diff --git a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsSnoozeWindow.cpp b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsSnoozeWindow.cpp
index 9b53381b804796c6562500457f0a82259b4a0720..ec6f45933a6ac434e8bf50eddebcfde1d4106739 100644
--- a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsSnoozeWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsSnoozeWindow.cpp
@@ -50,6 +50,11 @@ namespace gui
             exit();
             return true;
         }
+
+        if (inputEvent.isShortRelease(KeyCode::KEY_RF)) {
+            presenter->exitWithoutSave();
+        }
+
         return AppWindow::onInput(inputEvent);
     }
 
diff --git a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.cpp b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.cpp
index 21fbcd07eb7a6056f5863422bbdd36e37ea6ac53..fff44d7dec5a1f6f22a57b30cec7ac09cb0af1e6 100644
--- a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsAlarmSettingsWindow.cpp
@@ -55,6 +55,9 @@ namespace gui
             exit();
             return true;
         }
+        if (inputEvent.isShortRelease(KeyCode::KEY_RF)) {
+            presenter->exitWithoutSave();
+        }
 
         return AppWindow::onInput(inputEvent);
     }
diff --git a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsPrewakeUpWindow.cpp b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsPrewakeUpWindow.cpp
index ef390d166bc2a4870dd1530b8df22af4ae0fec5e..daea53f2991d0bf2d98cb06d5ae50c5d87061cc7 100644
--- a/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsPrewakeUpWindow.cpp
+++ b/products/BellHybrid/apps/application-bell-settings/windows/alarm_settings/BellSettingsPrewakeUpWindow.cpp
@@ -54,6 +54,9 @@ namespace gui
             exit();
             return true;
         }
+        if (inputEvent.isShortRelease(KeyCode::KEY_RF)) {
+            presenter->exitWithoutSave();
+        }
 
         return AppWindow::onInput(inputEvent);
     }
diff --git a/products/BellHybrid/apps/common/CMakeLists.txt b/products/BellHybrid/apps/common/CMakeLists.txt
index 9073e9d80c0662b4e58e88512212f97e62dd011e..a977f96425b1e394e142f8496d455b26ce21e3a6 100644
--- a/products/BellHybrid/apps/common/CMakeLists.txt
+++ b/products/BellHybrid/apps/common/CMakeLists.txt
@@ -79,6 +79,7 @@ target_link_libraries(application-bell-common
     PRIVATE
         bell::app-main
         bell::app-alarm
+        bell::audio
         module-gui
         bell::db
         )
diff --git a/products/BellHybrid/apps/common/include/common/models/AbstractAudioModel.hpp b/products/BellHybrid/apps/common/include/common/models/AbstractAudioModel.hpp
index 3580691475a76130dd2c888d20c10b3916d2809a..e1ad255d65aff4648766fa43df37b74564027a45 100644
--- a/products/BellHybrid/apps/common/include/common/models/AbstractAudioModel.hpp
+++ b/products/BellHybrid/apps/common/include/common/models/AbstractAudioModel.hpp
@@ -3,40 +3,41 @@
 
 #pragma once
 
-#include <Audio/AudioCommon.hpp>
+#include <module-audio/Audio/AudioCommon.hpp>
 
 #include <string>
 #include <functional>
+#include <optional>
 
 namespace app
 {
-    using AlarmModelReadyHandler = std::function<void()>;
-
     class AbstractAudioModel
     {
       public:
         /// 0-10 range
-        using Volume = std::uint8_t;
-
-        using OnPlayCallback   = std::function<void(audio::RetCode retCode, audio::Token token)>;
-        using OnStopCallback   = OnPlayCallback;
-        using OnPauseCallback  = OnPlayCallback;
-        using OnResumeCallback = OnPlayCallback;
+        static constexpr auto minVolume = 1;
+        static constexpr auto maxVolume = 10;
+        using Volume                    = std::uint32_t;
+        using OnStateChangeCallback     = std::function<void(const audio::RetCode code)>;
+        using OnGetValueCallback        = std::function<void(const audio::RetCode, Volume)>;
 
         enum class PlaybackType
         {
-            Chime,
+            Multimedia,
+            Snooze,
             Alarm,
             PreWakeup,
             Bedtime
         };
 
-        virtual ~AbstractAudioModel() noexcept                                                            = default;
-        virtual void setVolume(Volume volume, PlaybackType playbackType)                                  = 0;
-        virtual bool play(const std::string &filePath, const OnPlayCallback &callback, PlaybackType type) = 0;
-        virtual bool pause(const audio::Token &token, const OnPauseCallback &callback)                    = 0;
-        virtual bool resume(const audio::Token &token, const OnResumeCallback &callback)                  = 0;
-        virtual bool stop(const audio::Token &token, const OnStopCallback &callback)                      = 0;
+        virtual ~AbstractAudioModel() noexcept                                                              = default;
+        virtual void setVolume(Volume volume, PlaybackType playbackType, OnStateChangeCallback &&callback)  = 0;
+        virtual std::optional<Volume> getVolume(PlaybackType playbackType)                                  = 0;
+        virtual void getVolume(PlaybackType playbackType, OnGetValueCallback &&callback)                    = 0;
+        virtual void play(const std::string &filePath, PlaybackType type, OnStateChangeCallback &&callback) = 0;
+        virtual void stop(OnStateChangeCallback &&callback)                                                 = 0;
+        virtual void pause(OnStateChangeCallback &&callback)                                                = 0;
+        virtual void resume(OnStateChangeCallback &&callback)                                               = 0;
     };
 
 } // namespace app
diff --git a/products/BellHybrid/apps/common/include/common/models/AbstractSettingsModel.hpp b/products/BellHybrid/apps/common/include/common/models/AbstractSettingsModel.hpp
index 3618cff9a360c8593dc7fc712f217411e2b2e5f1..fb721adaba9e9f999daf8f309fae7f7e7029627b 100644
--- a/products/BellHybrid/apps/common/include/common/models/AbstractSettingsModel.hpp
+++ b/products/BellHybrid/apps/common/include/common/models/AbstractSettingsModel.hpp
@@ -3,6 +3,13 @@
 
 #pragma once
 
+#include <apps-common/AsyncTask.hpp>
+
+namespace app
+{
+    class ApplicationCommon;
+}
+
 namespace gui
 {
     template <class ValueType> class AbstractSettingsModel
@@ -12,5 +19,42 @@ namespace gui
 
         virtual void setValue(ValueType value) = 0;
         virtual ValueType getValue() const     = 0;
+        virtual void restoreDefault()
+        {}
+    };
+
+    template <typename ValueT> class AsyncSettingsAdapter : public AbstractSettingsModel<ValueT>
+    {
+      public:
+        std::function<void(ValueT)> onReady;
+
+        void setValue(ValueT value) final
+        {
+            onSet(value);
+        }
+
+        ValueT getValue() const final
+        {
+            return currentValue;
+        }
+
+        void restoreDefault() final
+        {
+            onSet(defaultValue);
+        }
+
+      protected:
+        std::function<void(ValueT)> onSet;
+
+        void onUpdate(ValueT value)
+        {
+            currentValue = value;
+            defaultValue = currentValue;
+            onReady(currentValue);
+        }
+
+      private:
+        ValueT currentValue{};
+        ValueT defaultValue{};
     };
 } // namespace gui
diff --git a/products/BellHybrid/apps/common/include/common/models/AudioModel.hpp b/products/BellHybrid/apps/common/include/common/models/AudioModel.hpp
index cc08498097d2fd8c01f4e27c1f490e88f2598110..31888d9fef58b2a6b5e48a3653c6f623158d38f1 100644
--- a/products/BellHybrid/apps/common/include/common/models/AudioModel.hpp
+++ b/products/BellHybrid/apps/common/include/common/models/AudioModel.hpp
@@ -4,28 +4,24 @@
 #pragma once
 
 #include "AbstractAudioModel.hpp"
-#include <apps-common/AudioOperations.hpp>
+#include <apps-common/AsyncTask.hpp>
 
 namespace app
 {
-    class ApplicationCommon;
-}
-
-namespace app
-{
-    class AudioModel : public AbstractAudioModel
+    class AudioModel : public AbstractAudioModel, public app::AsyncCallbackReceiver
     {
       public:
         explicit AudioModel(ApplicationCommon *app);
 
-        void setVolume(Volume volume, PlaybackType playbackType) override;
-        bool play(const std::string &filePath, const OnPlayCallback &callback, PlaybackType type) override;
-        bool pause(const audio::Token &token, const OnPauseCallback &callback) override;
-        bool resume(const audio::Token &token, const OnResumeCallback &callback) override;
-        bool stop(const audio::Token &token, const OnStopCallback &callback) override;
+        void setVolume(Volume volume, PlaybackType playbackType, OnStateChangeCallback &&callback) override;
+        std::optional<Volume> getVolume(PlaybackType playbackType) override;
+        void getVolume(PlaybackType playbackType, OnGetValueCallback &&callback) override;
+        void play(const std::string &filePath, PlaybackType type, OnStateChangeCallback &&callback) override;
+        void stop(OnStateChangeCallback &&callback) override;
+        void pause(OnStateChangeCallback &&callback) override;
+        void resume(OnStateChangeCallback &&callback) override;
 
       private:
         ApplicationCommon *app{};
-        AsyncAudioOperations asyncAudioOperations;
     };
 } // namespace app
diff --git a/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp b/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp
index 3db849b02ac3ba231281a12eb1eef5462aa738d3..919741edd5216ddf6b7c9641ba630d038b08ed2d 100644
--- a/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp
+++ b/products/BellHybrid/apps/common/include/common/models/BedtimeModel.hpp
@@ -6,13 +6,14 @@
 #include "AbstractBedtimeModel.hpp"
 #include "SettingsModel.hpp"
 #include <Service/Service.hpp>
+#include <common/models/AudioModel.hpp>
+#include <ApplicationCommon.hpp>
 #include <ctime>
 
 namespace app::bell_bedtime
 {
-    inline constexpr auto DEFAULT_BEDTIME_TIME   = "21:00";
-    inline constexpr auto DEFAULT_BEDTIME_TONE   = "Evening Horizon";
-    inline constexpr auto DEFAULT_BEDTIME_VOLUME = 1;
+    inline constexpr auto DEFAULT_BEDTIME_TIME = "21:00";
+    inline constexpr auto DEFAULT_BEDTIME_TONE = "Evening Horizon";
 
     class BedtimeOnOffModel : public gui::SettingsModel<bool>
     {
@@ -36,13 +37,18 @@ namespace app::bell_bedtime
         auto getValue() const -> time_t override;
     };
 
-    class BedtimeVolumeModel : public gui::SettingsModel<std::uint8_t>
+    class BedtimeVolumeModel : public gui::AbstractSettingsModel<std::uint8_t>
     {
       public:
-        using SettingsModel::SettingsModel;
+        explicit BedtimeVolumeModel(AbstractAudioModel &audioModel);
 
         void setValue(std::uint8_t value) override;
         std::uint8_t getValue() const override;
+        void restoreDefault() override;
+
+      private:
+        AbstractAudioModel &audioModel;
+        std::uint8_t defaultValue;
     };
 
     class AlarmToneModel : public gui::SettingsModel<UTF8>
@@ -61,10 +67,11 @@ namespace app::bell_bedtime
 
         explicit BedtimeModel(sys::Service *app)
         {
+            audioModel    = std::make_unique<AudioModel>(static_cast<ApplicationCommon *>(app));
             bedtimeOnOff  = std::make_unique<bell_bedtime::BedtimeOnOffModel>(app);
             bedtimeTime   = std::make_unique<bell_bedtime::BedtimeTimeModel>(app);
             bedtimeTone   = std::make_unique<bell_bedtime::AlarmToneModel>(app);
-            bedtimeVolume = std::make_unique<bell_bedtime::BedtimeVolumeModel>(app);
+            bedtimeVolume = std::make_unique<bell_bedtime::BedtimeVolumeModel>(*audioModel);
         }
         gui::AbstractSettingsModel<bool> &getBedtimeOnOff() override
         {
@@ -86,6 +93,7 @@ namespace app::bell_bedtime
         }
 
       private:
+        std::unique_ptr<AudioModel> audioModel;
         std::unique_ptr<gui::AbstractSettingsModel<bool>> bedtimeOnOff;
         std::unique_ptr<gui::AbstractSettingsModel<time_t>> bedtimeTime;
         std::unique_ptr<gui::AbstractSettingsModel<UTF8>> bedtimeTone;
diff --git a/products/BellHybrid/apps/common/src/AudioModel.cpp b/products/BellHybrid/apps/common/src/AudioModel.cpp
index b497e9c754edbd6da64f949f3a9d1a0a88ef15b8..926ef7dcd1e21413ec8361d21735a21e5bd902cd 100644
--- a/products/BellHybrid/apps/common/src/AudioModel.cpp
+++ b/products/BellHybrid/apps/common/src/AudioModel.cpp
@@ -2,7 +2,9 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "models/AudioModel.hpp"
-#include <service-audio/AudioServiceAPI.hpp>
+
+#include <ApplicationCommon.hpp>
+#include <audio/AudioMessage.hpp>
 
 namespace
 {
@@ -10,45 +12,168 @@ namespace
     {
         using Type = app::AbstractAudioModel::PlaybackType;
         switch (type) {
+        case Type::Multimedia:
+            return audio::PlaybackType::Multimedia;
         case Type::Alarm:
             return audio::PlaybackType::Alarm;
-        case Type::Chime:
-            return audio::PlaybackType::Alarm;
+        case Type::Snooze:
+            return audio::PlaybackType::Snooze;
         case Type::PreWakeup:
-            return audio::PlaybackType::Alarm;
+            return audio::PlaybackType::PreWakeUp;
         case Type::Bedtime:
-            return audio::PlaybackType::Alarm;
+            return audio::PlaybackType::Bedtime;
         default:
             return audio::PlaybackType::Alarm;
         }
     }
+
+    void reportError(const char *prefix, audio::RetCode code)
+    {
+        if (code != audio::RetCode::Success) {
+            LOG_ERROR("%s request error: %s", prefix, magic_enum::enum_name(code).data());
+        }
+    }
+
+    auto SendAudioRequest(sys::Service *serv, std::shared_ptr<service::AudioMessage> msg)
+    {
+        auto msgType = static_cast<int>(msg->type);
+        auto ret     = serv->bus.sendUnicastSync(msg, service::audioServiceName, sys::BusProxy::defaultTimeout);
+        if (ret.first == sys::ReturnCodes::Success) {
+            if (auto resp = std::dynamic_pointer_cast<service::AudioResponseMessage>(ret.second)) {
+                return resp;
+            }
+            LOG_ERROR("msgType %d - not AudioResponseMessage", msgType);
+            return std::make_shared<service::AudioResponseMessage>(audio::RetCode::Failed);
+        }
+        LOG_ERROR("Command %d Failed with %d error", msgType, static_cast<int>(ret.first));
+        return std::make_shared<service::AudioResponseMessage>(audio::RetCode::Failed);
+    }
+
 } // namespace
 
 namespace app
 {
 
-    AudioModel::AudioModel(ApplicationCommon *app) : app{app}, asyncAudioOperations{app}
+    AudioModel::AudioModel(ApplicationCommon *app) : app::AsyncCallbackReceiver{app}, app{app}
     {}
-    void AudioModel::setVolume(AbstractAudioModel::Volume volume, PlaybackType playbackType)
+    void AudioModel::play(const std::string &filePath, PlaybackType type, OnStateChangeCallback &&callback)
+    {
+        auto msg  = std::make_unique<service::AudioStartPlaybackRequest>(filePath, convertPlaybackType(type));
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioStartPlaybackResponse *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode);
+            }
+            reportError("play", result->retCode);
+
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
+    }
+
+    void AudioModel::stop(OnStateChangeCallback &&callback)
+    {
+        auto msg  = std::make_unique<service::AudioStopRequest>();
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioStopResponse *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode);
+            }
+            reportError("stop", result->retCode);
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
+    }
+
+    void AudioModel::setVolume(AbstractAudioModel::Volume volume,
+                               PlaybackType playbackType,
+                               OnStateChangeCallback &&callback)
     {
-        AudioServiceAPI::SetVolume(app, volume, convertPlaybackType(playbackType));
+        auto msg = std::make_unique<service::AudioSetVolume>(convertPlaybackType(playbackType), std::to_string(volume));
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioResponseMessage *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode);
+            }
+            reportError("setVolume", result->retCode);
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
     }
-    bool AudioModel::play(const std::string &filePath,
-                          const AbstractAudioOperations::OnPlayCallback &callback,
-                          PlaybackType type)
+    void AudioModel::pause(OnStateChangeCallback &&callback)
     {
-        return asyncAudioOperations.play(filePath, callback, convertPlaybackType(type));
+        auto msg  = std::make_unique<service::AudioPauseRequest>();
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioResponseMessage *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode);
+            }
+
+            reportError("pause", result->retCode);
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
     }
-    bool AudioModel::pause(const audio::Token &token, const AbstractAudioOperations::OnPauseCallback &callback)
+    void AudioModel::resume(OnStateChangeCallback &&callback)
     {
-        return asyncAudioOperations.pause(token, callback);
+        auto msg  = std::make_unique<service::AudioResumeRequest>();
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioResponseMessage *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode);
+            }
+            reportError("resume", result->retCode);
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
     }
-    bool AudioModel::resume(const audio::Token &token, const AbstractAudioOperations::OnResumeCallback &callback)
+    void AudioModel::getVolume(AbstractAudioModel::PlaybackType playbackType,
+                               AbstractAudioModel::OnGetValueCallback &&callback)
     {
-        return asyncAudioOperations.resume(token, callback);
+        auto msg  = std::make_unique<service::AudioGetVolume>(convertPlaybackType(playbackType));
+        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::audioServiceName);
+        auto cb   = [_callback = callback](auto response) {
+            auto result = dynamic_cast<service::AudioResponseMessage *>(response);
+            if (result == nullptr) {
+                return false;
+            }
+            if (_callback) {
+                _callback(result->retCode, utils::getNumericValue<AbstractAudioModel::Volume>(result->val));
+            }
+
+            reportError("getVolume", result->retCode);
+            return true;
+        };
+        task->execute(app, this, std::move(cb));
     }
-    bool AudioModel::stop(const audio::Token &token, const AbstractAudioOperations::OnStopCallback &callback)
+    std::optional<AbstractAudioModel::Volume> AudioModel::getVolume(AbstractAudioModel::PlaybackType playbackType)
     {
-        return asyncAudioOperations.stop(token, callback);
+        auto msg       = std::make_shared<service::AudioGetVolume>(convertPlaybackType(playbackType));
+        const auto ret = SendAudioRequest(app, msg);
+        if (ret) {
+            return utils::getNumericValue<audio::Volume>(ret->val);
+        }
+
+        return {};
     }
 } // namespace app
diff --git a/products/BellHybrid/apps/common/src/models/BedtimeModel.cpp b/products/BellHybrid/apps/common/src/models/BedtimeModel.cpp
index 36cfc879d5b34c469aa699844413b92691f00ff6..6797dc1cc438878a3f40243a9f64510d987e1b52 100644
--- a/products/BellHybrid/apps/common/src/models/BedtimeModel.cpp
+++ b/products/BellHybrid/apps/common/src/models/BedtimeModel.cpp
@@ -78,18 +78,20 @@ namespace app::bell_bedtime
     void BedtimeVolumeModel::setValue(std::uint8_t value)
     {
         const auto valStr = std::to_string(value);
-        settings.setValue(bell::settings::Bedtime::volume, valStr, settings::SettingsScope::Global);
+        audioModel.setVolume(value, AbstractAudioModel::PlaybackType::Bedtime, {});
     }
 
     auto BedtimeVolumeModel::getValue() const -> std::uint8_t
     {
-        const auto str = settings.getValue(bell::settings::Bedtime::volume, settings::SettingsScope::Global);
-        try {
-            return std::stoi(str);
-        }
-        catch (const std::invalid_argument &) {
-            return DEFAULT_BEDTIME_VOLUME;
-        }
+        return defaultValue;
+    }
+    BedtimeVolumeModel::BedtimeVolumeModel(AbstractAudioModel &audioModel) : audioModel{audioModel}
+    {
+        defaultValue = audioModel.getVolume(AbstractAudioModel::PlaybackType::Bedtime).value_or(0);
+    }
+    void BedtimeVolumeModel::restoreDefault()
+    {
+        setValue(defaultValue);
     }
 
 } // namespace app::bell_bedtime
diff --git a/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp b/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp
index 07f8a1e2ff22984b673ae19309f6e1bd2a12826c..2e99b27940fe76711094b6896aa59600b5687573 100644
--- a/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp
+++ b/products/BellHybrid/apps/common/src/popups/BedtimeNotificationWindow.cpp
@@ -1,13 +1,14 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
+#include <audio/AudioMessage.hpp>
 #include <apps-common/popups/Popups.hpp>
+#include <apps-common/popups/data/PopupRequestParams.hpp>
 #include <common/popups/BedtimeNotificationWindow.hpp>
 #include <gui/input/InputEvent.hpp>
 #include <gui/widgets/Icon.hpp>
 #include <i18n/i18n.hpp>
 #include <purefs/filesystem_paths.hpp>
-#include <service-audio/AudioServiceAPI.hpp>
 #include <service-appmgr/Controller.hpp>
 
 namespace gui
@@ -72,8 +73,7 @@ namespace gui
 
     void BedtimeNotificationWindow::onClose(CloseReason reason)
     {
-        auto stopPlaybackVec = std::vector<audio::PlaybackType>({audio::PlaybackType::Multimedia});
-        AudioServiceAPI::Stop(app, stopPlaybackVec);
+        application->bus.sendUnicast(std::make_shared<service::AudioStopRequest>(), service::audioServiceName);
     }
 
 } /* namespace gui */
diff --git a/products/BellHybrid/services/CMakeLists.txt b/products/BellHybrid/services/CMakeLists.txt
index 104ebc1733aaf730cddaa5fd232823c18489ddcd..7c3540cc36df2f0123d1456ac03c521f8724d498 100644
--- a/products/BellHybrid/services/CMakeLists.txt
+++ b/products/BellHybrid/services/CMakeLists.txt
@@ -5,3 +5,4 @@ add_subdirectory(evtmgr)
 add_subdirectory(db)
 add_subdirectory(desktop)
 add_subdirectory(time)
+add_subdirectory(audio)
diff --git a/products/BellHybrid/services/audio/CMakeLists.txt b/products/BellHybrid/services/audio/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b3afe181cbd954c26b4950403fb7bbbc036d4707
--- /dev/null
+++ b/products/BellHybrid/services/audio/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+# For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+add_library(bell-audio STATIC)
+add_library(bell::audio ALIAS bell-audio)
+
+target_include_directories(bell-audio
+        PRIVATE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/audio>
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        )
+
+target_sources(bell-audio
+        PRIVATE
+        ServiceAudio.cpp
+
+        PUBLIC
+        include/audio/AudioMessage.hpp
+        include/audio/ServiceAudio.hpp
+
+        )
+
+
+target_link_libraries(bell-audio
+        PRIVATE
+        log
+        module-utils
+        service-db
+        PUBLIC
+        messagetype
+        module-audio
+        module-sys
+        )
diff --git a/products/BellHybrid/services/audio/ServiceAudio.cpp b/products/BellHybrid/services/audio/ServiceAudio.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1b71993b82b3b213a98f6b11903b13eacfdf07d
--- /dev/null
+++ b/products/BellHybrid/services/audio/ServiceAudio.cpp
@@ -0,0 +1,307 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "ServiceAudio.hpp"
+#include "system/Constants.hpp"
+
+#include <audio/AudioMessage.hpp>
+#include <service-db/Settings.hpp>
+#include <system/messages/SentinelRegistrationMessage.hpp>
+
+namespace
+{
+    constexpr auto stackSize            = 1024 * 4;
+    constexpr auto defaultVolume        = "5";
+    constexpr audio::Volume maxInVolume = 10;
+    constexpr audio::Volume minVolume   = 0;
+    constexpr auto profileType          = audio::Profile::Type::PlaybackLoudspeaker;
+    namespace initializer
+    {
+        using namespace audio;
+        // clang-format off
+        static constexpr std::initializer_list<std::pair<audio::DbPathElement, const char *>> values{
+            {DbPathElement{Setting::Volume, PlaybackType::Meditation, Profile::Type::PlaybackLoudspeaker},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Multimedia, Profile::Type::PlaybackLoudspeaker},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Alarm, Profile::Type::PlaybackLoudspeaker}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Bedtime, Profile::Type::PlaybackLoudspeaker}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::PreWakeUp, Profile::Type::PlaybackLoudspeaker},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Snooze, Profile::Type::PlaybackLoudspeaker}, defaultVolume},
+
+            /// Profiles below are not used but unfortunately, must exist in order to satisfy audio module requirements
+            {DbPathElement{Setting::Volume, PlaybackType::Meditation, Profile::Type::PlaybackHeadphones},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Meditation, Profile::Type::PlaybackBluetoothA2DP},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Multimedia, Profile::Type::PlaybackHeadphones},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Multimedia, Profile::Type::PlaybackBluetoothA2DP},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Alarm, Profile::Type::PlaybackHeadphones}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Alarm, Profile::Type::PlaybackBluetoothA2DP}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Bedtime, Profile::Type::PlaybackHeadphones}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Bedtime, Profile::Type::PlaybackBluetoothA2DP},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::PreWakeUp, Profile::Type::PlaybackHeadphones}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::PreWakeUp, Profile::Type::PlaybackBluetoothA2DP},defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Snooze, Profile::Type::PlaybackHeadphones}, defaultVolume},
+            {DbPathElement{Setting::Volume, PlaybackType::Snooze, Profile::Type::PlaybackBluetoothA2DP}, defaultVolume},
+        };
+        // clang-format on
+    } // namespace initializer
+
+    class AudioInternalEOFNotificationMessage : public service::AudioNotificationMessage
+    {
+      public:
+        explicit AudioInternalEOFNotificationMessage(audio::Token token) : AudioNotificationMessage(token)
+        {}
+    };
+} // namespace
+
+namespace service
+{
+    Audio::Audio()
+        : sys::Service(audioServiceName, "", stackSize, sys::ServicePriority::Idle),
+          audioMux([this](auto... params) { return this->AudioServicesCallback(params...); }),
+          cpuSentinel(std::make_shared<sys::CpuSentinel>(audioServiceName, this)),
+          settingsProvider(std::make_unique<settings::Settings>())
+    {
+        LOG_INFO("%s Initializing", audioServiceName);
+        bus.channels.push_back(sys::BusChannel::ServiceAudioNotifications);
+
+        auto sentinelRegistrationMsg = std::make_shared<sys::SentinelRegistrationMessage>(cpuSentinel);
+        bus.sendUnicast(std::move(sentinelRegistrationMsg), service::name::system_manager);
+
+        connect(typeid(AudioStartPlaybackRequest), [this](sys::Message *msg) -> sys::MessagePointer {
+            auto *msgl = static_cast<AudioStartPlaybackRequest *>(msg);
+            return handleStart(audio::Operation::Type::Playback, msgl->fileName.c_str(), msgl->playbackType);
+        });
+
+        connect(typeid(AudioInternalEOFNotificationMessage), [this](sys::Message *msg) -> sys::MessagePointer {
+            auto *msgl = static_cast<AudioInternalEOFNotificationMessage *>(msg);
+            handleEOF(msgl->token);
+            return sys::msgHandled();
+        });
+
+        connect(typeid(AudioStopRequest), [this](sys::Message *msg) -> sys::MessagePointer {
+            auto *msgl = static_cast<AudioStopRequest *>(msg);
+            return handleStop(msgl->stopVec, msgl->token);
+        });
+
+        connect(typeid(AudioSetVolume), [this](sys::Message *msg) -> sys::MessagePointer {
+            auto *msgl = static_cast<AudioSetVolume *>(msg);
+            return handleSetVolume(msgl->playbackType, msgl->val);
+        });
+
+        connect(typeid(AudioGetVolume), [this](sys::Message *msg) -> sys::MessagePointer {
+            auto *msgl = static_cast<AudioGetVolume *>(msg);
+            return handleGetVolume(msgl->playbackType);
+        });
+
+        connect(typeid(AudioPauseRequest), [this](sys::Message *msg) -> sys::MessagePointer { return handlePause(); });
+
+        connect(typeid(AudioResumeRequest),
+                [this](sys::Message *msg) -> sys::MessagePointer { return handleResume(); });
+    }
+    sys::MessagePointer Audio::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
+    {
+        return sys::msgNotHandled();
+    }
+    sys::ReturnCodes Audio::InitHandler()
+    {
+        settingsProvider->init(service::ServiceProxy(weak_from_this()));
+        initializeDatabase();
+
+        return sys::ReturnCodes::Success;
+    }
+    sys::ReturnCodes Audio::DeinitHandler()
+    {
+        return sys::ReturnCodes::Success;
+    }
+    void Audio::ProcessCloseReason([[maybe_unused]] sys::CloseReason closeReason)
+    {
+        if (const auto &activeInputOpt = audioMux.GetActiveInput(); activeInputOpt.has_value()) {
+            const auto activeInput = activeInputOpt.value();
+            activeInput->audio->Stop();
+        }
+        sendCloseReadyMessage(this);
+    }
+    auto Audio::handleStart(const audio::Operation::Type opType,
+                            const std::string &fileName,
+                            const audio::PlaybackType &playbackType) -> std::unique_ptr<AudioResponseMessage>
+    {
+        auto retCode  = audio::RetCode::Failed;
+        auto retToken = audio::Token::MakeBadToken();
+
+        auto AudioStart = [&](auto &input) {
+            if (input) {
+                for (auto &audioInput : audioMux.GetAllInputs()) {
+                    stopInput(&audioInput);
+                }
+                retToken = audioMux.ResetInput(input);
+
+                try {
+                    retCode = (*input)->audio->Start(opType, retToken, fileName.c_str(), playbackType);
+                }
+                catch (const audio::AudioInitException &audioException) {
+                    retCode = audio::RetCode::FailedToAllocateMemory;
+                }
+            }
+        };
+        auto input = audioMux.GetPlaybackInput(playbackType);
+        AudioStart(input);
+
+        return std::make_unique<AudioStartPlaybackResponse>(retCode, retToken);
+    }
+    auto Audio::handleStop(const std::vector<audio::PlaybackType> &stopTypes, const audio::Token &token)
+        -> std::unique_ptr<AudioResponseMessage>
+    {
+        std::vector<std::pair<audio::Token, audio::RetCode>> retCodes;
+
+        for (auto &input : audioMux.GetAllInputs()) {
+            auto t = input.token;
+            retCodes.emplace_back(t, stopInput(&input));
+        }
+
+        // on failure return first false code
+        auto it = std::find_if_not(
+            retCodes.begin(), retCodes.end(), [](auto p) { return p.second == audio::RetCode::Success; });
+        if (it != retCodes.end()) {
+            return std::make_unique<AudioStopResponse>(it->second, it->first);
+        }
+
+        return std::make_unique<AudioStopResponse>(audio::RetCode::Success, token);
+    }
+    auto Audio::stopInput(audio::AudioMux::Input *input, Audio::StopReason stopReason) -> audio::RetCode
+    {
+        if (input->audio->GetCurrentState() == audio::Audio::State::Idle) {
+            return audio::RetCode::Success;
+        }
+        const auto retCode = input->audio->Stop();
+        // Send notification that audio file was stopped
+        std::shared_ptr<AudioNotificationMessage> msg;
+        if (stopReason == StopReason::Eof) {
+            msg = std::make_shared<AudioEOFNotification>(input->token);
+        }
+        else {
+            msg = std::make_shared<AudioStopNotification>(input->token);
+        }
+        bus.sendMulticast(std::move(msg), sys::BusChannel::ServiceAudioNotifications);
+        audioMux.ResetInput(input);
+        return retCode;
+    }
+    constexpr auto Audio::shouldLoop(const std::optional<audio::PlaybackType> &type) const -> bool
+    {
+        return type == audio::PlaybackType::Alarm;
+    }
+    auto Audio::isBusy() const -> bool
+    {
+        const auto &inputs = audioMux.GetAllInputs();
+        return std::any_of(inputs.begin(), inputs.end(), [](const auto &input) {
+            return input.audio->GetCurrentState() != audio::Audio::State::Idle;
+        });
+    }
+    void Audio::handleEOF(const audio::Token &token)
+    {
+        if (const auto input = audioMux.GetInput(token); input) {
+            if (shouldLoop((*input)->audio->GetCurrentOperationPlaybackType())) {
+                (*input)->audio->Start();
+                if ((*input)->audio->IsMuted()) {
+                    (*input)->audio->Mute();
+                }
+            }
+            else {
+                stopInput(*input, StopReason::Eof);
+            }
+        }
+    }
+    auto Audio::AudioServicesCallback(const sys::Message *msg) -> std::optional<std::string>
+    {
+        std::optional<std::string> ret;
+        if (const auto *eof = dynamic_cast<const AudioServiceMessage::EndOfFile *>(msg); eof) {
+            bus.sendUnicast(std::make_shared<AudioInternalEOFNotificationMessage>(eof->GetToken()), audioServiceName);
+        }
+        else if (const auto *dbReq = dynamic_cast<const AudioServiceMessage::DbRequest *>(msg); dbReq) {
+            auto selectedPlayback = dbReq->playback;
+            auto selectedProfile  = dbReq->profile;
+            if (const auto result =
+                    settingsProvider->getValue(dbPath(dbReq->setting, selectedPlayback, selectedProfile));
+                not result.empty()) {
+                ret.emplace(result);
+            }
+        }
+        else {
+            LOG_DEBUG("Message received but not handled - no effect.");
+        }
+
+        return ret;
+    }
+    auto Audio::handleSetVolume(const audio::PlaybackType &playbackType, const std::string &value)
+        -> std::unique_ptr<AudioResponseMessage>
+    {
+        constexpr auto setting  = audio::Setting::Volume;
+        auto retCode            = audio::RetCode::Success;
+        const auto clampedValue = std::clamp(utils::getNumericValue<audio::Volume>(value), minVolume, maxInVolume);
+
+        if (const auto activeInput = audioMux.GetActiveInput(); activeInput) {
+            if (activeInput) {
+                retCode = activeInput.value()->audio->SetOutputVolume(clampedValue);
+            }
+        }
+
+        if (retCode == audio::RetCode::Success) {
+            settingsProvider->setValue(dbPath(setting, playbackType, profileType), std::to_string(clampedValue));
+        }
+        return std::make_unique<AudioResponseMessage>(retCode);
+    }
+    auto Audio::handleGetVolume(const audio::PlaybackType &playbackType) -> std::unique_ptr<AudioResponseMessage>
+    {
+        constexpr auto setting = audio::Setting::Volume;
+
+        const auto path = dbPath(setting, playbackType, profileType);
+        if (const auto value = settingsProvider->getValue(path); not value.empty()) {
+            return std::make_unique<AudioResponseMessage>(audio::RetCode::Success, value);
+        }
+
+        return std::make_unique<AudioResponseMessage>(audio::RetCode::Failed);
+    }
+    sys::ReturnCodes Audio::SwitchPowerModeHandler([[maybe_unused]] const sys::ServicePowerMode mode)
+    {
+        return sys::ReturnCodes::Success;
+    }
+    auto Audio::handlePause() -> std::unique_ptr<AudioResponseMessage>
+    {
+        auto retCode = audio::RetCode::InvokedInIncorrectState;
+        if (const auto activeInput = audioMux.GetActiveInput(); activeInput) {
+            auto playbackType = (*activeInput)->audio->GetCurrentOperationPlaybackType();
+            if (isResumable(playbackType)) {
+                retCode = activeInput.value()->audio->Pause();
+            }
+            else {
+                retCode = audio::RetCode::UnsupportedEvent;
+            }
+        }
+        return std::make_unique<AudioResponseMessage>(retCode);
+    }
+    auto Audio::handleResume() -> std::unique_ptr<AudioResponseMessage>
+    {
+        auto retCode = audio::RetCode::InvokedInIncorrectState;
+        if (const auto activeInput = audioMux.GetActiveInput();
+            activeInput && activeInput.value()->audio->GetCurrentOperationState() == audio::Operation::State::Paused) {
+            retCode = activeInput.value()->audio->Resume();
+        }
+        return std::make_unique<AudioResponseMessage>(retCode);
+    }
+    constexpr auto Audio::isResumable(audio::PlaybackType type) const -> bool
+    {
+        return type == audio::PlaybackType::Multimedia;
+    }
+    void Audio::manageCpuSentinel()
+    {
+        isBusy() ? cpuSentinel->HoldMinimumFrequency(bsp::CpuFrequencyHz::Level_6)
+                 : cpuSentinel->ReleaseMinimumFrequency();
+    }
+    void Audio::initializeDatabase()
+    {
+        for (const auto &entry : initializer::values) {
+            const auto path = dbPath(entry.first);
+            if (settingsProvider->getValue(path).empty()) {
+                settingsProvider->setValue(path, entry.second);
+            }
+        }
+    }
+} // namespace service
diff --git a/products/BellHybrid/services/audio/include/audio/AudioMessage.hpp b/products/BellHybrid/services/audio/include/audio/AudioMessage.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0046c53690b451de9de22126ff174f788897b961
--- /dev/null
+++ b/products/BellHybrid/services/audio/include/audio/AudioMessage.hpp
@@ -0,0 +1,141 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Audio/AudioCommon.hpp>
+#include <MessageType.hpp>
+#include <Service/Message.hpp>
+
+#include <memory>
+#include <variant>
+
+namespace service
+{
+    inline constexpr auto audioServiceName = "ServiceAudio";
+
+    class AudioMessage : public sys::DataMessage
+    {
+      public:
+        AudioMessage() : sys::DataMessage(MessageType::AudioMessage)
+        {}
+    };
+
+    class AudioResponseMessage : public sys::ResponseMessage
+    {
+      public:
+        explicit AudioResponseMessage(audio::RetCode retCode = audio::RetCode::Success, const std::string &val = {})
+            : sys::ResponseMessage(), retCode(retCode), val(val)
+        {}
+
+        const audio::RetCode retCode = audio::RetCode::Success;
+        std::string val;
+    };
+
+    class AudioNotificationMessage : public AudioMessage
+    {
+      public:
+        explicit AudioNotificationMessage(audio::Token token) : token{token}
+        {}
+
+        const audio::Token token;
+    };
+
+    class AudioStopNotification : public AudioNotificationMessage
+    {
+      public:
+        explicit AudioStopNotification(audio::Token token) : AudioNotificationMessage{token}
+        {}
+    };
+
+    class AudioEOFNotification : public AudioNotificationMessage
+    {
+      public:
+        explicit AudioEOFNotification(audio::Token token) : AudioNotificationMessage{token}
+        {}
+    };
+
+    class AudioSettingsMessage : public AudioMessage
+    {
+      public:
+        AudioSettingsMessage(const audio::PlaybackType &playbackType, const std::string &val = {})
+            : AudioMessage{}, playbackType{playbackType}, val{val}
+        {}
+
+        audio::PlaybackType playbackType = audio::PlaybackType::None;
+        std::string val{};
+    };
+
+    class AudioGetVolume : public AudioSettingsMessage
+    {
+      public:
+        AudioGetVolume(const audio::PlaybackType &playbackType) : AudioSettingsMessage{playbackType}
+        {}
+    };
+
+    class AudioSetVolume : public AudioSettingsMessage
+    {
+      public:
+        AudioSetVolume(const audio::PlaybackType &playbackType, const std::string &val)
+            : AudioSettingsMessage{playbackType, val}
+        {}
+    };
+
+    class AudioStopRequest : public AudioMessage
+    {
+      public:
+        explicit AudioStopRequest(const std::vector<audio::PlaybackType> &stopVec = {}) : stopVec(stopVec)
+        {}
+
+        explicit AudioStopRequest(const audio::Token &token) : token(token)
+        {}
+
+        const std::vector<audio::PlaybackType> stopVec;
+        const audio::Token token;
+    };
+
+    class AudioStopResponse : public AudioResponseMessage
+    {
+      public:
+        AudioStopResponse(audio::RetCode retCode, const audio::Token &token)
+            : AudioResponseMessage(retCode), token(token)
+        {}
+
+        const audio::Token token;
+    };
+
+    class AudioStartPlaybackRequest : public AudioMessage
+    {
+      public:
+        AudioStartPlaybackRequest(const std::string &fileName, const audio::PlaybackType &playbackType)
+            : AudioMessage(), fileName(fileName), playbackType(playbackType)
+        {}
+
+        const std::string fileName;
+        const audio::PlaybackType playbackType;
+    };
+
+    class AudioStartPlaybackResponse : public AudioResponseMessage
+    {
+      public:
+        AudioStartPlaybackResponse(audio::RetCode retCode, const audio::Token &token)
+            : AudioResponseMessage(retCode), token(token)
+        {}
+
+        const audio::Token token;
+    };
+
+    class AudioPauseRequest : public AudioMessage
+    {
+      public:
+        AudioPauseRequest() : AudioMessage()
+        {}
+    };
+
+    class AudioResumeRequest : public AudioMessage
+    {
+      public:
+        AudioResumeRequest() : AudioMessage()
+        {}
+    };
+} // namespace service
diff --git a/products/BellHybrid/services/audio/include/audio/ServiceAudio.hpp b/products/BellHybrid/services/audio/include/audio/ServiceAudio.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1f31ea46324f5dd6ef861d4b38a70aa18a87d9d
--- /dev/null
+++ b/products/BellHybrid/services/audio/include/audio/ServiceAudio.hpp
@@ -0,0 +1,87 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include "AudioMessage.hpp"
+#include <Audio/Audio.hpp>
+#include <Audio/AudioMux.hpp>
+#include <MessageType.hpp>
+#include <service-db/DBServiceName.hpp>
+#include <Service/Service.hpp>
+#include <SystemManager/CpuSentinel.hpp>
+
+#include <functional>
+
+namespace settings
+{
+    class Settings;
+}
+
+namespace service
+{
+    class Audio : public sys::Service
+    {
+      public:
+        Audio();
+
+        sys::MessagePointer DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp = nullptr) final;
+        sys::ReturnCodes InitHandler() final;
+        sys::ReturnCodes DeinitHandler() final;
+        sys::ReturnCodes SwitchPowerModeHandler(const sys::ServicePowerMode mode) final;
+        void ProcessCloseReason(sys::CloseReason closeReason) final;
+
+      private:
+        enum class StopReason
+        {
+            Eof,
+            Other
+        };
+
+        auto handleStart(audio::Operation::Type opType,
+                         const std::string &fileName             = {},
+                         const audio::PlaybackType &playbackType = audio::PlaybackType::None)
+            -> std::unique_ptr<AudioResponseMessage>;
+        auto handleStop(const std::vector<audio::PlaybackType> &stopTypes, const audio::Token &token)
+            -> std::unique_ptr<AudioResponseMessage>;
+
+        auto handleSetVolume(const audio::PlaybackType &playbackType, const std::string &value)
+            -> std::unique_ptr<AudioResponseMessage>;
+        auto handleGetVolume(const audio::PlaybackType &playbackType) -> std::unique_ptr<AudioResponseMessage>;
+
+        auto handlePause() -> std::unique_ptr<AudioResponseMessage>;
+        auto handleResume() -> std::unique_ptr<AudioResponseMessage>;
+
+        void handleEOF(const audio::Token &token);
+
+        auto AudioServicesCallback(const sys::Message *msg) -> std::optional<std::string>;
+
+        auto stopInput(audio::AudioMux::Input *input, StopReason stopReason = StopReason::Other) -> audio::RetCode;
+
+        constexpr auto shouldLoop(const std::optional<audio::PlaybackType> &type) const -> bool;
+        constexpr auto isResumable(audio::PlaybackType type) const -> bool;
+        auto isBusy() const -> bool;
+
+        void manageCpuSentinel();
+        void initializeDatabase();
+
+        mutable audio::AudioMux audioMux;
+        std::shared_ptr<sys::CpuSentinel> cpuSentinel;
+        std::unique_ptr<settings::Settings> settingsProvider;
+    };
+
+} // namespace service
+
+namespace sys
+{
+    template <> struct ManifestTraits<service::Audio>
+    {
+        static auto GetManifest() -> ServiceManifest
+        {
+            ServiceManifest manifest;
+            manifest.name         = service::audioServiceName;
+            manifest.dependencies = {service::name::db};
+            return manifest;
+        }
+    };
+} // namespace sys
diff --git a/products/BellHybrid/services/db/include/db/SystemSettings.hpp b/products/BellHybrid/services/db/include/db/SystemSettings.hpp
index 4238a4a4e091cdcf65f59ee4f77320a3b09f0d47..e3cfb71e62691c3c4d0f8d6eca4c247ad475d2d6 100644
--- a/products/BellHybrid/services/db/include/db/SystemSettings.hpp
+++ b/products/BellHybrid/services/db/include/db/SystemSettings.hpp
@@ -15,19 +15,16 @@ namespace bell::settings
         constexpr inline auto length   = "snooze_length";
         constexpr inline auto interval = "snooze_interval";
         constexpr inline auto tone     = "snooze_tone";
-        constexpr inline auto volume   = "snooze_volume";
     } // namespace Snooze
     namespace PrewakeUp
     {
         constexpr inline auto duration      = "prewake_up_duration";
         constexpr inline auto tone          = "prewake_up_tone";
-        constexpr inline auto volume        = "prewake_up_volume";
         constexpr inline auto lightDuration = "prewake_up_light_duration";
     } // namespace PrewakeUp
     namespace Alarm
     {
         constexpr inline auto tone        = "alarm_tone";
-        constexpr inline auto volume      = "alarm_volume";
         constexpr inline auto lightActive = "alarm_light_active";
         constexpr inline auto duration    = "alarm_duration";
     } // namespace Alarm
@@ -36,7 +33,6 @@ namespace bell::settings
         constexpr inline auto active   = "bedtime_active";
         constexpr inline auto time     = "bedtime_time";
         constexpr inline auto tone     = "bedtime_tone";
-        constexpr inline auto volume   = "bedtime_volume";
         constexpr inline auto duration = "bedtime_duration";
     } // namespace Bedtime
 };    // namespace bell::settings
diff --git a/products/BellHybrid/services/evtmgr/WorkerEvent.cpp b/products/BellHybrid/services/evtmgr/WorkerEvent.cpp
index 2a8039032b830d8ffc88c58a568949631c5bec85..94bfa01ebd52518c246c46b6b8d52636220594d8 100644
--- a/products/BellHybrid/services/evtmgr/WorkerEvent.cpp
+++ b/products/BellHybrid/services/evtmgr/WorkerEvent.cpp
@@ -4,7 +4,6 @@
 #include "WorkerEvent.hpp"
 
 #include <bsp/eink_frontlight/eink_frontlight.hpp>
-#include <service-audio/AudioMessage.hpp>
 #include <service-evtmgr/EVMessages.hpp>
 
 namespace bell