Add IAudioEngine interface with volume methods

Author: adazem009

src/audio/CMakeLists.txt

@@ -15,6 +15,7 @@ endif()
 
 target_sources(scratchcpp-audio
   PUBLIC
+    iaudioengine.h
     iaudioplayer.h
     iaudiooutput.h
     audiooutput.cpp
@@ -38,6 +39,8 @@ if (LIBSCRATCHCPP_AUDIO_SUPPORT)
 else()
     target_sources(scratchcpp-audio
       PUBLIC
+        internal/audioenginestub.cpp
+        internal/audioenginestub.h
         internal/audioplayerstub.cpp
         internal/audioplayerstub.h
         internal/audioloudnessstub.cpp

src/audio/iaudioengine.h

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+namespace libscratchcpp
+{
+
+class IAudioEngine
+{
+    public:
+        virtual ~IAudioEngine() { }
+
+        static IAudioEngine *instance();
+
+        virtual float volume() const = 0;
+        virtual void setVolume(float volume) = 0;
+};
+
+} // namespace libscratchcpp

src/audio/internal/audioengine.cpp

@@ -1,19 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <iostream>
+#include <miniaudio.h>
 
 #include "audioengine.h"
 
 using namespace libscratchcpp;
 
 AudioEngine AudioEngine::instance;
 
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngine::instance;
+}
+
 ma_engine *AudioEngine::engine()
 {
     if (!instance.m_initialized)
         instance.init();
 
-    return instance.m_initialized ? &instance.m_engine : nullptr;
+    return instance.m_initialized ? instance.m_engine : nullptr;
 }
 
 bool AudioEngine::initialized()
@@ -24,20 +30,36 @@ bool AudioEngine::initialized()
     return instance.m_initialized;
 }
 
+float AudioEngine::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngine::setVolume(float volume)
+{
+    m_volume = volume;
+
+    if (m_initialized)
+        ma_engine_set_volume(m_engine, volume);
+}
+
 AudioEngine::AudioEngine()
 {
 }
 
 AudioEngine::~AudioEngine()
 {
-    if (m_initialized)
-        ma_engine_uninit(&m_engine);
+    if (m_initialized && m_engine) {
+        ma_engine_uninit(m_engine);
+        delete m_engine;
+    }
 }
 
 void AudioEngine::init()
 {
     ma_result result;
-    result = ma_engine_init(NULL, &m_engine);
+    m_engine = new ma_engine;
+    result = ma_engine_init(NULL, m_engine);
 
     if (result != MA_SUCCESS) {
         std::cerr << "Failed to initialize audio engine." << std::endl;

src/audio/internal/audioengine.h

@@ -3,27 +3,37 @@
 #pragma once
 
 #include <memory>
-#include <miniaudio.h>
+
+#include "../iaudioengine.h"
+
+struct ma_engine;
 
 namespace libscratchcpp
 {
 
 // This is a singleton which initializes and uninitializes the miniaudio engine
-class AudioEngine
+class AudioEngine : public IAudioEngine
 {
     public:
+        friend class IAudioEngine;
+
         static ma_engine *engine();
         static bool initialized();
 
+        float volume() const override;
+        void setVolume(float volume) override;
+
     private:
         AudioEngine();
         ~AudioEngine();
 
         void init();
 
         static AudioEngine instance;
-        ma_engine m_engine;
+
+        ma_engine *m_engine = nullptr;
         bool m_initialized = false;
+        float m_volume = 1.0f;
 };
 
 } // namespace libscratchcpp

src/audio/internal/audioenginestub.cpp

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "audioenginestub.h"
+
+using namespace libscratchcpp;
+
+AudioEngineStub AudioEngineStub::instance;
+
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngineStub::instance;
+}
+
+AudioEngineStub::AudioEngineStub()
+{
+}
+
+float AudioEngineStub::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngineStub::setVolume(float volume)
+{
+    m_volume = volume;
+}

src/audio/internal/audioenginestub.h

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../iaudioengine.h"
+
+namespace libscratchcpp
+{
+
+class AudioEngineStub : public IAudioEngine
+{
+    public:
+        friend class IAudioEngine;
+        AudioEngineStub();
+
+        float volume() const override;
+        void setVolume(float volume) override;
+
+    private:
+        static AudioEngineStub instance;
+        float m_volume = 1.0f;
+};
+
+} // namespace libscratchcpp

src/audio/internal/audioplayer.cpp

@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <cassert>
+#include <miniaudio.h>
 
 #include "audioplayer.h"
 #include "audioengine.h"

test/audio/CMakeLists.txt

@@ -1,3 +1,21 @@
+# audioengine_test
+add_executable(
+  audioengine_test
+  audioengine_test.cpp
+)
+
+target_link_libraries(
+  audioengine_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(audioengine_test)
+
+if (LIBSCRATCHCPP_AUDIO_SUPPORT)
+    target_compile_definitions(audioengine_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
+endif()
+
 # audiooutput_test
 add_executable(
   audiooutput_test

test/audio/audioengine_test.cpp

@@ -0,0 +1,31 @@
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+#include <audio/internal/audioengine.h>
+#else
+#include <audio/internal/audioenginestub.h>
+#endif
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(AudioEngineTest, Instance)
+{
+    IAudioEngine *instance = IAudioEngine::instance();
+    ASSERT_TRUE(instance);
+
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+    ASSERT_TRUE(dynamic_cast<AudioEngine *>(instance));
+#else
+    ASSERT_TRUE(dynamic_cast<AudioEngineStub *>(instance));
+#endif
+}
+
+TEST(AudioEngineTest, Volume)
+{
+    IAudioEngine *engine = IAudioEngine::instance();
+    ASSERT_TRUE(engine);
+    ASSERT_EQ(engine->volume(), 1.0f);
+
+    engine->setVolume(0.86f);
+    ASSERT_EQ(engine->volume(), 0.86f);
+}

test/mocks/audioenginemock.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <audio/iaudioengine.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioEngineMock : public IAudioEngine
+{
+    public:
+        MOCK_METHOD(float, volume, (), (const, override));
+        MOCK_METHOD(void, setVolume, (float), (override));
+};