X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fcpp%2FCAudioIO.cpp;h=1afcac271fef5f8c3c9cd377f0fc60b3d7d22b53;hb=2590cfd1e97b814139d65ef85c8c3779b6763150;hp=94bed765e1789f7a38435cb4704b1dfc91d7ee3b;hpb=5cfe54834f37db8a96a502b6191252534fc537b4;p=platform%2Fcore%2Fapi%2Faudio-io.git diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp index 94bed76..1afcac2 100644 --- a/src/cpp/CAudioIO.cpp +++ b/src/cpp/CAudioIO.cpp @@ -18,11 +18,8 @@ #include #include #include -#include #include "CAudioIODef.h" -#define AUDIO_IO_DEBUG - using namespace std; using namespace tizen_media_audio; @@ -30,16 +27,28 @@ using namespace tizen_media_audio; /** * class CAudioIO */ -CAudioIO::CAudioIO() : mIsInit(false), mForceIgnore(false), mpAudioSessionHandler(NULL), mpPulseAudioClient(NULL) { - mState = CAudioInfo::AUDIO_IO_STATE_NONE; - mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE; +CAudioIO::CAudioIO() : + mpAudioSessionHandler(NULL), + mpPulseAudioClient(NULL), + __mMutex(PTHREAD_MUTEX_INITIALIZER), + __mCond(PTHREAD_COND_INITIALIZER), + __mIsInit(false), + __mForceIgnore(false) { + mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE; + mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE; mByPolicy = false; } -CAudioIO::CAudioIO(CAudioInfo& audioInfo) : mIsInit(false), mForceIgnore(false), mpAudioSessionHandler(NULL), mpPulseAudioClient(NULL) { +CAudioIO::CAudioIO(CAudioInfo& audioInfo) : + mpAudioSessionHandler(NULL), + mpPulseAudioClient(NULL), + __mMutex(PTHREAD_MUTEX_INITIALIZER), + __mCond(PTHREAD_COND_INITIALIZER), + __mIsInit(false), + __mForceIgnore(false) { mAudioInfo = audioInfo; - mState = CAudioInfo::AUDIO_IO_STATE_NONE; - mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE; + mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE; + mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE; mByPolicy = false; } @@ -47,130 +56,140 @@ CAudioIO::~CAudioIO() { } void CAudioIO::setInit(bool flag) { - mIsInit = flag; + __mIsInit = flag; } bool CAudioIO::isInit() { - return mIsInit; + return __mIsInit; } bool CAudioIO::IsReady() { - return ((mState == CAudioInfo::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::AUDIO_IO_STATE_PAUSED)? true : false); + return ((mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED)? true : false); } -void CAudioIO::internalLock() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::internalLock() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - if (pthread_mutex_lock(&mMutex) != 0) { - THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); + if (pthread_mutex_lock(&__mMutex) != 0) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD(COLOR_RED"LOCK"COLOR_END); + AUDIO_IO_LOGD(COLOR_RED "LOCK" COLOR_END); #endif } -void CAudioIO::internalUnlock() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::internalUnlock() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - if (pthread_mutex_unlock(&mMutex) != 0) { - THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); + if (pthread_mutex_unlock(&__mMutex) != 0) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD(COLOR_GREEN"UNLOCK"COLOR_END); + AUDIO_IO_LOGD(COLOR_GREEN "UNLOCK" COLOR_END); #endif } -void CAudioIO::internalWait() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::internalWait() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD(COLOR_RED"WAIT"COLOR_END); + AUDIO_IO_LOGD(COLOR_RED "WAIT" COLOR_END); #endif - pthread_cond_wait(&mCond, &mMutex); + pthread_cond_wait(&__mCond, &__mMutex); } -void CAudioIO::internalSignal() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::internalSignal() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD(COLOR_GREEN"SIGNAL"COLOR_END); + AUDIO_IO_LOGD(COLOR_GREEN "SIGNAL" COLOR_END); #endif - pthread_cond_signal(&mCond); + pthread_cond_signal(&__mCond); } bool CAudioIO::isForceIgnore() { - return mForceIgnore; + return __mForceIgnore; } -void CAudioIO::initialize() throw (CAudioError) { - if (mIsInit == true) { +void CAudioIO::initialize() throw(CAudioError) { + if (__mIsInit == true) { return; } AUDIO_IO_LOGD("initialize"); - int ret = pthread_mutex_init(&mMutex, NULL); + int ret = pthread_mutex_init(&__mMutex, NULL); if (ret != 0) { - THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()"); + THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()"); } - ret = pthread_cond_init(&mCond, NULL); + ret = pthread_cond_init(&__mCond, NULL); if (ret != 0) { - THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()"); + THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()"); } - mIsInit = true; + __mIsInit = true; } void CAudioIO::finalize() { - if (mIsInit == false) { + if (__mIsInit == false) { return; } AUDIO_IO_LOGD("finalize"); - int ret = pthread_mutex_destroy(&mMutex); + int ret = pthread_mutex_destroy(&__mMutex); if (ret != 0) { - THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_destroy() ret:%d", ret); + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_destroy() ret:%d", ret); } - ret = pthread_cond_destroy(&mCond); + ret = pthread_cond_destroy(&__mCond); if (ret != 0) { - THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_destroy() ret:%d", ret); + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_destroy() ret:%d", ret); } - mIsInit = false; + __mIsInit = false; } void CAudioIO::onStream(CPulseAudioClient* pClient, size_t length) { - assert(mIsInit == true); + assert(__mIsInit == true); assert(pClient != NULL); assert(length > 0); +#ifdef _AUDIO_IO_DEBUG_TIMING_ + AUDIO_IO_LOGD("mStreamCallback.onStream(%p), pClient(%p), length(%zu)", mStreamCallback.onStream, pClient, length); +#endif + if (mStreamCallback.onStream != NULL) { mStreamCallback.onStream(length, mStreamCallback.mUserData); } } void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy) { - assert(mIsInit == true); - assert(state > 0); + assert(__mIsInit == true); + assert(state >= CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE && state < CAudioInfo::EAudioIOState::AUDIO_IO_STATE_MAX); mStatePrev = mState; mState = state; mByPolicy = byPolicy; - AUDIO_IO_LOGD("current(%d), previous(%d), by_policy(%d)", mState, mStatePrev, mByPolicy); + if (mState == mStatePrev) + return; + + const char* state_string[] = { "NONE", "IDLE", "RUNNING", "PAUSED" }; + + AUDIO_IO_LOGD("previous(%s,%d) ===> current(%s,%d), by_policy(%d)", + state_string[(int)mStatePrev], mStatePrev, state_string[(int)mState], mState, mByPolicy); if (mStateChangedCallback.onStateChanged != NULL) { mStateChangedCallback.onStateChanged(mState, mStatePrev, mByPolicy, mStateChangedCallback.mUserData); @@ -181,6 +200,10 @@ void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state) { onStateChanged(state, false); } +CAudioInfo::EAudioIOState CAudioIO::getState() { + return mState; +} + void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info) { assert(pHandler); @@ -191,7 +214,7 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu // Triggered by 'focus watch callback' /////////////////////////////////////// - if (session_option & (ASM_SESSION_OPTION_PAUSE_OTHERS | ASM_SESSION_OPTION_UNINTERRUPTIBLE)) { + if (session_option & (MM_SESSION_OPTION_PAUSE_OTHERS | MM_SESSION_OPTION_UNINTERRUPTIBLE)) { AUDIO_IO_LOGD("Session option is pausing others or uninterruptible, skip..."); return; } @@ -201,7 +224,7 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu internalLock(); mpPulseAudioClient->cork(false); - onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING); + onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING); internalUnlock(); @@ -210,14 +233,15 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu } else if (state == FOCUS_IS_ACQUIRED) { // Focus handle(id) of the other application was acquired, do pause if possible internalLock(); - if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::STREAM_DIRECTION_PLAYBACK) { + + if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK) { if (mpPulseAudioClient->drain() == false) { AUDIO_IO_LOGE("Failed CPulseAudioClient::drain()"); } } mpPulseAudioClient->cork(true); - onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED); + onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED); internalUnlock(); @@ -233,7 +257,7 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu AUDIO_IO_LOGW("Id is different, why? [mId : %d]", pHandler->getId()); } - if (session_option & ASM_SESSION_OPTION_UNINTERRUPTIBLE) { + if (session_option & MM_SESSION_OPTION_UNINTERRUPTIBLE) { AUDIO_IO_LOGD("Session option is uninterruptible, skip..."); return; } @@ -241,14 +265,15 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu if (state == FOCUS_IS_RELEASED) { // Focus handle(id) was released, do pause here internalLock(); - if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::STREAM_DIRECTION_PLAYBACK) { + + if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK) { if (mpPulseAudioClient->drain() == false) { AUDIO_IO_LOGE("Failed CPulseAudioClient::drain()"); } } mpPulseAudioClient->cork(true); - onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED); + onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED); internalUnlock(); } else if (state == FOCUS_IS_ACQUIRED) { @@ -258,14 +283,14 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu internalLock(); mpPulseAudioClient->cork(false); - onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING); + onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING); internalUnlock(); } } if (mInterruptCallback.onInterrupt != NULL) { - IAudioSessionEventListener::EInterruptCode e = IAudioSessionEventListener::INTERRUPT_COMPLETED; + IAudioSessionEventListener::EInterruptCode e = IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED; e = IAudioSessionEventListener::convertInterruptedCode(state, reason_for_change); mInterruptCallback.onInterrupt(e, mInterruptCallback.mUserData); } @@ -275,7 +300,7 @@ void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t s assert(pHandler); if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) { - if (value == 1 && pHandler->getSubscribeId() >= 0) { + if (value == 1 && pHandler->getSubscribeId() > 0) { // Unregister focus watch callback & disable session handler pHandler->disableSessionHandler(); AUDIO_IO_LOGD("Session handler disabled by signal"); @@ -285,41 +310,35 @@ void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t s } } -void CAudioIO::prepare() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::prepare() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } try { - internalLock(); - AUDIO_IO_LOGD("prepare"); + AUDIO_IO_LOGD("------> prepare done"); /* Do nothing */ - internalUnlock(); } catch (CAudioError e) { - internalUnlock(); throw e; } } -void CAudioIO::unprepare() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::unprepare() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } try { - internalLock(); - AUDIO_IO_LOGD("unprepare"); + AUDIO_IO_LOGD("unprepare ----->"); /* Do nothing */ - internalUnlock(); } catch (CAudioError e) { - internalUnlock(); throw e; } } -void CAudioIO::pause() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); +void CAudioIO::pause() throw(CAudioError) { + if (__mIsInit == false || IsReady() == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } try { @@ -333,9 +352,9 @@ void CAudioIO::pause() throw (CAudioError) { } } -void CAudioIO::resume() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); +void CAudioIO::resume() throw(CAudioError) { + if (__mIsInit == false || IsReady() == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } try { @@ -349,121 +368,125 @@ void CAudioIO::resume() throw (CAudioError) { } } -void CAudioIO::drain() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); +void CAudioIO::drain() throw(CAudioError) { + if (__mIsInit == false || IsReady() == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } try { - internalLock(); - AUDIO_IO_LOGD("drain"); - mpPulseAudioClient->drain(); - internalUnlock(); + if (mpPulseAudioClient->isInThread()) { + mpPulseAudioClient->drain(); + } else { + internalLock(); + mpPulseAudioClient->drain(); + internalUnlock(); + } } catch (CAudioError e) { - internalUnlock(); + if (!mpPulseAudioClient->isInThread()) { + internalUnlock(); + } throw e; } } -void CAudioIO::flush() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); +void CAudioIO::flush() throw(CAudioError) { + if (__mIsInit == false || IsReady() == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } try { - internalLock(); - AUDIO_IO_LOGD("flush"); - mpPulseAudioClient->flush(); - internalUnlock(); + if (mpPulseAudioClient->isInThread()) { + mpPulseAudioClient->flush(); + } else { + internalLock(); + mpPulseAudioClient->flush(); + internalUnlock(); + } } catch (CAudioError e) { - internalUnlock(); + if (!mpPulseAudioClient->isInThread()) { + internalUnlock(); + } throw e; } } -CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +CAudioInfo& CAudioIO::getAudioInfo() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } return mAudioInfo; } -void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::setStreamCallback(SStreamCallback callback) throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - internalLock(); mStreamCallback = callback; - internalUnlock(); } -CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } return mStreamCallback; } -void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - internalLock(); mStateChangedCallback = callback; - internalUnlock(); } -CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } return mStateChangedCallback; } -void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } mInterruptCallback = callback; } -CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); +CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw(CAudioError) { + if (__mIsInit == false) { + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } return mInterruptCallback; } -void CAudioIO::ignoreSession() throw (CAudioError) { - if (mIsInit == false) { - THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); - } - - internalLock(); +void CAudioIO::ignoreSession() throw(CAudioError) { + if (__mIsInit == false) + THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); try { - if (mpPulseAudioClient != NULL && mpPulseAudioClient->isCorked() == false) { - THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "An Operation is not permitted while started"); - } + internalLock(); + + if (mpPulseAudioClient != NULL && mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) + THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "An Operation is not permitted while started"); bool isSkip = mpAudioSessionHandler->isSkipSessionEvent(); - if (isSkip == false && mpAudioSessionHandler->getId() >= 0) { + if (isSkip == false && mpAudioSessionHandler->getId() >= 0) mpAudioSessionHandler->unregisterSound(); - mForceIgnore = true; - } + + mpAudioSessionHandler->finalize(); + __mForceIgnore = true; + + internalUnlock(); } catch (CAudioError e) { internalUnlock(); - throw e; } - - internalUnlock(); }