MockupAudioManager up and tested

asrob-uc3m · Mar 30, 2015 · 807cb9d · 807cb9d
1 parent 2f5d3ff
commit 807cb9d
Show file tree

Hide file tree

Showing 3 changed files with 140 additions and 19 deletions.
diff --git a/src/libraries/MusicLib/MockupAudioManager.cpp b/src/libraries/MusicLib/MockupAudioManager.cpp
@@ -5,39 +5,141 @@ rd::MockupAudioManager * rd::MockupAudioManager::uniqueInstance = NULL;
 const std::string rd::MockupAudioManager::id = "MOCKUP";
 
 
-rd::MockupAudioManager::MockupAudioManager()
+rd::MockupAudioManager::MockupAudioManager() : yarp::os::RateThread(UPDATE_PERIOD)
 {
 }
 
+void rd::MockupAudioManager::run()
+{
+    durations_mutex.lock();
+    loop_times_mutex.lock();
+
+    for( std::map<std::string, int>::const_iterator it = durations.begin(); it != durations.end(); ++it)
+    {
+       if (it->second == 0)
+       {
+           std::string id = it->first;
+           if (loop_times[id] == -1)
+           {
+               durations[id] = AUDIO_DURATION;
+           }
+           else if (loop_times[id] > 0)
+           {
+               durations[id] = AUDIO_DURATION;
+               loop_times[id]--;
+           }
+       }
+       else if (it->second > 0)
+       {
+          durations[id]--;
+       }
+    }
+
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+}
+
 
 bool rd::MockupAudioManager::isPlaying(const std::string &id)
 {
-    return false;
+    bool playing = false;
+
+    durations_mutex.lock();
+    loop_times_mutex.lock();
+
+    if (durations.find(id) == durations.end() || loop_times.find(id) == loop_times.end())
+    {
+        RD_ERROR("Sound \"%s\" not found (maybe it was not loaded?)\n", id.c_str());
+        durations_mutex.unlock();
+        loop_times_mutex.unlock();
+        return false;
+    }
+
+    if (loop_times[id] != 0 || durations[id] > 0)
+    {
+        playing = true;
+    }
+
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+
+    return playing;
 }
 
 bool rd::MockupAudioManager::load(const std::string &music_filepath, const std::string &id, const int &type)
 {
-    return false;
+    durations_mutex.lock();
+    loop_times_mutex.lock();
+
+    if (durations.find(id) != durations.end() || loop_times.find(id) != loop_times.end())
+    {
+        RD_ERROR("Sound \"%s\" already exists\n", id.c_str());
+        durations_mutex.unlock();
+        loop_times_mutex.unlock();
+        return false;
+    }
+
+    durations[id] = 0;
+    loop_times[id] = 0;
+
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+
+    return true;
 }
 
 bool rd::MockupAudioManager::play(const std::string &id, int loop)
 {
-    return false;
+    durations_mutex.lock();
+    loop_times_mutex.lock();
+
+    if (durations.find(id) == durations.end() || loop_times.find(id) == loop_times.end())
+    {
+        RD_ERROR("Sound \"%s\" not found (maybe it was not loaded?)\n", id.c_str());
+        durations_mutex.unlock();
+        loop_times_mutex.unlock();
+        return false;
+    }
+
+    durations[id] = AUDIO_DURATION;
+    loop_times[id] = loop;
+
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+
+    return true;
 }
 
 bool rd::MockupAudioManager::stopMusic()
 {
+    durations_mutex.lock();
+    loop_times_mutex.lock();
+
+    for( std::map<std::string, int>::const_iterator it = durations.begin(); it != durations.end(); ++it)
+    {
+        std::string id = it->first;
+
+        durations[id] = 0;
+        loop_times[id]= 0;
+    }
+
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+
     return false;
 }
 
 bool rd::MockupAudioManager::start()
 {
-    return false;
+    return yarp::os::RateThread::start();
 }
 
 bool rd::MockupAudioManager::stop()
 {
-    return false;
+    durations_mutex.unlock();
+    loop_times_mutex.unlock();
+    yarp::os::RateThread::askToStop();
+    return true;
 }
 
 bool rd::MockupAudioManager::RegisterManager()

diff --git a/src/libraries/MusicLib/MockupAudioManager.hpp b/src/libraries/MusicLib/MockupAudioManager.hpp
@@ -8,6 +8,9 @@
 #include "RdMacros.hpp"
 #include "AudioManager.hpp"
 
+#include <yarp/os/RateThread.h>
+#include <yarp/os/Mutex.h>
+
 namespace rd{
 
 /**
@@ -16,7 +19,8 @@ namespace rd{
  * @brief Mockup music and sound effects manager for testing purposes
  *
  */
-class MockupAudioManager : public AudioManager
+class MockupAudioManager : public AudioManager,
+                           public yarp::os::RateThread
 {
     public:
         //---------------- Mockup interface -------------------------------------------------------------------------//
@@ -49,10 +53,14 @@ class MockupAudioManager : public AudioManager
         //! @brief Destructor. Used to reset the local static reference after destroying this manager
         ~MockupAudioManager();
 
-
         //! @brief String that identifies this manager
         static const std::string id;
 
+        //! @brief Default duration (s)
+        static const int AUDIO_DURATION = 30;
+
+        //! @brief Thread update period (ms)
+        static const int UPDATE_PERIOD = 1000;
 
     private:
         /**
@@ -63,14 +71,19 @@ class MockupAudioManager : public AudioManager
          */
         MockupAudioManager();
 
+        //! @brief Method called periodically from the RateThread class. It simply calls the update() method.
+        void run();
+
         //! \brief Stores the unique instance of the RdAudioManager
         static MockupAudioManager * uniqueInstance;
 
-        //! \brief Dictionary for the sound effects
-        std::map<std::string, bool> fx_sounds;
+        //! \brief Dictionary for sound durations:
+        yarp::os::Mutex durations_mutex;
+        std::map<std::string, int> durations;
 
-        //! \brief Dictionary for the music tracks
-        std::map<std::string, bool> music_sounds;
+        //! \brief Dictionary for loop times
+        yarp::os::Mutex loop_times_mutex;
+        std::map<std::string, int> loop_times;
 
 };
 

diff --git a/test/testMockupAudioManager.cpp b/test/testMockupAudioManager.cpp
@@ -3,6 +3,8 @@
 
 #include "MockupAudioManager.hpp"
 
+#include <yarp/os/Time.h>
+
 using namespace rd;
 
 class MockupAudioManagerTest : public testing::Test
@@ -60,12 +62,14 @@ TEST_F( MockupAudioManagerTest, AudioManagerPlaysOneSound )
     ASSERT_NE((AudioManager *)NULL, audioManager);
 
     ASSERT_TRUE(audioManager->load(sound_bso, "bso", AudioManager::MUSIC));
+    ASSERT_TRUE(audioManager->start());
 
     EXPECT_TRUE(audioManager->play("bso", true));
     EXPECT_TRUE(mockupManager->isPlaying("bso"));
-    sleep(2);
+    yarp::os::Time::delay(2);
     EXPECT_TRUE(audioManager->stopMusic());
     EXPECT_FALSE(mockupManager->isPlaying("bso"));
+    EXPECT_TRUE(audioManager->stop());
 }
 
 TEST_F( MockupAudioManagerTest, AudioManagerPlaysFx )
@@ -74,11 +78,13 @@ TEST_F( MockupAudioManagerTest, AudioManagerPlaysFx )
 
     ASSERT_TRUE(audioManager->load(sound_shoot, "shoot", AudioManager::FX));
     ASSERT_TRUE(audioManager->load(sound_explosion, "explosion", AudioManager::FX));
+    ASSERT_TRUE(audioManager->start());
 
     EXPECT_TRUE(audioManager->play("shoot", false));
-    sleep(1);
+    yarp::os::Time::delay(1);
     EXPECT_TRUE(audioManager->play("explosion", false));
-    sleep(2);
+    yarp::os::Time::delay(2);
+    EXPECT_TRUE(audioManager->stop());
 }
 
 TEST_F( MockupAudioManagerTest, AudioManagerPlaysAllSounds )
@@ -88,20 +94,20 @@ TEST_F( MockupAudioManagerTest, AudioManagerPlaysAllSounds )
     ASSERT_TRUE(audioManager->load(sound_bso, "bso", AudioManager::MUSIC));
     ASSERT_TRUE(audioManager->load(sound_shoot, "shoot", AudioManager::FX));
     ASSERT_TRUE(audioManager->load(sound_explosion, "explosion", AudioManager::FX));
+    ASSERT_TRUE(audioManager->start());
 
     EXPECT_TRUE(audioManager->play("bso", true));
     EXPECT_TRUE(audioManager->play("shoot", true));
     EXPECT_TRUE(mockupManager->isPlaying("bso"));
     EXPECT_TRUE(mockupManager->isPlaying("shoot"));
-    sleep(1);
-
+    yarp::os::Time::delay(1);
     EXPECT_TRUE(audioManager->play("explosion", false));
     EXPECT_TRUE(mockupManager->isPlaying("explosion"));
-    sleep(4);
+    yarp::os::Time::delay(4);
 
     EXPECT_TRUE(audioManager->stopMusic());
     EXPECT_FALSE(mockupManager->isPlaying("bso"));
     EXPECT_FALSE(mockupManager->isPlaying("shoot"));
     EXPECT_FALSE(mockupManager->isPlaying("explosion"));
-
+    EXPECT_TRUE(audioManager->stop());
 }