Added mutex lock for feedback stream

Change-Id: If6d7f84e802ade5ab58c10c7a31b9787e2b9ea7a
Signed-off-by: sungrae jo <seongrae.jo@samsung.com>

diff --git a/client/vc_mgr.c b/client/vc_mgr.c
index bb411a53ea37af1506670f344a87a4014e45aa1c..22f070d39903960c59beb4287dd08c56f6131cc0 100644 (file)
--- a/client/vc_mgr.c
+++ b/client/vc_mgr.c
@@ -79,6 +79,8 @@ static vc_audio_channel_e g_feedback_audio_channel = 0;
 static vc_audio_type_e g_feedback_audio_type = 0;
 static Ecore_Thread* g_feedback_thread = NULL;
 
+static pthread_mutex_t g_feedback_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t g_vc_tts_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 static Eina_Bool __vc_mgr_notify_state_changed(void *data);
 static void __vc_mgr_notify_error(void *data);
@@ -4012,20 +4014,26 @@ int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void
        if (NULL == callback)
                return VC_ERROR_INVALID_PARAMETER;
 
+       pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
+
        vc_state_e state;
        if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
+               pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        /* check state */
        if (VC_STATE_INITIALIZED != state) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
+               pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        vc_mgr_client_set_feedback_streaming_cb(g_vc_m, callback, user_data);
 
+       pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
+
        SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
 
        return 0;
@@ -4043,20 +4051,26 @@ int vc_mgr_unset_feedback_streaming_cb()
                return VC_ERROR_PERMISSION_DENIED;
        }
 
+       pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
+
        vc_state_e state;
        if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
+               pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        /* check state */
        if (VC_STATE_INITIALIZED != state) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
+               pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        vc_mgr_client_set_feedback_streaming_cb(g_vc_m, NULL, NULL);
 
+       pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
+
        SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
 
        return 0;
@@ -4067,20 +4081,26 @@ int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* us
        if (NULL == callback)
                return VC_ERROR_INVALID_PARAMETER;
 
+       pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
+
        vc_state_e state;
        if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
+               pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        /* check state */
        if (VC_STATE_INITIALIZED != state) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
+               pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        vc_mgr_client_set_vc_tts_streaming_cb(g_vc_m, callback, user_data);
 
+       pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
+
        SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
 
        return 0;
@@ -4088,20 +4108,26 @@ int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* us
 
 int vc_mgr_unset_vc_tts_streaming_cb()
 {
+       pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
+
        vc_state_e state;
        if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
+               pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        /* check state */
        if (VC_STATE_INITIALIZED != state) {
                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
+               pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
                return VC_ERROR_INVALID_STATE;
        }
 
        vc_mgr_client_set_vc_tts_streaming_cb(g_vc_m, NULL, NULL);
 
+       pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
+
        SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
 
        return 0;
@@ -4149,10 +4175,13 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
                                vc_mgr_feedback_streaming_cb callback = NULL;
                                void* user_data = NULL;
 
+                               pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
+
                                vc_mgr_client_get_feedback_streaming_cb(g_vc_m, &callback, &user_data);
                                if (NULL == callback) {
                                        SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback streaming callback is null");
                                        vc_mgr_data_clear_feedback_data(&feedback_data);
+                                       pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
                                        return;
                                }
 
@@ -4161,6 +4190,8 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
                                callback(feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
                                vc_mgr_client_not_use_callback(g_vc_m);
 
+                               pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
+
                                /* If no feedback data and EVENT_FINISH */
                                if (0 >= vc_mgr_data_get_feedback_data_size() && VC_FEEDBACK_EVENT_FINISH == feedback_data->event) {
                                        SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish feedback");
@@ -4170,10 +4201,13 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
                                vc_mgr_vc_tts_streaming_cb callback = NULL;
                                void* user_data = NULL;
 
+                               pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
+
                                vc_mgr_client_get_vc_tts_streaming_cb(g_vc_m, &callback, &user_data);
                                if (NULL == callback) {
                                        SLOG(LOG_WARN, TAG_VCM, "[WARNING] vc tts streaming callback is null");
                                        vc_mgr_data_clear_feedback_data(&feedback_data);
+                                       pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
                                        return;
                                }
 
@@ -4182,6 +4216,8 @@ static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
                                callback(feedback_data->pid, feedback_data->utt_id, feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
                                vc_mgr_client_not_use_callback(g_vc_m);
 
+                               pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
+
                                /* If no feedback data and EVENT_FINISH */
                                if (0 >= vc_mgr_data_get_feedback_data_size() && VC_FEEDBACK_EVENT_FINISH == feedback_data->event) {
                                        SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish vc tts feedback");