TizenRefApp-8322 [Call UI] Implement SoundManager

Change-Id: I2f361b7c97f7db02ef4ef685ea33af576a68cfcd

diff --git a/inc/model/ISoundManager.h b/inc/model/ISoundManager.h
index 1b34e51ce53598ba533abb77f22bd2481bf4ab35..1ac209f9453362cd2fb29ff41fda252286926765 100644 (file)
--- a/inc/model/ISoundManager.h
+++ b/inc/model/ISoundManager.h
@@ -22,10 +22,6 @@
 namespace callui {
 
        class ISoundManager: public ucl::Polymorphic {
-       public:
-               using AudioStateHandler = ucl::Delegate<void(AudioStateType)>;
-               using MuteStateHandler = ucl::Delegate<void(bool)>;
-
        public:
                virtual ucl::Result setSpeakerState(bool isEnable) = 0;
                virtual ucl::Result setBluetoothState(bool isEnable) = 0;
@@ -34,10 +30,10 @@ namespace callui {
                virtual bool getMuteState() const = 0;
                virtual ucl::Result startDtmf(const unsigned char dtmfDigit) = 0;
                virtual ucl::Result stopDtmf() = 0;
-               virtual ucl::Result addAudioStateChangeHandler(AudioStateHandler handler) = 0;
-               virtual ucl::Result removeAudioStateChangeHandler(AudioStateHandler handler) = 0;
-               virtual ucl::Result addMuteStateChangeHandler(MuteStateHandler handler) = 0;
-               virtual ucl::Result removeMuteStateChangeHandler(MuteStateHandler handler) = 0;
+               virtual void addAudioStateChangeHandler(AudioStateHandler handler) = 0;
+               virtual void removeAudioStateChangeHandler(AudioStateHandler handler) = 0;
+               virtual void addMuteStateChangeHandler(MuteStateHandler handler) = 0;
+               virtual void removeMuteStateChangeHandler(MuteStateHandler handler) = 0;
        };
 }
 

diff --git a/inc/model/types.h b/inc/model/types.h
index 00c292cd2b8faa7c499852081fff279891dd9d88..437c9593488b2255efe612c6fc7f6832d9de19a1 100644 (file)
--- a/inc/model/types.h
+++ b/inc/model/types.h
@@ -17,9 +17,10 @@
 #ifndef __CALLUI_MODEL_TYPES_H__
 #define __CALLUI_MODEL_TYPES_H__
 
-#include "../types.h"
 #include <list>
 
+#include "../types.h"
+
 namespace callui {
 
        enum class SimSlot {
@@ -109,6 +110,9 @@ namespace callui {
 
        using CallStateHandler = ucl::Delegate<void(CallEventType)>;
 
+       using AudioStateHandler = ucl::Delegate<void(AudioStateType)>;
+       using MuteStateHandler = ucl::Delegate<void(bool)>;
+
        using ConfMemberCallList = std::list<IConferenceCallInfoSCRef>;
 }
 

diff --git a/src/model/CallManager.h b/src/model/CallManager.h
index 02aba127ef07f59e9b6f971c7d29a876a2bbb505..0fe3192d0d6583a954110ac0a5cc8dacf1ec696a 100644 (file)
--- a/src/model/CallManager.h
+++ b/src/model/CallManager.h
@@ -59,7 +59,7 @@ namespace callui {
                HeldCallSRef m_heldCall;
                EndCallSRef m_endCall;
                CallMask m_availableCalls;
-               ucl::Event<CallStateHandler> m_event;
+               CallStateEvent m_event;
        };
 
 }

diff --git a/src/model/SoundManager.cpp b/src/model/SoundManager.cpp
index c2aa1370c0e5eb65e4d57d60c5e2fdc20a008b94..3e1199f17a17ab2595de3025669de5e5b03cf1bb 100644 (file)
--- a/src/model/SoundManager.cpp
+++ b/src/model/SoundManager.cpp
@@ -19,6 +19,7 @@
 #include "CallClient.h"
 
 #include "common.h"
+#include "helpers.h"
 
 namespace callui {
 
@@ -31,6 +32,8 @@ namespace callui {
 
        SoundManager::~SoundManager()
        {
+               cm_unset_audio_state_changed_cb(*m_client);
+               cm_unset_mute_status_cb(*m_client);
        }
 
        SoundManagerSRef SoundManager::newInstance(const CallClientSRef &client)
@@ -40,64 +43,101 @@ namespace callui {
                return result;
        }
 
+       void SoundManager::audioStateChangedCb(cm_audio_state_type_e state)
+       {
+               if (state == CM_AUDIO_STATE_NONE_E) {
+                       ELOG("Unhandled state [%d]", state);
+                       return;
+               }
+
+               m_audioStateEvent.invoke(convertCallManagerAudioState(state));
+       }
+
+       void SoundManager::muteStateChangedCb(cm_mute_status_e status)
+       {
+               m_muteStateEvent.invoke(status == CM_MUTE_STATUS_ON);
+       }
+
        Result SoundManager::prepare()
        {
-               return RES_OK;
+               Result res = convertCallManagerResult(cm_set_audio_state_changed_cb(*m_client, CALLBACK_B(SoundManager::audioStateChangedCb), this));
+               FAIL_RETURN_VALUE(res, res, "cm_set_audio_state_changed_cb() failed!");
+
+               res = convertCallManagerResult(cm_set_mute_status_cb(*m_client, CALLBACK_B(SoundManager::muteStateChangedCb), this));
+               FAIL_RETURN_VALUE(res, res, "__callui_mute_state_changed_cb() failed!");
+
+               return res;
        }
 
        Result SoundManager::setSpeakerState(bool isEnable)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               if (isEnable) {
+                       return convertCallManagerResult(cm_speaker_on(*m_client));
+               } else {
+                       return convertCallManagerResult(cm_speaker_off(*m_client));
+               }
        }
 
        Result SoundManager::setBluetoothState(bool isEnable)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               if (isEnable) {
+                       return convertCallManagerResult(cm_bluetooth_on(*m_client));
+               } else {
+                       return convertCallManagerResult(cm_bluetooth_off(*m_client));
+               }
        }
 
        AudioStateType SoundManager::getAudioState() const
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               cm_audio_state_type_e state = CM_AUDIO_STATE_NONE_E;
+               Result res = convertCallManagerResult(cm_get_audio_state(*m_client, &state));
+               FAIL_RETURN_VALUE(res, AudioStateType::NONE, "cm_get_audio_state() failed!");
+
+               return convertCallManagerAudioState(state);
        }
 
        Result SoundManager::setMuteState(bool isEnable)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               return convertCallManagerResult(cm_set_mute_state(*m_client, isEnable));
        }
 
        bool SoundManager::getMuteState() const
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               cm_mute_status_e status = CM_MUTE_STATUS_MAX;
+               Result res = convertCallManagerResult(cm_get_mute_status(*m_client, &status));
+               FAIL_RETURN_VALUE(res, false, "cm_get_mute_status() failed!");
+
+               return (status == CM_MUTE_STATUS_ON);
        }
 
        Result SoundManager::startDtmf(const unsigned char dtmfDigit)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               return convertCallManagerResult(cm_start_dtmf(*m_client, dtmfDigit));
        }
 
        Result SoundManager::stopDtmf()
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               return convertCallManagerResult(cm_stop_dtmf(*m_client));
        }
 
-       Result SoundManager::addAudioStateChangeHandler(AudioStateHandler handler)
+       void SoundManager::addAudioStateChangeHandler(AudioStateHandler handler)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               m_audioStateEvent += handler;
        }
 
-       Result SoundManager::removeAudioStateChangeHandler(AudioStateHandler handler)
+       void SoundManager::removeAudioStateChangeHandler(AudioStateHandler handler)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               m_audioStateEvent -= handler;
        }
 
-       Result SoundManager::addMuteStateChangeHandler(MuteStateHandler handler)
+       void SoundManager::addMuteStateChangeHandler(MuteStateHandler handler)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               m_muteStateEvent += handler;
        }
 
-       Result SoundManager::removeMuteStateChangeHandler(MuteStateHandler handler)
+       void SoundManager::removeMuteStateChangeHandler(MuteStateHandler handler)
        {
-               UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+               m_muteStateEvent -= handler;
        }
 
 }

diff --git a/src/model/SoundManager.h b/src/model/SoundManager.h
index deed3881e3ce919985df71bef8e22b03bf2c85b4..b0277444aa50395498baed4a370ad02f74653b43 100644 (file)
--- a/src/model/SoundManager.h
+++ b/src/model/SoundManager.h
@@ -17,6 +17,8 @@
 #ifndef __CALLUI_MODEL_SOUND_MANAGER_H__
 #define __CALLUI_MODEL_SOUND_MANAGER_H__
 
+#include <call-manager-ext.h>
+
 #include "model/ISoundManager.h"
 
 #include "implTypes.h"
@@ -28,6 +30,8 @@ namespace callui {
                static SoundManagerSRef newInstance(const CallClientSRef &client);
                virtual ~SoundManager();
 
+               // ISoundManager
+
                virtual ucl::Result setSpeakerState(bool isEnable) override final;
                virtual ucl::Result setBluetoothState(bool isEnable) override final;
                virtual AudioStateType getAudioState() const override final;
@@ -35,18 +39,23 @@ namespace callui {
                virtual bool getMuteState() const override final;
                virtual ucl::Result startDtmf(const unsigned char dtmfDigit) override final;
                virtual ucl::Result stopDtmf() override final;
-               virtual ucl::Result addAudioStateChangeHandler(AudioStateHandler handler) override final;
-               virtual ucl::Result removeAudioStateChangeHandler(AudioStateHandler handler) override final;
-               virtual ucl::Result addMuteStateChangeHandler(MuteStateHandler handler) override final;
-               virtual ucl::Result removeMuteStateChangeHandler(MuteStateHandler handler) override final;
+               virtual void addAudioStateChangeHandler(AudioStateHandler handler) override final;
+               virtual void removeAudioStateChangeHandler(AudioStateHandler handler) override final;
+               virtual void addMuteStateChangeHandler(MuteStateHandler handler) override final;
+               virtual void removeMuteStateChangeHandler(MuteStateHandler handler) override final;
 
        private:
                friend class ucl::RefCountObj<SoundManager>;
                SoundManager(const CallClientSRef &client);
 
                ucl::Result prepare();
+               void audioStateChangedCb(cm_audio_state_type_e state);
+               void muteStateChangedCb(cm_mute_status_e status);
+
        private:
                CallClientSRef m_client;
+               AudioStateEvent m_audioStateEvent;
+               MuteStateEvent m_muteStateEvent;
        };
 
 }

diff --git a/src/model/helpers.h b/src/model/helpers.h
index 409ef74fb93e12fa43e6a018f2d8d84a805e2dcf..522dc476dfe160f7149bc84207abb00be7377672 100644 (file)
--- a/src/model/helpers.h
+++ b/src/model/helpers.h
@@ -17,11 +17,15 @@
 #ifndef __CALLUI_MODEL_HELPERS_H__
 #define __CALLUI_MODEL_HELPERS_H__
 
+#include <call-manager-ext.h>
+
 #include "model/types.h"
 
 namespace callui {
 
        ucl::Result convertCallManagerResult(int cmRes);
+
+       AudioStateType convertCallManagerAudioState(cm_audio_state_type_e state);
 }
 
 #include "helpers.hpp"

diff --git a/src/model/helpers.hpp b/src/model/helpers.hpp
index 040b63c8c763767d4750834202ad917529509837..43a9784160538afc3cb7c989117780b38bd7c97f 100644 (file)
--- a/src/model/helpers.hpp
+++ b/src/model/helpers.hpp
@@ -33,4 +33,17 @@ namespace callui {
                        return ucl::RES_FALSE;
                }
        }
+
+       inline AudioStateType convertCallManagerAudioState(cm_audio_state_type_e state)
+       {
+               switch (state) {
+               case CM_AUDIO_STATE_NONE_E:      return AudioStateType::NONE;
+               case CM_AUDIO_STATE_SPEAKER_E:   return AudioStateType::SPEAKER;
+               case CM_AUDIO_STATE_RECEIVER_E:  return AudioStateType::RECEIVER;
+               case CM_AUDIO_STATE_EARJACK_E:   return AudioStateType::EARJACK;
+               case CM_AUDIO_STATE_BT_E:        return AudioStateType::BT;
+               default:
+                       return AudioStateType::NONE;
+               }
+       }
 }

diff --git a/src/model/implTypes.h b/src/model/implTypes.h
index 213ebb497885e19e6bd95e875b6ae689b7be4ddd..ee8bae0548dfeac58af2dc8fc0ef979591d9882b 100644 (file)
--- a/src/model/implTypes.h
+++ b/src/model/implTypes.h
@@ -17,7 +17,8 @@
 #ifndef __CALLUI_MODEL_IMPL_TYPES_H__
 #define __CALLUI_MODEL_IMPL_TYPES_H__
 
-#include "ucl/util/memory.h"
+#include "model/types.h"
+#include "ucl/misc/Event.h"
 
 namespace callui {
 
@@ -36,6 +37,9 @@ namespace callui {
        UCL_DECLARE_REF_ALIASES(ContactInfo);
        UCL_DECLARE_REF_ALIASES(ConferenceCallInfo);
 
+       using CallStateEvent = ucl::Event<CallStateHandler>;
+       using AudioStateEvent = ucl::Event<AudioStateHandler>;
+       using MuteStateEvent = ucl::Event<MuteStateHandler>;
 }
 
 #endif // __CALLUI_MODEL_IMPL_TYPES_H__