Add sub thread for audio stream callback

[Version] 0.2.37
[Profile] Common
[Issue Type] Enhancement
[Dependency module] N/A
[Dependency commit] N/A
[Test] [M(T) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-mobile_20160913.1]

Change-Id: I56243fbcfa660c410218a38220f436a597c2b390
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/include/recorder.h b/include/recorder.h
index 8fbd344..682a2ee 100644 (file)
--- a/include/recorder.h
+++ b/include/recorder.h
@@ -804,8 +804,8 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo
  * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
  * @remarks This function should be called before recording (recorder_start()).
  * @param[in] recorder The handle to the media recorder
- * @param[in] width    The preview width
- * @param[in] height   The preview height
+ * @param[in] width    The video width
+ * @param[in] height   The video height
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RECORDER_ERROR_NONE Successful
  * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter

diff --git a/include/recorder_private.h b/include/recorder_private.h
index b42b831..76608dc 100644 (file)
--- a/include/recorder_private.h
+++ b/include/recorder_private.h
@@ -60,27 +60,51 @@ enum {
        _RECORDER_GET_DOUBLE_MAX
 };
 
+enum {
+       _RECORDER_MESSAGE_HANDLER_TYPE_GENERAL,
+       _RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB
+};
+
+typedef struct _recorder_msg_handler_info_s {
+       int type;
+       void *cb_info;
+       int running;
+       GCond cond;
+       GMutex mutex;
+       GQueue *queue;
+       GThread *thread;
+} recorder_msg_handler_info_s;
+
 typedef struct _recorder_cb_info_s {
+       /* server connection */
        gint fd;
        gboolean is_server_connected;
 
+       /* message receive thread */
        GThread *msg_recv_thread;
-       GThread *msg_handler_thread;
        gint msg_recv_running;
-       gint msg_handler_running;
-       GCond msg_handler_cond;
-       GMutex msg_handler_mutex;
-       GQueue *msg_queue;
+       gchar recv_msg[RECORDER_MSG_LENGTH_MAX];
+       GCond api_cond[MUSE_RECORDER_API_MAX];
+       GMutex api_mutex[MUSE_RECORDER_API_MAX];
+       gint api_activating[MUSE_RECORDER_API_MAX];
+       gint api_ret[MUSE_RECORDER_API_MAX];
+
+       /* general message handler info */
+       recorder_msg_handler_info_s msg_handler_info;
+
+       /* preview cb message handler info */
+       recorder_msg_handler_info_s audio_stream_cb_info;
+
+       /* idle event */
        GList *idle_event_list;
        GCond idle_event_cond;
        GMutex idle_event_mutex;
+
+       /* user callback */
        gpointer user_cb[MUSE_RECORDER_EVENT_TYPE_NUM];
        gpointer user_data[MUSE_RECORDER_EVENT_TYPE_NUM];
-       gchar recv_msg[RECORDER_MSG_LENGTH_MAX];
-       GCond api_cond[MUSE_RECORDER_API_MAX];
-       GMutex api_mutex[MUSE_RECORDER_API_MAX];
-       gint *api_activating;
-       gint *api_ret;
+
+       /* tbm */
        tbm_bufmgr bufmgr;
 
        /* get values */
@@ -92,6 +116,8 @@ typedef struct _recorder_cb_info_s {
 typedef struct _recorder_message_s {
        gchar recv_msg[MUSE_RECORDER_MSG_MAX_LENGTH];
        muse_recorder_api_e api;
+       muse_recorder_event_e event;
+       muse_recorder_event_class_e event_class;
 } recorder_message_s;
 
 typedef struct _recorder_idle_event_s {

diff --git a/packaging/capi-media-recorder.spec b/packaging/capi-media-recorder.spec
index a87bc07..692bb3e 100644 (file)
--- a/packaging/capi-media-recorder.spec
+++ b/packaging/capi-media-recorder.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-recorder
 Summary:    A Recorder API
-Version:    0.2.36
+Version:    0.2.37
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/recorder.c b/src/recorder.c
index b545e8e..a5e453a 100644 (file)
--- a/src/recorder.c
+++ b/src/recorder.c
@@ -411,47 +411,95 @@ static void _recorder_remove_idle_event_all(recorder_cb_info_s *cb_info)
 }
 
 
+static void __recorder_add_msg_to_queue(recorder_cb_info_s *cb_info, int api, int event, int event_class, char *msg)
+{
+       recorder_message_s *rec_msg = NULL;
+
+       if (!cb_info || !msg) {
+               LOGE("NULL pointer %p %p", cb_info, msg);
+               return;
+       }
+
+       rec_msg = g_new0(recorder_message_s, 1);
+       if (!rec_msg) {
+               LOGE("failed to alloc rec_msg for [%s]", msg);
+               return;
+       }
+
+       rec_msg->api = api;
+       rec_msg->event = event;
+       rec_msg->event_class = event_class;
+
+       strncpy(rec_msg->recv_msg, msg, sizeof(rec_msg->recv_msg) - 1);
+
+       /*LOGD("add recorder message to queue : api %d, event %d, event_class %d", api, event, event_class);*/
+
+       if (event == MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM) {
+               g_mutex_lock(&cb_info->audio_stream_cb_info.mutex);
+               g_queue_push_tail(cb_info->audio_stream_cb_info.queue, (gpointer)rec_msg);
+               g_cond_signal(&cb_info->audio_stream_cb_info.cond);
+               g_mutex_unlock(&cb_info->audio_stream_cb_info.mutex);
+       } else {
+               g_mutex_lock(&cb_info->msg_handler_info.mutex);
+               g_queue_push_tail(cb_info->msg_handler_info.queue, (gpointer)rec_msg);
+               g_cond_signal(&cb_info->msg_handler_info.cond);
+               g_mutex_unlock(&cb_info->msg_handler_info.mutex);
+       }
+
+       rec_msg = NULL;
+
+       return;
+}
+
+
 static void *_recorder_msg_handler_func(gpointer data)
 {
-       int ret = 0;
        int api = 0;
-       int event = 0;
-       int event_class = 0;
+       int type = 0;
        recorder_message_s *rec_msg = NULL;
        recorder_idle_event_s *rec_idle_event = NULL;
-       recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;
+       recorder_msg_handler_info_s *handler_info = (recorder_msg_handler_info_s *)data;
+       recorder_cb_info_s *cb_info = NULL;
 
-       if (cb_info == NULL) {
-               LOGE("cb_info NULL");
+       if (!handler_info || !handler_info->cb_info) {
+               LOGE("NULL handler %p", handler_info);
                return NULL;
        }
 
-       LOGD("start");
+       cb_info = (recorder_cb_info_s *)handler_info->cb_info;
+       type = handler_info->type;
 
-       g_mutex_lock(&cb_info->msg_handler_mutex);
+       LOGD("t:%d start", type);
 
-       while (g_atomic_int_get(&cb_info->msg_handler_running)) {
-               if (g_queue_is_empty(cb_info->msg_queue)) {
+       g_mutex_lock(&handler_info->mutex);
+
+       while (g_atomic_int_get(&handler_info->running)) {
+               if (g_queue_is_empty(handler_info->queue)) {
                        /*LOGD("signal wait...");*/
-                       g_cond_wait(&cb_info->msg_handler_cond, &cb_info->msg_handler_mutex);
+                       g_cond_wait(&handler_info->cond, &handler_info->mutex);
                        /*LOGD("signal received");*/
 
-                       if (g_atomic_int_get(&cb_info->msg_handler_running) == 0) {
+                       if (g_atomic_int_get(&handler_info->running) == 0) {
                                LOGD("stop event thread");
                                break;
                        }
                }
 
-               rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue);
-               g_mutex_unlock(&cb_info->msg_handler_mutex);
+               rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
+               g_mutex_unlock(&handler_info->mutex);
                if (rec_msg == NULL) {
                        LOGE("NULL message");
-                       g_mutex_lock(&cb_info->msg_handler_mutex);
+                       g_mutex_lock(&handler_info->mutex);
                        continue;
                }
+
                api = rec_msg->api;
+
                if (api < MUSE_RECORDER_API_MAX) {
+                       int ret = 0;
+
                        g_mutex_lock(&cb_info->api_mutex[api]);
+
                        if (muse_recorder_msg_get(ret, rec_msg->recv_msg)) {
                                cb_info->api_ret[api] = ret;
                                cb_info->api_activating[api] = 1;
@@ -460,28 +508,14 @@ static void *_recorder_msg_handler_func(gpointer data)
 
                                g_cond_signal(&cb_info->api_cond[api]);
                        } else {
-                               LOGE("failed to get ret for api %d, msg %s", rec_msg->api, rec_msg->recv_msg);
+                               LOGE("t:%d failed to get ret for api %d, msg %s", type, api, rec_msg->recv_msg);
                        }
 
                        g_mutex_unlock(&cb_info->api_mutex[api]);
                } else if (api == MUSE_RECORDER_CB_EVENT) {
-                       event = -1;
-                       event_class = -1;
-
-                       if (!muse_recorder_msg_get(event, rec_msg->recv_msg) ||
-                           !muse_recorder_msg_get(event_class, rec_msg->recv_msg)) {
-                               LOGE("get failed : event %d, class %d", event, event_class);
-
-                               g_free(rec_msg);
-                               rec_msg = NULL;
-
-                               g_mutex_lock(&cb_info->msg_handler_mutex);
-                               continue;
-                       }
-
-                       switch (event_class) {
+                       switch (rec_msg->event_class) {
                        case MUSE_RECORDER_EVENT_CLASS_THREAD_SUB:
-                               _recorder_client_user_callback(cb_info, rec_msg->recv_msg, event);
+                               _recorder_client_user_callback(cb_info, rec_msg->recv_msg, rec_msg->event);
                                break;
                        case MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN:
                                rec_idle_event = g_new0(recorder_idle_event_s, 1);
@@ -490,12 +524,12 @@ static void *_recorder_msg_handler_func(gpointer data)
                                        break;
                                }
 
-                               rec_idle_event->event = event;
+                               rec_idle_event->event = rec_msg->event;
                                rec_idle_event->cb_info = cb_info;
                                g_mutex_init(&rec_idle_event->event_mutex);
-                               memcpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg));
+                               strncpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg) - 1);
 
-                               /*LOGD("add recorder event[%d, %p] to IDLE", event, rec_idle_event);*/
+                               /*LOGD("add recorder event[%d, %p] to IDLE", rec_msg->event, rec_idle_event);*/
 
                                g_mutex_lock(&cb_info->idle_event_mutex);
                                cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)rec_idle_event);
@@ -507,7 +541,7 @@ static void *_recorder_msg_handler_func(gpointer data)
                                        NULL);
                                break;
                        default:
-                               LOGE("unknown event class %d", event_class);
+                               LOGE("unknown event class %d", rec_msg->event_class);
                                break;
                        }
                } else {
@@ -517,12 +551,12 @@ static void *_recorder_msg_handler_func(gpointer data)
                g_free(rec_msg);
                rec_msg = NULL;
 
-               g_mutex_lock(&cb_info->msg_handler_mutex);
+               g_mutex_lock(&handler_info->mutex);
        }
 
        /* remove remained event */
-       while (!g_queue_is_empty(cb_info->msg_queue)) {
-               rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue);
+       while (!g_queue_is_empty(handler_info->queue)) {
+               rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
                if (rec_msg) {
                        LOGD("remove message %p", rec_msg);
                        free(rec_msg);
@@ -532,7 +566,7 @@ static void *_recorder_msg_handler_func(gpointer data)
                }
        }
 
-       g_mutex_unlock(&cb_info->msg_handler_mutex);
+       g_mutex_unlock(&handler_info->mutex);
 
        LOGD("return");
 
@@ -681,6 +715,8 @@ static void *_recorder_msg_recv_func(gpointer data)
        int ret = 0;
        int api = 0;
        int api_class = 0;
+       int event = 0;
+       int event_class = 0;
        int num_token = 0;
        int str_pos = 0;
        int prev_pos = 0;
@@ -688,7 +724,6 @@ static void *_recorder_msg_recv_func(gpointer data)
        char *error_msg = NULL;
        char **parse_str = NULL;
        recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;
-       recorder_message_s *rec_msg = NULL;
 
        if (cb_info == NULL) {
                LOGE("cb_info NULL");
@@ -757,9 +792,15 @@ static void *_recorder_msg_recv_func(gpointer data)
                                continue;
                        }
 
-                       if (api != MUSE_RECORDER_CB_EVENT) {
+                       if (api == MUSE_RECORDER_CB_EVENT) {
+                               if (!muse_recorder_msg_get(event, parse_str[i]) ||
+                                       !muse_recorder_msg_get(event_class, parse_str[i])) {
+                                       LOGE("failed to get event or event_class [%s]", parse_str[i]);
+                                       continue;
+                               }
+                       } else {
                                if (!muse_recorder_msg_get(api_class, parse_str[i])) {
-                                       LOGE("failed to get recorder api_class");
+                                       LOGE("failed to get api_class [%s]", parse_str[i]);
                                        continue;
                                }
                        }
@@ -801,25 +842,8 @@ static void *_recorder_msg_recv_func(gpointer data)
 
                                g_cond_signal(&cb_info->api_cond[api]);
                                g_mutex_unlock(&cb_info->api_mutex[api]);
-                       } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB ||
-                                       api == MUSE_RECORDER_CB_EVENT) {
-                               rec_msg = g_new0(recorder_message_s, 1);
-                               if (rec_msg == NULL) {
-                                       LOGE("failed to alloc rec_msg");
-                                       continue;
-                               }
-
-                               rec_msg->api = api;
-                               memcpy(rec_msg->recv_msg, parse_str[i], sizeof(rec_msg->recv_msg));
-
-                               /*LOGD("add recorder message to queue : api %d", api);*/
-
-                               g_mutex_lock(&cb_info->msg_handler_mutex);
-                               g_queue_push_tail(cb_info->msg_queue, (gpointer)rec_msg);
-                               g_cond_signal(&cb_info->msg_handler_cond);
-                               g_mutex_unlock(&cb_info->msg_handler_mutex);
-
-                               rec_msg = NULL;
+                       } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB || api == MUSE_RECORDER_CB_EVENT) {
+                               __recorder_add_msg_to_queue(cb_info, api, event, event_class, parse_str[i]);
                        } else {
                                LOGW("unknown recorder api %d and api_class %d", api, api_class);
                        }
@@ -831,8 +855,6 @@ static void *_recorder_msg_recv_func(gpointer data)
        if (!cb_info->is_server_connected) {
                /* send error msg for server disconnection */
                error_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_CB_EVENT,
-                       MUSE_TYPE_INT, PARAM_EVENT, MUSE_RECORDER_EVENT_TYPE_ERROR,
-                       MUSE_TYPE_INT, PARAM_EVENT_CLASS, MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                        MUSE_TYPE_INT, "error", RECORDER_ERROR_SERVICE_DISCONNECTED,
                        MUSE_TYPE_INT, "current_state", RECORDER_STATE_NONE,
                        NULL);
@@ -841,33 +863,21 @@ static void *_recorder_msg_recv_func(gpointer data)
                        goto CB_HANDLER_EXIT;
                }
 
-               rec_msg = g_new0(recorder_message_s, 1);
-               if (rec_msg == NULL) {
-                       LOGE("failed to alloc rec_msg");
-                       goto CB_HANDLER_EXIT;
-               }
-
-               rec_msg->api = MUSE_RECORDER_CB_EVENT;
-               memcpy(rec_msg->recv_msg, error_msg, sizeof(rec_msg->recv_msg));
-
-               /*LOGD("add recorder message to queue : api %d", api);*/
+               LOGE("add error msg for service disconnection done");
 
-               g_mutex_lock(&cb_info->msg_handler_mutex);
-               g_queue_push_tail(cb_info->msg_queue, (gpointer)rec_msg);
-               g_cond_signal(&cb_info->msg_handler_cond);
-               g_mutex_unlock(&cb_info->msg_handler_mutex);
+               __recorder_add_msg_to_queue(cb_info,
+                       MUSE_RECORDER_CB_EVENT,
+                       MUSE_RECORDER_EVENT_TYPE_ERROR,
+                       MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+                       error_msg);
 
-               rec_msg = NULL;
+               muse_core_msg_json_factory_free(error_msg);
+               error_msg = NULL;
 
                LOGE("add error msg for service disconnection done");
        }
 
 CB_HANDLER_EXIT:
-       if (error_msg) {
-               muse_core_msg_json_factory_free(error_msg);
-               error_msg = NULL;
-       }
-
        if (parse_str) {
                for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
                        if (parse_str[i]) {
@@ -883,11 +893,91 @@ CB_HANDLER_EXIT:
        return NULL;
 }
 
-static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd)
+
+static bool __create_msg_handler_thread(recorder_msg_handler_info_s *handler_info,
+       int type, const char *thread_name, recorder_cb_info_s *cb_info)
+{
+       if (!handler_info || !thread_name || !cb_info) {
+               LOGE("t:%d NULL %p %p %p",
+                       type, handler_info, thread_name, cb_info);
+               return false;
+       }
+
+       LOGD("t:%d", type);
+
+       handler_info->type = type;
+       handler_info->queue = g_queue_new();
+       if (handler_info->queue == NULL) {
+               LOGE("t:%d queue failed", type);
+               return false;
+       }
+
+       g_mutex_init(&handler_info->mutex);
+       g_cond_init(&handler_info->cond);
+
+       handler_info->cb_info = (void *)cb_info;
+       g_atomic_int_set(&handler_info->running, 1);
+
+       handler_info->thread = g_thread_try_new(thread_name,
+               _recorder_msg_handler_func, (gpointer)handler_info, NULL);
+       if (handler_info->thread == NULL) {
+               LOGE("t:%d thread failed", type);
+
+               g_mutex_clear(&handler_info->mutex);
+               g_cond_clear(&handler_info->cond);
+               g_queue_free(handler_info->queue);
+               handler_info->queue = NULL;
+
+               return false;
+       }
+
+       LOGD("t:%d done", type);
+
+       return true;
+}
+
+
+static void __destroy_msg_handler_thread(recorder_msg_handler_info_s *handler_info)
+{
+       int type = 0;
+
+       if (!handler_info) {
+               LOGE("NULL handler");
+               return;
+       }
+
+       if (!handler_info->thread) {
+               LOGW("thread is not created");
+               return;
+       }
+
+       type = handler_info->type;
+
+       LOGD("t:%d thread %p", type, handler_info->thread);
+
+       g_mutex_lock(&handler_info->mutex);
+       g_atomic_int_set(&handler_info->running, 0);
+       g_cond_signal(&handler_info->cond);
+       g_mutex_unlock(&handler_info->mutex);
+
+       g_thread_join(handler_info->thread);
+       g_thread_unref(handler_info->thread);
+       handler_info->thread = NULL;
+
+       g_mutex_clear(&handler_info->mutex);
+       g_cond_clear(&handler_info->cond);
+       g_queue_free(handler_info->queue);
+       handler_info->queue = NULL;
+
+       LOGD("t:%d done", type);
+
+       return;
+}
+
+
+static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd, bool need_msg_handler_thread)
 {
        recorder_cb_info_s *cb_info = NULL;
-       gint *tmp_activating = NULL;
-       gint *tmp_ret = NULL;
        gint i = 0;
 
        g_return_val_if_fail(sockfd > 0, NULL);
@@ -898,46 +988,33 @@ static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd)
                goto ErrorExit;
        }
 
-       g_mutex_init(&cb_info->msg_handler_mutex);
-       g_cond_init(&cb_info->msg_handler_cond);
-       g_mutex_init(&cb_info->idle_event_mutex);
-       g_cond_init(&cb_info->idle_event_cond);
-
        for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
                g_mutex_init(&cb_info->api_mutex[i]);
                g_cond_init(&cb_info->api_cond[i]);
        }
 
-       tmp_activating = g_new0(gint, MUSE_RECORDER_API_MAX);
-       if (tmp_activating == NULL) {
-               LOGE("tmp_activating failed");
-               goto ErrorExit;
-       }
-
-       tmp_ret = g_new0(gint, MUSE_RECORDER_API_MAX);
-       if (tmp_ret == NULL) {
-               LOGE("tmp_ret failed");
-               goto ErrorExit;
-       }
+       g_mutex_init(&cb_info->idle_event_mutex);
+       g_cond_init(&cb_info->idle_event_cond);
 
-       cb_info->msg_queue = g_queue_new();
-       if (cb_info->msg_queue == NULL) {
-               LOGE("msg_queue new failed");
-               goto ErrorExit;
-       }
+       if (need_msg_handler_thread) {
+               /* message handler thread */
+               if (!__create_msg_handler_thread(&cb_info->msg_handler_info,
+                       _RECORDER_MESSAGE_HANDLER_TYPE_GENERAL, "recorder_msg_handler", cb_info)) {
+                       LOGE("msg_handler_info failed");
+                       goto ErrorExit;
+               }
 
-       g_atomic_int_set(&cb_info->msg_handler_running, 1);
-       cb_info->msg_handler_thread = g_thread_try_new("recorder_msg_handler",
-               _recorder_msg_handler_func, (gpointer)cb_info, NULL);
-       if (cb_info->msg_handler_thread == NULL) {
-               LOGE("message handler thread creation failed");
-               goto ErrorExit;
+               /* message handler thread for audio stream callback */
+               if (!__create_msg_handler_thread(&cb_info->audio_stream_cb_info,
+                       _RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB, "recorder_msg_handler:audio_stream_cb", cb_info)) {
+                       LOGE("audio_stream_cb_info failed");
+                       goto ErrorExit;
+               }
        }
 
        cb_info->fd = sockfd;
-       cb_info->api_activating = tmp_activating;
-       cb_info->api_ret = tmp_ret;
 
+       /* message receive thread */
        g_atomic_int_set(&cb_info->msg_recv_running, 1);
        cb_info->msg_recv_thread = g_thread_try_new("recorder_msg_recv",
                _recorder_msg_recv_func, (gpointer)cb_info, NULL);
@@ -952,45 +1029,21 @@ static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd)
 
 ErrorExit:
        if (cb_info) {
-               if (cb_info->msg_handler_thread) {
-                       g_mutex_lock(&cb_info->msg_handler_mutex);
-                       g_atomic_int_set(&cb_info->msg_handler_running, 0);
-                       g_cond_signal(&cb_info->msg_handler_cond);
-                       g_mutex_unlock(&cb_info->msg_handler_mutex);
-
-                       g_thread_join(cb_info->msg_handler_thread);
-                       g_thread_unref(cb_info->msg_handler_thread);
-                       cb_info->msg_handler_thread = NULL;
-               }
+               __destroy_msg_handler_thread(&cb_info->msg_handler_info);
+               __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);
 
-               for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
-                       g_mutex_clear(&cb_info->api_mutex[i]);
-                       g_cond_clear(&cb_info->api_cond[i]);
-               }
-
-               g_mutex_clear(&cb_info->msg_handler_mutex);
-               g_cond_clear(&cb_info->msg_handler_cond);
                g_mutex_clear(&cb_info->idle_event_mutex);
                g_cond_clear(&cb_info->idle_event_cond);
 
-               if (cb_info->msg_queue) {
-                       g_queue_free(cb_info->msg_queue);
-                       cb_info->msg_queue = NULL;
+               for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
+                       g_mutex_clear(&cb_info->api_mutex[i]);
+                       g_cond_clear(&cb_info->api_cond[i]);
                }
 
                g_free(cb_info);
                cb_info = NULL;
        }
 
-       if (tmp_activating) {
-               g_free(tmp_activating);
-               tmp_activating = NULL;
-       }
-       if (tmp_ret) {
-               g_free(tmp_ret);
-               tmp_ret = NULL;
-       }
-
        return NULL;
 }
 
@@ -1141,21 +1194,11 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info)
        g_thread_unref(cb_info->msg_recv_thread);
        cb_info->msg_recv_thread = NULL;
 
-       LOGD("msg thread removed");
+       LOGD("msg_recv thread removed");
 
-       g_mutex_lock(&cb_info->msg_handler_mutex);
-       g_atomic_int_set(&cb_info->msg_handler_running, 0);
-       g_cond_signal(&cb_info->msg_handler_cond);
-       g_mutex_unlock(&cb_info->msg_handler_mutex);
+       __destroy_msg_handler_thread(&cb_info->msg_handler_info);
+       __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);
 
-       g_thread_join(cb_info->msg_handler_thread);
-       g_thread_unref(cb_info->msg_handler_thread);
-       cb_info->msg_handler_thread = NULL;
-
-       g_queue_free(cb_info->msg_queue);
-       cb_info->msg_queue = NULL;
-       g_mutex_clear(&cb_info->msg_handler_mutex);
-       g_cond_clear(&cb_info->msg_handler_cond);
        g_mutex_clear(&cb_info->idle_event_mutex);
        g_cond_clear(&cb_info->idle_event_cond);
 
@@ -1164,8 +1207,6 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info)
                g_cond_clear(&cb_info->api_cond[i]);
        }
 
-       LOGD("event thread removed");
-
        if (cb_info->fd > -1) {
                muse_core_connection_close(cb_info->fd);
                cb_info->fd = -1;
@@ -1175,14 +1216,6 @@ static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info)
                tbm_bufmgr_deinit(cb_info->bufmgr);
                cb_info->bufmgr = NULL;
        }
-       if (cb_info->api_activating) {
-               g_free(cb_info->api_activating);
-               cb_info->api_activating = NULL;
-       }
-       if (cb_info->api_ret) {
-               g_free(cb_info->api_ret);
-               cb_info->api_ret = NULL;
-       }
        if (cb_info->get_filename) {
                free(cb_info->get_filename);
                cb_info->get_filename = NULL;
@@ -1323,7 +1356,7 @@ static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e ty
                goto _ERR_RECORDER_EXIT;
        }
 
-       pc->cb_info = _recorder_client_callback_new(sock_fd);
+       pc->cb_info = _recorder_client_callback_new(sock_fd, true);
        if (pc->cb_info == NULL) {
                ret = RECORDER_ERROR_OUT_OF_MEMORY;
                goto _ERR_RECORDER_EXIT;