Add mutex for internal focus cb

[Version] 0.3.80
[Issue Type] Enhancement

Change-Id: Ic2bda1f6915738ae6228fa6b22aa74c1beefa852
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/include/CAudioSessionHandler.h b/include/CAudioSessionHandler.h
index 1d151e6..363714e 100644 (file)
--- a/include/CAudioSessionHandler.h
+++ b/include/CAudioSessionHandler.h
@@ -20,7 +20,7 @@
 
 #ifdef __cplusplus
 
-
+#include <pthread.h>
 #include <mm_session.h>
 #include <mm_session_private.h>
 #include <mm_sound.h>
@@ -116,6 +116,8 @@ namespace tizen_media_audio {
         CAudioError __getAsmInformation(MMSessionType *type, int *options);
         bool __isFocusRequired(MMSessionType type, int options);
         bool __isFocusDisableReacquisitionRequired(MMSessionType type, int options);
+        void __lockFocusCBMutex();
+        void __unlockFocusCBMutex();
 
         /* Static Member */
         static int                  __sCaptureRef;
@@ -139,6 +141,8 @@ namespace tizen_media_audio {
         int                         __mAcquiredFocus;    /* For audio focus */
         char*                       __mReasonForChange;  /* For audio focus */
         char*                       __mAdditionalInfo;   /* For audio focus */
+
+        pthread_mutex_t             __mFocusCBMutex;
     };
 
 

diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index e5412e8..ef8818c 100644 (file)
--- a/packaging/capi-media-audio-io.spec
+++ b/packaging/capi-media-audio-io.spec
@@ -1,6 +1,6 @@
 Name:           capi-media-audio-io
 Summary:        An Audio Input & Audio Output library in Tizen Native API
-Version:        0.3.79
+Version:        0.3.80
 Release:        0
 Group:          Multimedia/API
 License:        Apache-2.0

diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp
index 27699fa..51f9a4b 100644 (file)
--- a/src/cpp/CAudioSessionHandler.cpp
+++ b/src/cpp/CAudioSessionHandler.cpp
@@ -81,6 +81,24 @@ int CAudioSessionHandler::__focusIdCountGet() {
     return __sFocusRef;
 }
 
+void CAudioSessionHandler::__lockFocusCBMutex() {
+    if (pthread_mutex_lock(&__mFocusCBMutex) != 0) {
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
+    }
+#ifdef _AUDIO_IO_DEBUG_TIMING_
+    AUDIO_IO_LOGD(COLOR_RED "LOCK - FocusCB Mutex" COLOR_END);
+#endif
+}
+
+void CAudioSessionHandler::__unlockFocusCBMutex() {
+    if (pthread_mutex_unlock(&__mFocusCBMutex) != 0) {
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_unlock()");
+    }
+#ifdef _AUDIO_IO_DEBUG_TIMING_
+    AUDIO_IO_LOGD(COLOR_GREEN "UNLOCK - FocusCB Mutex" COLOR_END);
+#endif
+}
+
 CAudioSessionHandler::CAudioSessionHandler(EAudioSessionType sessionType, CAudioInfo& audioInfo, IAudioSessionEventListener* listener) :
     __mId(-1),
     __mOptions(0),
@@ -92,7 +110,8 @@ CAudioSessionHandler::CAudioSessionHandler(EAudioSessionType sessionType, CAudio
     __mUseFocus(false),
     __mAcquiredFocus(FOCUS_NONE),
     __mReasonForChange(NULL),
-    __mAdditionalInfo(NULL) {
+    __mAdditionalInfo(NULL),
+    __mFocusCBMutex(PTHREAD_MUTEX_INITIALIZER) {
     __mAudioInfo = audioInfo;
 }
 
@@ -319,6 +338,8 @@ void CAudioSessionHandler::__sound_pcm_focus_cb(int id, mm_sound_focus_type_e fo
 
     CAudioSessionHandler* pHandler = static_cast<CAudioSessionHandler*>(user_data);
 
+    pHandler->__lockFocusCBMutex();
+
     if (state == FOCUS_IS_RELEASED)
         pHandler->__mAcquiredFocus &= ~focus_type;
     else if (state == FOCUS_IS_ACQUIRED)
@@ -328,6 +349,8 @@ void CAudioSessionHandler::__sound_pcm_focus_cb(int id, mm_sound_focus_type_e fo
 
     if (pHandler->__mpEventListener != NULL)
         pHandler->__mpEventListener->onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info);
+
+    pHandler->__unlockFocusCBMutex();
 #endif
     return;
 }
@@ -356,6 +379,7 @@ void CAudioSessionHandler::registerSound() {
 
         if (__isFocusRequired(__mMultimediaSession, __mOptions)) {
             int index = 0;
+
             CAudioError err = __convertStreamType(__mAudioSession, __mMultimediaSession, &index);
             if (err != CAudioError::EError::ERROR_NONE) {
                 throw err;
@@ -444,20 +468,36 @@ void CAudioSessionHandler::updatePlaying() {
         if (__mId >= 0) {
             int ret = MM_ERROR_NONE;
             int focus_type = 0;
+            bool is_focus_cb_thread;
+
+            if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed mm_sound_focus_is_cb_thread() err:0x%x", ret);
+
+            if (!is_focus_cb_thread)
+                __lockFocusCBMutex();
+
             if (__mAcquiredFocus == FOCUS_FOR_BOTH) {
                 AUDIO_IO_LOGW("Focus was already acquired, skip it...");
+                if (!is_focus_cb_thread)
+                    __unlockFocusCBMutex();
                 return;
             }
+
             focus_type |= (FOCUS_FOR_BOTH & ~__mAcquiredFocus);
             if (__mMultimediaSession == MM_SESSION_TYPE_MEDIA)
                 ret = mm_sound_acquire_focus_with_option(__mId, (mm_sound_focus_type_e)focus_type, 1, "audio-io acquire focus"); /* option: 1 for no-resume */
             else
                 ret = mm_sound_acquire_focus(__mId, (mm_sound_focus_type_e)focus_type, "audio-io acquire focus");
             if (ret != MM_ERROR_NONE) {
+                if (!is_focus_cb_thread)
+                    __unlockFocusCBMutex();
                 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_acquire_focus() err:0x%x", ret);
             }
             __mAcquiredFocus = FOCUS_FOR_BOTH;
             AUDIO_IO_LOGD("Focus acquired successfully [id:%d]", __mId);
+
+            if (!is_focus_cb_thread)
+                __unlockFocusCBMutex();
         }
     }
 }
@@ -470,19 +510,35 @@ void CAudioSessionHandler::updateStop() {
     if (__mUseFocus && __isFocusRequired(__mMultimediaSession, __mOptions)) {
         if (__mId >= 0) {
             int ret = MM_ERROR_NONE;
+            bool is_focus_cb_thread;
+
+            if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed mm_sound_focus_is_cb_thread() err:0x%x", ret);
+
+            if (!is_focus_cb_thread)
+                __lockFocusCBMutex();
+
             if (__mAcquiredFocus == FOCUS_NONE) {
                 AUDIO_IO_LOGW("Focus was already released, skip it...");
+                if (!is_focus_cb_thread)
+                    __unlockFocusCBMutex();
                 return;
             }
+
             if (__mMultimediaSession == MM_SESSION_TYPE_MEDIA)
                 ret = mm_sound_release_focus_with_option(__mId, (mm_sound_focus_type_e)__mAcquiredFocus, 1, "audio-io release focus"); /* option: 1 for no-resume */
             else
                 ret = mm_sound_release_focus(__mId, (mm_sound_focus_type_e)__mAcquiredFocus, "audio-io release focus");
             if (ret != MM_ERROR_NONE) {
+                if (!is_focus_cb_thread)
+                    __unlockFocusCBMutex();
                 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_release_focus() err:0x%x", ret);
             }
             __mAcquiredFocus = FOCUS_NONE;
             AUDIO_IO_LOGD("Focus released successfully [id:%d]", __mId);
+
+            if (!is_focus_cb_thread)
+                __unlockFocusCBMutex();
         }
     }
 }
@@ -515,6 +571,7 @@ IAudioSessionEventListener::EInterruptCode IAudioSessionEventListener::convertIn
         if (!strcmp(reason_for_change, "emergency"))          e = EInterruptCode::INTERRUPT_BY_EMERGENCY;
         if (!strcmp(reason_for_change, "voice-information"))  e = EInterruptCode::INTERRUPT_BY_MEDIA;
         if (!strcmp(reason_for_change, "voice-recognition"))  e = EInterruptCode::INTERRUPT_BY_MEDIA;
+        if (!strcmp(reason_for_change, "voice-recognition-service")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
         if (!strcmp(reason_for_change, "ringtone-voip"))      e = EInterruptCode::INTERRUPT_BY_CALL;
         if (!strcmp(reason_for_change, "ringtone-call"))      e = EInterruptCode::INTERRUPT_BY_CALL;
         if (!strcmp(reason_for_change, "voip"))               e = EInterruptCode::INTERRUPT_BY_CALL;