Release version 0.2.8

1. Add new enum for class of API and event

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

diff --git a/muse/include/muse_recorder.h b/muse/include/muse_recorder.h
index 6d56b03..a9ec1de 100644 (file)
--- a/muse/include/muse_recorder.h
+++ b/muse/include/muse_recorder.h
@@ -96,6 +96,15 @@ typedef enum {
 } muse_recorder_api_e;
 
 /**
+ * @brief Enumeration for the muse recorder API class.
+ */
+typedef enum {
+       MUSE_RECORDER_API_CLASS_IMMEDIATE,
+       MUSE_RECORDER_API_CLASS_THREAD_SUB,
+       MUSE_RECORDER_API_CLASS_NUM
+} muse_recorder_api_class_e;
+
+/**
  * @brief Enumeration for the muse recorder events.
  */
 typedef enum {
@@ -113,6 +122,15 @@ typedef enum {
 } muse_recorder_event_e;
 
 /**
+ * @brief Enumeration for the muse recorder events class.
+ */
+typedef enum {
+       MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+       MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+       MUSE_RECORDER_EVENT_CLASS_NUM
+} muse_recorder_event_class_e;
+
+/**
  * @brief The structure type for muse camera errors.
  */
 typedef enum {

diff --git a/muse/include/muse_recorder_msg.h b/muse/include/muse_recorder_msg.h
index befaf5c..953a021 100644 (file)
--- a/muse/include/muse_recorder_msg.h
+++ b/muse/include/muse_recorder_msg.h
@@ -31,47 +31,57 @@ extern "C" {
 /**
  * @brief Definition for the handle parameter.
  */
-#define PARAM_HANDLE                   "handle"
+#define PARAM_HANDLE        "handle"
 
 /**
  * @brief Definition for the ret parameter.
  */
-#define PARAM_RET                              "ret"
+#define PARAM_RET           "ret"
 
 /**
  * @brief Definition for the event parameter.
  */
-#define PARAM_EVENT                    "event"
+#define PARAM_EVENT         "event"
+
+/**
+ * @brief Definition for the api class parameter.
+ */
+#define PARAM_API_CLASS     "api_class"
+
+/**
+ * @brief Definition for the event class parameter.
+ */
+#define PARAM_EVENT_CLASS   "event_class"
 
 /**
  * @brief Definition for the error parameter.
  */
-#define PARAM_ERROR                    "error"
+#define PARAM_ERROR         "error"
 
 /**
  * @brief Definition for the tbm key parameter.
  */
-#define PARAM_TBM_KEY                  "t_key"
+#define PARAM_TBM_KEY       "t_key"
 
 /**
  * @brief Definition for the display mode parameter.
  */
-#define PARAM_DISPLAY_MODE     "display_mode"
+#define PARAM_DISPLAY_MODE  "display_mode"
 
 /**
  * @brief Definition for the device type parameter.
  */
-#define PARAM_DEVICE_TYPE              "device_type"
+#define PARAM_DEVICE_TYPE   "device_type"
 
 /**
  * @brief Definition for the recorder type parameter audio/video
  */
- #define PARAM_RECORDER_TYPE   "recorder_type"
+ #define PARAM_RECORDER_TYPE "recorder_type"
 
 /**
  * @brief Definition for the camera handle ipc parameter
  */
-#define PARAM_CAMERA_HANDLE    "camera_handle"
+#define PARAM_CAMERA_HANDLE "camera_handle"
 
 /**
  * @brief Definition for the INTEGER type.
@@ -158,10 +168,7 @@ typedef const char* STRING;
 #define muse_recorder_msg_send(api, fd, cb_info, ret) \
        do{     \
                char *__sndMsg__; \
-               callback_cb_info_s *cb_info_s; \
                int __len__; \
-               cb_info_s = (callback_cb_info_s *)cb_info; \
-               cb_info_s->activating[api] = 0; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, 0); \
                __len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
                if (__len__ <= 0) { \
@@ -287,14 +294,16 @@ typedef const char* STRING;
 /**
  * @brief Returning the ack message from the server to client side.
  * @param[in] api The enumeration of the corresponding api.
+ * @param[in] class The enumeration of the api class.
  * @param[out] ret The delivered return value from the module to proxy side.
  * @param[in] module The module info for the ipc transportation.
  */
-#define muse_recorder_msg_return(api, ret, module) \
+#define muse_recorder_msg_return(api, class, ret, module) \
        do{     \
                char *__sndMsg__; \
                int __len__; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
+                               MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                                MUSE_TYPE_INT, PARAM_RET, ret, \
                                0); \
                __len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
@@ -308,17 +317,19 @@ typedef const char* STRING;
 /**
  * @brief Returning the ack message from the server to client side.
  * @param[in] api The enumeration of the corresponding api.
+ * @param[in] class The enumeration of the api class.
  * @param[out] ret The delivered return value from the module to proxy side.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] type The data type of the parameter.
  * @param[in] param A parameter to be included in the message.
  */
-#define muse_recorder_msg_return1(api, ret, module, type, param) \
+#define muse_recorder_msg_return1(api, class, ret, module, type, param) \
        do{     \
                char *__sndMsg__; \
                int __len__; \
                type __value__ = (type)param; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
+                               MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                                MUSE_TYPE_INT, PARAM_RET, ret, \
                                MUSE_TYPE_##type, #param, __value__, \
                                0); \
@@ -333,6 +344,7 @@ typedef const char* STRING;
 /**
  * @brief Returning the ack message from the server to client side, adding 2 parameters.
  * @param[in] api The enumeration of the corresponding api.
+ * @param[in] class The enumeration of the api class.
  * @param[out] ret The delivered return value from the module to proxy side.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] type1 The data type of the parameter.
@@ -340,13 +352,14 @@ typedef const char* STRING;
  * @param[in] type2 The data type of the parameter.
  * @param[in] param2 The 2nd parameter to be included in the message.
  */
-#define muse_recorder_msg_return2(api, ret, module, type1, param1, type2, param2) \
+#define muse_recorder_msg_return2(api, class, ret, module, type1, param1, type2, param2) \
        do{     \
                char *__sndMsg__; \
                int __len__; \
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
+                               MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                                MUSE_TYPE_INT, PARAM_RET, ret, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
@@ -362,6 +375,7 @@ typedef const char* STRING;
 /**
  * @brief Returning the ack message from the server to client side, adding 3 parameters.
  * @param[in] api The enumeration of the corresponding api.
+ * @param[in] class The enumeration of the api class.
  * @param[out] ret The delivered return value from the module to proxy side.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] type1 The data type of the parameter.
@@ -371,7 +385,7 @@ typedef const char* STRING;
  * @param[in] type3 The data type of the parameter.
  * @param[in] param3 The 3rd parameter to be included in the message.
  */
-#define muse_recorder_msg_return3(api, ret, module, type1, param1, type2, param2, type3, param3) \
+#define muse_recorder_msg_return3(api, class, ret, module, type1, param1, type2, param2, type3, param3) \
        do{     \
                char *__sndMsg__; \
                int __len__; \
@@ -379,6 +393,7 @@ typedef const char* STRING;
                type2 __value2__ = (type2)param2; \
                type3 __value3__ = (type3)param3; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
+                               MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                                MUSE_TYPE_INT, PARAM_RET, ret, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
@@ -395,18 +410,20 @@ typedef const char* STRING;
 /**
  * @brief Returning the ack message from the server to client side, adding array parameter.
  * @param[in] api The enumeration of the corresponding api.
+ * @param[in] class The enumeration of the api class.
  * @param[out] ret The delivered return value from the module to proxy side.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] param The array data parameter to be included in the message.
  * @param[in] length The length of the array.
  * @param[in] datum_size The size of the array.
  */
-#define muse_recorder_msg_return_array(api, ret, module, param, length, datum_size) \
+#define muse_recorder_msg_return_array(api, class, ret, module, param, length, datum_size) \
        do{     \
                char *__sndMsg__; \
                int __len__; \
                int *__value__ = (int *)param; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
+                               MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                                MUSE_TYPE_INT, PARAM_RET, ret, \
                                MUSE_TYPE_INT, #length, length, \
                                MUSE_TYPE_ARRAY, #param, \
@@ -425,14 +442,16 @@ typedef const char* STRING;
 /**
  * @brief Returning the event ack message from the server to client side.
  * @param[in] api The enumeration of the corresponding api.
- * @param[out] ret The delivered return value from the module to proxy side.
+ * @param[in] event The enumeration of the event.
+ * @param[in] class The enumeration of the event class.
  * @param[in] module The module info for the ipc transportation.
  */
-#define muse_recorder_msg_event(api, event, fd) \
+#define muse_recorder_msg_event(api, event, class, module) \
        do{     \
                char *__sndMsg__; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
                                MUSE_TYPE_INT, PARAM_EVENT, event, \
+                               MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                                0); \
                muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
                muse_core_msg_json_factory_free(__sndMsg__); \
@@ -441,17 +460,19 @@ typedef const char* STRING;
 /**
  * @brief Returning the event ack message from the server to client side, adding a parameter.
  * @param[in] api The enumeration of the corresponding api.
- * @param[out] ret The delivered return value from the module to proxy side.
+ * @param[in] event The enumeration of the event.
+ * @param[in] class The enumeration of the event class.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] type The data type of the parameter.
  * @param[in] param A parameter to be included in the message.
  */
-#define muse_recorder_msg_event1(api, event, module, type, param) \
+#define muse_recorder_msg_event1(api, event, class, module, type, param) \
        do{     \
                char *__sndMsg__; \
                type __value__ = (type)param; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
                                MUSE_TYPE_INT, PARAM_EVENT, event, \
+                               MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                                MUSE_TYPE_##type, #param, __value__, \
                                0); \
                muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
@@ -461,19 +482,21 @@ typedef const char* STRING;
 /**
  * @brief Returning the event ack message from the server to client side, adding 2 parameters.
  * @param[in] api The enumeration of the corresponding api.
- * @param[out] ret The delivered return value from the module to proxy side.
+ * @param[in] event The enumeration of the event.
+ * @param[in] class The enumeration of the event class.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] param1 The 1st parameter to be included in the message.
  * @param[in] type2 The data type of the parameter.
  * @param[in] param2 The 2nd parameter to be included in the message.
  */
-#define muse_recorder_msg_event2(api, event, module, type1, param1, type2, param2) \
+#define muse_recorder_msg_event2(api, event, class, module, type1, param1, type2, param2) \
        do{     \
                char *__sndMsg__; \
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
                                MUSE_TYPE_INT, PARAM_EVENT, event, \
+                               MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                0); \
@@ -484,7 +507,8 @@ typedef const char* STRING;
 /**
  * @brief Returning the event ack message from the server to client side, adding 3 parameters.
  * @param[in] api The enumeration of the corresponding api.
- * @param[out] ret The delivered return value from the module to proxy side.
+ * @param[in] event The enumeration of the event.
+ * @param[in] class The enumeration of the event class.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] param1 The 1st parameter to be included in the message.
  * @param[in] type2 The data type of the parameter.
@@ -492,7 +516,7 @@ typedef const char* STRING;
  * @param[in] type3 The data type of the parameter.
  * @param[in] param3 The 3rd parameter to be included in the message.
  */
-#define muse_recorder_msg_event3(api, event, module, type1, param1, type2, param2, type3, param3) \
+#define muse_recorder_msg_event3(api, event, class, module, type1, param1, type2, param2, type3, param3) \
        do{     \
                char *__sndMsg__; \
                type1 __value1__ = (type1)param1; \
@@ -500,6 +524,7 @@ typedef const char* STRING;
                type3 __value3__ = (type3)param3; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
                                MUSE_TYPE_INT, PARAM_EVENT, event, \
+                               MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \
@@ -511,7 +536,8 @@ typedef const char* STRING;
 /**
  * @brief Returning the event ack message from the server to client side, adding 5 parameters.
  * @param[in] api The enumeration of the corresponding api.
- * @param[out] ret The delivered return value from the module to proxy side.
+ * @param[in] event The enumeration of the event.
+ * @param[in] class The enumeration of the event class.
  * @param[in] module The module info for the ipc transportation.
  * @param[in] param1 The 1st parameter to be included in the message.
  * @param[in] type2 The data type of the parameter.
@@ -523,7 +549,7 @@ typedef const char* STRING;
  * @param[in] type5 The data type of the parameter.
  * @param[in] param5 The 5th parameter to be included in the message.
  */
-#define muse_recorder_msg_event5(api, event, module, type1, param1, type2, param2, type3, param3, type4, param4, type5, param5) \
+#define muse_recorder_msg_event5(api, event, class, module, type1, param1, type2, param2, type3, param3, type4, param4, type5, param5) \
        do{     \
                char *__sndMsg__; \
                type1 __value1__ = (type1)param1; \
@@ -533,6 +559,7 @@ typedef const char* STRING;
                type5 __value5__ = (type5)param5; \
                __sndMsg__ = muse_core_msg_json_factory_new(api, \
                                MUSE_TYPE_INT, PARAM_EVENT, event, \
+                               MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                                MUSE_TYPE_##type1, #param1, __value1__, \
                                MUSE_TYPE_##type2, #param2, __value2__, \
                                MUSE_TYPE_##type3, #param3, __value3__, \

diff --git a/muse/src/muse_recorder_dispatcher.c b/muse/src/muse_recorder_dispatcher.c
index 44d9aae..d61706e 100644 (file)
--- a/muse/src/muse_recorder_dispatcher.c
+++ b/muse/src/muse_recorder_dispatcher.c
@@ -69,6 +69,7 @@ void _recorder_disp_recording_limit_reached_cb(recorder_recording_limit_type_e t
 
        muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                                 module,
                                 INT, type);
 
@@ -88,6 +89,7 @@ void _recorder_disp_recording_status_cb(unsigned long long elapsed_time, unsigne
 
        muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                                 module,
                                 INT64, cb_elapsed_time,
                                 INT64, cb_file_size);
@@ -106,6 +108,7 @@ void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e
 
        muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                                 module,
                                 INT, previous,
                                 INT, current,
@@ -125,6 +128,7 @@ void _recorder_disp_interrupted_cb(recorder_policy_e policy, recorder_state_e pr
 
        muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                                 module,
                                 INT, policy,
                                 INT, previous,
@@ -144,6 +148,7 @@ void _recorder_disp_error_cb(recorder_error_e error, recorder_state_e current_st
 
        muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_ERROR,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
                                 module,
                                 INT, error,
                                 INT, current_state);
@@ -223,6 +228,7 @@ void _recorder_disp_audio_stream_cb(void* stream, int size, audio_sample_type_e
        /* send message */
        muse_recorder_msg_event5(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
                                 module,
                                 INT, size,
                                 INT, format,
@@ -244,6 +250,7 @@ void _recorder_disp_foreach_supported_video_resolution_cb(int width, int height,
 
        muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
                                 module,
                                 INT, width,
                                 INT, height);
@@ -262,6 +269,7 @@ void _recorder_disp_foreach_supported_file_format_cb(recorder_file_format_e form
 
        muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
                                 module,
                                 INT, format);
 
@@ -279,6 +287,7 @@ void _recorder_disp_foreach_supported_audio_encoder_cb(recorder_audio_codec_e co
 
        muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
                                 module,
                                 INT, codec);
 
@@ -296,6 +305,7 @@ void _recorder_disp_foreach_supported_video_encoder_cb(recorder_video_codec_e co
 
        muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
                                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
+                                MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
                                 module,
                                 INT, codec);
 
@@ -375,6 +385,7 @@ int recorder_dispatcher_create(muse_module_h module)
        int client_fd = -1;
        int pid = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        intptr_t camera_handle = 0;
        muse_recorder_handle_s *muse_recorder = NULL;
        muse_camera_handle_s *muse_camera = NULL;
@@ -389,7 +400,7 @@ int recorder_dispatcher_create(muse_module_h module)
        if (!muse_core_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
                LOGE("security check failed");
                ret = RECORDER_ERROR_PERMISSION_DENIED;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -398,7 +409,7 @@ int recorder_dispatcher_create(muse_module_h module)
        if (muse_recorder == NULL) {
                ret = RECORDER_ERROR_OUT_OF_MEMORY;
                LOGE("handle alloc failed 0x%x", ret);
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -414,7 +425,7 @@ int recorder_dispatcher_create(muse_module_h module)
                muse_recorder = NULL;
 
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
 
                return MUSE_RECORDER_ERROR_NONE;
        }
@@ -429,7 +440,7 @@ int recorder_dispatcher_create(muse_module_h module)
                        muse_recorder = NULL;
 
                        ret = RECORDER_ERROR_INVALID_PARAMETER;
-                       muse_recorder_msg_return(api, ret, module);
+                       muse_recorder_msg_return(api, class, ret, module);
                        return MUSE_RECORDER_ERROR_NONE;
                }
 
@@ -458,14 +469,14 @@ int recorder_dispatcher_create(muse_module_h module)
 
                handle = (intptr_t)muse_recorder->recorder_handle;
                muse_core_ipc_set_handle(module, (intptr_t)muse_recorder);
-               muse_recorder_msg_return1(api, ret, module, POINTER, handle);
+               muse_recorder_msg_return1(api, class, ret, module, POINTER, handle);
        } else {
                g_mutex_clear(&muse_recorder->list_lock);
                free(muse_recorder);
                muse_recorder = NULL;
 
                LOGE("error 0x%d", ret);
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
        }
 
        return MUSE_RECORDER_ERROR_NONE;
@@ -476,12 +487,13 @@ int recorder_dispatcher_destroy(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_handle_s *muse_recorder = NULL;
        muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -497,7 +509,7 @@ int recorder_dispatcher_destroy(muse_module_h module)
                LOGE("recorder destroy failed 0x%x", ret);
        }
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -506,6 +518,7 @@ int recorder_dispatcher_get_state(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        recorder_state_e get_state = RECORDER_STATE_NONE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
@@ -513,13 +526,13 @@ int recorder_dispatcher_get_state(muse_module_h module)
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_state(muse_recorder->recorder_handle, &get_state);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_state);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_state);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -528,19 +541,20 @@ int recorder_dispatcher_prepare(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_prepare(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -549,19 +563,20 @@ int recorder_dispatcher_unprepare(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unprepare(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -570,19 +585,20 @@ int recorder_dispatcher_start(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_START;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_start(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -591,19 +607,20 @@ int recorder_dispatcher_pause(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_pause(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -612,19 +629,20 @@ int recorder_dispatcher_commit(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_commit(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -633,19 +651,20 @@ int recorder_dispatcher_cancel(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_cancel(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -656,13 +675,14 @@ int recorder_dispatcher_set_video_resolution(muse_module_h module)
        int width = 0;
        int height = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -671,7 +691,7 @@ int recorder_dispatcher_set_video_resolution(muse_module_h module)
 
        ret = legacy_recorder_set_video_resolution(muse_recorder->recorder_handle, width, height);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -682,19 +702,20 @@ int recorder_dispatcher_get_video_resolution(muse_module_h module)
        int get_width = 0;
        int get_height = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_video_resolution(muse_recorder->recorder_handle, &get_width, &get_height);
 
-       muse_recorder_msg_return2(api, ret, module,
+       muse_recorder_msg_return2(api, class, ret, module,
                                  INT, get_width,
                                  INT, get_height);
 
@@ -705,13 +726,14 @@ int recorder_dispatcher_foreach_supported_video_resolution(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -719,7 +741,7 @@ int recorder_dispatcher_foreach_supported_video_resolution(muse_module_h module)
                                                                 (recorder_supported_video_resolution_cb)_recorder_disp_foreach_supported_video_resolution_cb,
                                                                 (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -729,20 +751,20 @@ int recorder_dispatcher_get_audio_level(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        double get_level = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_audio_level(muse_recorder->recorder_handle, &get_level);
 
-       muse_recorder_msg_return1(api, ret, module,
-                                 DOUBLE, get_level);
+       muse_recorder_msg_return1(api, class, ret, module, DOUBLE, get_level);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -752,13 +774,14 @@ int recorder_dispatcher_set_filename(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        char filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -766,7 +789,7 @@ int recorder_dispatcher_set_filename(muse_module_h module)
 
        ret = legacy_recorder_set_filename(muse_recorder->recorder_handle, filename);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -776,21 +799,22 @@ int recorder_dispatcher_get_filename(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        char *get_filename = NULL;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_filename(muse_recorder->recorder_handle, &get_filename);
        if (ret == RECORDER_ERROR_NONE && get_filename) {
-               muse_recorder_msg_return1(api, ret, module, STRING, get_filename);
+               muse_recorder_msg_return1(api, class, ret, module, STRING, get_filename);
        } else {
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
        }
 
        if (get_filename) {
@@ -806,13 +830,14 @@ int recorder_dispatcher_set_file_format(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_file_format_e set_format = RECORDER_FILE_FORMAT_3GP;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -820,7 +845,7 @@ int recorder_dispatcher_set_file_format(muse_module_h module)
 
        ret = legacy_recorder_set_file_format(muse_recorder->recorder_handle, set_format);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -830,19 +855,20 @@ int recorder_dispatcher_get_file_format(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_file_format_e get_format = RECORDER_FILE_FORMAT_3GP;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_file_format(muse_recorder->recorder_handle, &get_format);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_format);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_format);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -851,13 +877,14 @@ int recorder_dispatcher_set_state_changed_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -865,7 +892,7 @@ int recorder_dispatcher_set_state_changed_cb(muse_module_h module)
                                                   (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
                                                   (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -874,19 +901,20 @@ int recorder_dispatcher_unset_state_changed_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_state_changed_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -895,13 +923,14 @@ int recorder_dispatcher_set_interrupted_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -909,7 +938,7 @@ int recorder_dispatcher_set_interrupted_cb(muse_module_h module)
                                                 (recorder_interrupted_cb)_recorder_disp_interrupted_cb,
                                                 (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -918,19 +947,20 @@ int recorder_dispatcher_unset_interrupted_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_interrupted_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -939,13 +969,14 @@ int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -953,7 +984,7 @@ int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
                                                  (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb,
                                                  (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -962,19 +993,20 @@ int recorder_dispatcher_unset_audio_stream_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_audio_stream_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -983,13 +1015,14 @@ int recorder_dispatcher_set_error_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -997,7 +1030,7 @@ int recorder_dispatcher_set_error_cb(muse_module_h module)
                                           (recorder_error_cb)_recorder_disp_error_cb,
                                           (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1006,19 +1039,20 @@ int recorder_dispatcher_unset_error_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_error_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1027,13 +1061,14 @@ int recorder_dispatcher_set_recording_status_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1041,7 +1076,7 @@ int recorder_dispatcher_set_recording_status_cb(muse_module_h module)
                                                      (recorder_recording_status_cb)_recorder_disp_recording_status_cb,
                                                      (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1050,19 +1085,20 @@ int recorder_dispatcher_unset_recording_status_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_recording_status_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1071,20 +1107,21 @@ int recorder_dispatcher_set_recording_limit_reached_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_set_recording_limit_reached_cb(muse_recorder->recorder_handle,
                                                             (recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
                                                             (void *)module);
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1093,19 +1130,20 @@ int recorder_dispatcher_unset_recording_limit_reached_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_unset_recording_limit_reached_cb(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1114,13 +1152,14 @@ int recorder_dispatcher_foreach_supported_file_format(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1128,7 +1167,7 @@ int recorder_dispatcher_foreach_supported_file_format(muse_module_h module)
                                                            (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
                                                            (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1138,13 +1177,14 @@ int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int kbyte = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1152,7 +1192,7 @@ int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
 
        ret = legacy_recorder_attr_set_size_limit(muse_recorder->recorder_handle, kbyte);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1162,13 +1202,14 @@ int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int second = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1176,7 +1217,7 @@ int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
 
        ret = legacy_recorder_attr_set_time_limit(muse_recorder->recorder_handle, second);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1186,13 +1227,14 @@ int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_audio_device_e set_device = RECORDER_AUDIO_DEVICE_MIC;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1200,7 +1242,7 @@ int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
 
        ret = legacy_recorder_attr_set_audio_device(muse_recorder->recorder_handle, set_device);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1210,13 +1252,14 @@ int recorder_dispatcher_set_audio_encoder(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_audio_codec_e set_codec = RECORDER_AUDIO_CODEC_AMR;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1224,7 +1267,7 @@ int recorder_dispatcher_set_audio_encoder(muse_module_h module)
 
        ret = legacy_recorder_set_audio_encoder(muse_recorder->recorder_handle, set_codec);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1234,19 +1277,20 @@ int recorder_dispatcher_get_audio_encoder(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_audio_codec_e get_codec = RECORDER_AUDIO_CODEC_AMR;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_audio_encoder(muse_recorder->recorder_handle, &get_codec);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_codec);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_codec);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1256,13 +1300,14 @@ int recorder_dispatcher_set_video_encoder(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_video_codec_e set_codec = RECORDER_VIDEO_CODEC_MPEG4;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1270,7 +1315,7 @@ int recorder_dispatcher_set_video_encoder(muse_module_h module)
 
        ret = legacy_recorder_set_video_encoder(muse_recorder->recorder_handle, set_codec);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1280,19 +1325,20 @@ int recorder_dispatcher_get_video_encoder(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_video_codec_e get_codec = RECORDER_VIDEO_CODEC_MPEG4;
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_get_video_encoder(muse_recorder->recorder_handle, &get_codec);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_codec);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_codec);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1302,13 +1348,14 @@ int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int samplerate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1316,7 +1363,7 @@ int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
 
        ret = legacy_recorder_attr_set_audio_samplerate(muse_recorder->recorder_handle, samplerate);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1326,13 +1373,14 @@ int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int bitrate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1340,7 +1388,7 @@ int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
 
        ret = legacy_recorder_attr_set_audio_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1350,13 +1398,14 @@ int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int bitrate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1364,7 +1413,7 @@ int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
 
        ret = legacy_recorder_attr_set_video_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1374,19 +1423,20 @@ int recorder_dispatcher_attr_get_size_limit(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_kbyte = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_size_limit(muse_recorder->recorder_handle, &get_kbyte);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_kbyte);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_kbyte);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1396,19 +1446,20 @@ int recorder_dispatcher_attr_get_time_limit(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_second = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_time_limit(muse_recorder->recorder_handle, &get_second);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_second);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_second);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1418,19 +1469,20 @@ int recorder_dispatcher_attr_get_audio_device(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_audio_device_e get_device = RECORDER_AUDIO_DEVICE_MIC;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_audio_device(muse_recorder->recorder_handle, &get_device);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_device);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_device);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1440,19 +1492,20 @@ int recorder_dispatcher_attr_get_audio_samplerate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_samplerate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_audio_samplerate(muse_recorder->recorder_handle, &get_samplerate);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_samplerate);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_samplerate);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1462,19 +1515,20 @@ int recorder_dispatcher_attr_get_audio_encoder_bitrate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_bitrate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_audio_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_bitrate);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_bitrate);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1484,19 +1538,20 @@ int recorder_dispatcher_attr_get_video_encoder_bitrate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_bitrate = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_video_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_bitrate);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_bitrate);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1505,13 +1560,14 @@ int recorder_dispatcher_foreach_supported_audio_encoder(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1519,7 +1575,7 @@ int recorder_dispatcher_foreach_supported_audio_encoder(muse_module_h module)
                                                              (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
                                                              (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1528,13 +1584,14 @@ int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
+               muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1542,7 +1599,7 @@ int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
                                                              (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
                                                              (void *)module);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1552,13 +1609,14 @@ int recorder_dispatcher_attr_set_mute(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int set_enable = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1566,7 +1624,7 @@ int recorder_dispatcher_attr_set_mute(muse_module_h module)
 
        ret = legacy_recorder_attr_set_mute(muse_recorder->recorder_handle, (bool)set_enable);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1575,19 +1633,20 @@ int recorder_dispatcher_attr_is_muted(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_is_muted(muse_recorder->recorder_handle);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1597,13 +1656,14 @@ int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        double rate = 1.0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1611,7 +1671,7 @@ int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
 
        ret = legacy_recorder_attr_set_recording_motion_rate(muse_recorder->recorder_handle, rate);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1621,13 +1681,14 @@ int recorder_dispatcher_attr_get_recording_motion_rate(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        double get_rate = 1.0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1635,7 +1696,7 @@ int recorder_dispatcher_attr_get_recording_motion_rate(muse_module_h module)
 
        LOGD("get rate %lf", get_rate);
 
-       muse_recorder_msg_return1(api, ret, module, DOUBLE, get_rate);
+       muse_recorder_msg_return1(api, class, ret, module, DOUBLE, get_rate);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1645,13 +1706,14 @@ int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int channel_count = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1659,7 +1721,7 @@ int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
 
        ret = legacy_recorder_attr_set_audio_channel(muse_recorder->recorder_handle, channel_count);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1669,19 +1731,20 @@ int recorder_dispatcher_attr_get_audio_channel(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        int get_channel_count = 0;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_audio_channel(muse_recorder->recorder_handle, &get_channel_count);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_channel_count);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_channel_count);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1691,13 +1754,14 @@ int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_rotation_e set_orientation = RECORDER_ROTATION_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1705,7 +1769,7 @@ int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
 
        ret = legacy_recorder_attr_set_orientation_tag(muse_recorder->recorder_handle, set_orientation);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1715,19 +1779,20 @@ int recorder_dispatcher_attr_get_orientation_tag(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        recorder_rotation_e get_orientation = RECORDER_ROTATION_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
        ret = legacy_recorder_attr_get_orientation_tag(muse_recorder->recorder_handle, &get_orientation);
 
-       muse_recorder_msg_return1(api, ret, module, INT, get_orientation);
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_orientation);
 
        return MUSE_RECORDER_ERROR_NONE;
 }
@@ -1737,13 +1802,14 @@ int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        char root_directory[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
        muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY;
+       muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
        muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, ret, module);
+               muse_recorder_msg_return(api, class, ret, module);
                return MUSE_RECORDER_ERROR_NONE;
        }
 
@@ -1751,7 +1817,7 @@ int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
 
        ret = legacy_recorder_attr_set_root_directory(muse_recorder->recorder_handle, root_directory);
 
-       muse_recorder_msg_return(api, ret, module);
+       muse_recorder_msg_return(api, class, ret, module);
 
        return MUSE_RECORDER_ERROR_NONE;
 }

diff --git a/packaging/mmsvc-recorder.spec b/packaging/mmsvc-recorder.spec
index 835de08..0f25106 100644 (file)
--- a/packaging/mmsvc-recorder.spec
+++ b/packaging/mmsvc-recorder.spec
@@ -1,6 +1,6 @@
 Name:       mmsvc-recorder
 Summary:    A Recorder module for muse server
-Version:    0.2.7
+Version:    0.2.8
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0