#include <mm.h>
#include <pthread.h>
#include <assert.h>
-#include <audio-session-manager.h>
#include "CAudioIODef.h"
-#define AUDIO_IO_DEBUG
-
using namespace std;
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;
}
}
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);
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);
// 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;
}
internalLock();
mpPulseAudioClient->cork(false);
- onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
internalUnlock();
} 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();
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;
}
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) {
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);
}
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");
}
}
-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 {
}
}
-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 {
}
}
-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();
}
projects / platform / core / api / audio-io.git / blobdiff