From 9223539a32166e25638d94f47e525424631c7326 Mon Sep 17 00:00:00 2001 From: Igor Olshevskyi Date: Tue, 4 Apr 2017 08:46:59 +0300 Subject: [PATCH] TizenRefApp-8322 [Call UI] Implement SoundManager Change-Id: I2f361b7c97f7db02ef4ef685ea33af576a68cfcd --- inc/model/ISoundManager.h | 12 +++---- inc/model/types.h | 6 +++- src/model/CallManager.h | 2 +- src/model/SoundManager.cpp | 72 +++++++++++++++++++++++++++++--------- src/model/SoundManager.h | 17 ++++++--- src/model/helpers.h | 4 +++ src/model/helpers.hpp | 13 +++++++ src/model/implTypes.h | 6 +++- 8 files changed, 101 insertions(+), 31 deletions(-) diff --git a/inc/model/ISoundManager.h b/inc/model/ISoundManager.h index 1b34e51..1ac209f 100644 --- 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; - using MuteStateHandler = ucl::Delegate; - 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 00c292c..437c959 100644 --- 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 +#include "../types.h" + namespace callui { enum class SimSlot { @@ -109,6 +110,9 @@ namespace callui { using CallStateHandler = ucl::Delegate; + using AudioStateHandler = ucl::Delegate; + using MuteStateHandler = ucl::Delegate; + using ConfMemberCallList = std::list; } diff --git a/src/model/CallManager.h b/src/model/CallManager.h index 02aba12..0fe3192 100644 --- 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 m_event; + CallStateEvent m_event; }; } diff --git a/src/model/SoundManager.cpp b/src/model/SoundManager.cpp index c2aa137..3e1199f 100644 --- 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 deed388..b027744 100644 --- 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 + #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(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 409ef74..522dc47 100644 --- 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 + #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 040b63c..43a9784 100644 --- 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 213ebb4..ee8bae0 100644 --- 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; + using AudioStateEvent = ucl::Event; + using MuteStateEvent = ucl::Event; } #endif // __CALLUI_MODEL_IMPL_TYPES_H__ -- 2.34.1