Remove Handle arg, Change Client to Module, Muse naming

Change-Id:Ie1c7edc107176a13cd1a770fb86a675b6200193f
Signed-off-by: sejong123.park <sejong123.park@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
old mode 100755 (executable)
new mode 100644 (file)
index 0fe2382..5ef5384
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,7 +72,7 @@ SET_TARGET_PROPERTIES(${fw_name}
      CLEAN_DIRECT_OUTPUT 1
 )
 
-TARGET_LINK_LIBRARIES(${fw_name} mused-recorder ${${fw_name}_LDFLAGS})
+TARGET_LINK_LIBRARIES(${fw_name} muse-recorder ${${fw_name}_LDFLAGS})
 
 INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR})
 INSTALL(

diff --git a/capi-media-recorder.pc.in b/capi-media-recorder.pc.in
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/include/recorder_private.h b/include/recorder_private.h
index dc01d2357ab1c1eb9010dbe27da6d27ddc7a6282..19d34047e62ace13b41484450050975ee6f218e5 100644 (file)
--- a/include/recorder_private.h
+++ b/include/recorder_private.h
@@ -21,7 +21,7 @@
 #include <camera.h>
 #include <mm_camcorder.h>
 #include <recorder.h>
-#include <mmsvc_core.h>
+#include <muse_core.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -45,12 +45,12 @@ typedef struct _callback_cb_info {
        GThread *thread;
        gint running;
        gint fd;
-       gpointer user_cb[MMSVC_RECORDER_EVENT_TYPE_NUM];
-       gpointer user_cb_completed[MMSVC_RECORDER_EVENT_TYPE_NUM];
-       gpointer user_data[MMSVC_RECORDER_EVENT_TYPE_NUM];
-       gchar recvMsg[MM_MSG_MAX_LENGTH];
-       gchar recvApiMsg[MM_MSG_MAX_LENGTH];
-       gchar recvEventMsg[MM_MSG_MAX_LENGTH];
+       gpointer user_cb[MUSE_RECORDER_EVENT_TYPE_NUM];
+       gpointer user_cb_completed[MUSE_RECORDER_EVENT_TYPE_NUM];
+       gpointer user_data[MUSE_RECORDER_EVENT_TYPE_NUM];
+       gchar recvMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
+       gchar recvApiMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
+       gchar recvEventMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
        GCond *pCond;
        GMutex *pMutex;
        gint *activating;

diff --git a/src/recorder.c b/src/recorder.c
index 4d694551be9bc0a2265f6f0d6f05fc80e147e9ec..180d1260a7f4a3337d8d38f6d4ec6818e7d63bb3 100644 (file)
--- a/src/recorder.c
+++ b/src/recorder.c
@@ -19,94 +19,94 @@
 #include <string.h>
 #include <mm_types.h>
 #include <recorder.h>
-#include <mused_recorder.h>
-#include <mused_recorder_msg.h>
-#include <mmsvc_core_ipc.h>
+#include <muse_recorder.h>
+#include <muse_recorder_msg.h>
+#include <muse_core_ipc.h>
 #include <recorder_private.h>
 #include <glib.h>
-#include <mmsvc_core.h>
-#include <mmsvc_core_msg_json.h>
+#include <muse_core.h>
+#include <muse_core_msg_json.h>
 #include <dlog.h>
 
 #ifdef LOG_TAG
 #undef LOG_TAG
 #endif
-#define LOG_TAG "TIZEN_N_RECORDER2"
+#define LOG_TAG "TIZEN_N_RECORDER"
 
-static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_event_e event )
+static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_event_e event )
 {
        char *recvMsg = cb_info->recvMsg;
        LOGD("get event %d", event);
 
        switch (event) {
-               case MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE:
+               case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
                {
                        int cb_previous, cb_current, cb_by_policy;
-                       mmsvc_recorder_msg_get(cb_previous, recvMsg);
-                       mmsvc_recorder_msg_get(cb_current, recvMsg);
-                       mmsvc_recorder_msg_get(cb_by_policy, recvMsg);
+                       muse_recorder_msg_get(cb_previous, recvMsg);
+                       muse_recorder_msg_get(cb_current, recvMsg);
+                       muse_recorder_msg_get(cb_by_policy, recvMsg);
                        ((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)cb_previous,
                                                                                                        (recorder_state_e)cb_current,
                                                                                                        (bool)cb_by_policy,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
+               case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
                {
                        int cb_type;
-                       mmsvc_recorder_msg_get(cb_type, recvMsg);
+                       muse_recorder_msg_get(cb_type, recvMsg);
                        ((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)cb_type,
                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS:
+               case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
                {
                        double cb_elapsed_time;
                        double cb_file_size;
-                       mmsvc_recorder_msg_get(cb_elapsed_time, recvMsg);
-                       mmsvc_recorder_msg_get(cb_file_size, recvMsg);
+                       muse_recorder_msg_get(cb_elapsed_time, recvMsg);
+                       muse_recorder_msg_get(cb_file_size, recvMsg);
                        ((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time,
                                                                                                                        (unsigned long long)cb_file_size,
                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED:
+               case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
                {
                        int cb_policy, cb_previous, cb_current;
-                       mmsvc_recorder_msg_get(cb_policy, recvMsg);
-                       mmsvc_recorder_msg_get(cb_previous, recvMsg);
-                       mmsvc_recorder_msg_get(cb_current, recvMsg);
+                       muse_recorder_msg_get(cb_policy, recvMsg);
+                       muse_recorder_msg_get(cb_previous, recvMsg);
+                       muse_recorder_msg_get(cb_current, recvMsg);
                        ((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)cb_policy,
                                                                                                                (recorder_state_e)cb_previous,
                                                                                                                (recorder_state_e)cb_current,
                                                                                                                cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM:
+               case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
                {
-                       mmsvc_recorder_transport_info_s transport_info;
+                       muse_recorder_transport_info_s transport_info;
                        int tKey = 0;
                        int cb_size = 0;
                        int cb_format;
                        int cb_channel;
                        int cb_timestamp;
                        unsigned char *stream = NULL;
-                       mmsvc_recorder_msg_get(tKey, recvMsg);
+                       muse_recorder_msg_get(tKey, recvMsg);
 
                        if (tKey != 0) {
                                transport_info.tbm_key = tKey;
                                LOGE("Read key_info INFO : %d", transport_info.tbm_key);
 
-                               if(mmsvc_recorder_ipc_init_tbm(&transport_info) == FALSE) {
+                               if(muse_recorder_ipc_init_tbm(&transport_info) == FALSE) {
                                        LOGE("Initialize TBM ERROR!!");
                                        break;
                                }
 
-                               if(mmsvc_recorder_ipc_import_tbm(&transport_info) == FALSE) {
+                               if(muse_recorder_ipc_import_tbm(&transport_info) == FALSE) {
                                        LOGE("Import TBM Key ERROR!!");
                                        break;
                                } else {
-                                       mmsvc_recorder_msg_get(cb_size, recvMsg);
+                                       muse_recorder_msg_get(cb_size, recvMsg);
                                        if (cb_size > 0) {
                                                stream = (unsigned char *)transport_info.bo_handle.ptr;
                                        }
@@ -115,9 +115,9 @@ static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_e
                                LOGE("Get KEY INFO sock msg ERROR!!");
                                break;
                        }
-                       mmsvc_recorder_msg_get(cb_format, recvMsg);
-                       mmsvc_recorder_msg_get(cb_channel, recvMsg);
-                       mmsvc_recorder_msg_get(cb_timestamp, recvMsg);
+                       muse_recorder_msg_get(cb_format, recvMsg);
+                       muse_recorder_msg_get(cb_channel, recvMsg);
+                       muse_recorder_msg_get(cb_timestamp, recvMsg);
                        ((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)stream,
                                                                                                        cb_size,
                                                                                                        (audio_sample_type_e)cb_format,
@@ -125,49 +125,49 @@ static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_recorder_e
                                                                                                        (unsigned int)cb_timestamp,
                                                                                                        cb_info->user_data[event]);
                        //unref tbm after hand over the buffer.
-                       mmsvc_recorder_ipc_unref_tbm(&transport_info);
+                       muse_recorder_ipc_unref_tbm(&transport_info);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_ERROR:
+               case MUSE_RECORDER_EVENT_TYPE_ERROR:
                {
                        int cb_error, cb_current_state;
-                       mmsvc_recorder_msg_get(cb_error, recvMsg);
-                       mmsvc_recorder_msg_get(cb_current_state, recvMsg);
+                       muse_recorder_msg_get(cb_error, recvMsg);
+                       muse_recorder_msg_get(cb_current_state, recvMsg);
                        ((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)cb_error,
                                                                                                        (recorder_state_e)cb_current_state,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
+               case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
                {
                        int cb_codec;
-                       mmsvc_recorder_msg_get(cb_codec, recvMsg);
+                       muse_recorder_msg_get(cb_codec, recvMsg);
                        ((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)cb_codec,
                                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
+               case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
                {
                        int cb_format;
-                       mmsvc_recorder_msg_get(cb_format, recvMsg);
+                       muse_recorder_msg_get(cb_format, recvMsg);
                        ((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)cb_format,
                                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
+               case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
                {
                        int cb_codec;
-                       mmsvc_recorder_msg_get(cb_codec, recvMsg);
+                       muse_recorder_msg_get(cb_codec, recvMsg);
                        ((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)cb_codec,
                                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
+               case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
                {
                        int width;
                        int height;
-                       mmsvc_recorder_msg_get(width, recvMsg);
-                       mmsvc_recorder_msg_get(height, recvMsg);
+                       muse_recorder_msg_get(width, recvMsg);
+                       muse_recorder_msg_get(height, recvMsg);
                        ((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width,
                                                                                                                                        height,
                                                                                                                                        cb_info->user_data[event]);
@@ -191,17 +191,17 @@ static void *_client_cb_handler(gpointer data)
        int prev_pos = 0;
        callback_cb_info_s *cb_info = data;
        char *recvMsg = cb_info->recvMsg;
-       char parseStr[MMSVC_PARSE_STRING_SIZE][MMSVC_MSG_MAX_LENGTH] = {{0,0},};
+       char parseStr[MUSE_RECORDER_PARSE_STRING_SIZE][MUSE_RECORDER_MSG_MAX_LENGTH] = {{0,0},};
 
        while (g_atomic_int_get(&cb_info->running)) {
-               ret = mmsvc_core_ipc_recv_msg(cb_info->fd, recvMsg);
+               ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg);
                if (ret <= 0)
                        break;
                recvMsg[ret] = '\0';
                str_pos = 0;
                prev_pos = 0;
                num_token = 0;
-               memset(parseStr, 0, MMSVC_PARSE_STRING_SIZE * MMSVC_MSG_MAX_LENGTH);
+               memset(parseStr, 0, MUSE_RECORDER_PARSE_STRING_SIZE * MUSE_RECORDER_MSG_MAX_LENGTH);
                LOGD("recvMSg : %s, length : %d", recvMsg, ret);
 
                /* Need to split the combined entering msgs.
@@ -218,10 +218,10 @@ static void *_client_cb_handler(gpointer data)
                /* Re-construct to the useful single msg. */
                for (i = 0; i < num_token; i++) {
 
-                       if (i >= MMSVC_PARSE_STRING_SIZE)
+                       if (i >= MUSE_RECORDER_PARSE_STRING_SIZE)
                                break;
-                       if (mmsvc_recorder_msg_get(api, &(parseStr[i][0]))) {
-                               if(api < MMSVC_RECORDER_API_MAX){
+                       if (muse_recorder_msg_get(api, &(parseStr[i][0]))) {
+                               if(api < MUSE_RECORDER_API_MAX){
                                        LOGD("api : %d, wait ends.", api);
                                        g_mutex_lock(&(cb_info->pMutex[api]));
                                        /* The api msgs should be distinguished from the event msg. */
@@ -231,20 +231,20 @@ static void *_client_cb_handler(gpointer data)
                                        cb_info->activating[api] = 1;
                                        g_cond_signal(&(cb_info->pCond[api]));
                                        g_mutex_unlock(&(cb_info->pMutex[api]));
-                                       if(api == MMSVC_RECORDER_API_DESTROY) {
+                                       if(api == MUSE_RECORDER_API_DESTROY) {
                                                g_atomic_int_set(&cb_info->running, 0);
                                                LOGD("close client cb handler");
                                        }
 
-                               } else if(api == MMSVC_RECORDER_CB_EVENT) {
+                               } else if(api == MUSE_RECORDER_CB_EVENT) {
                                        int event;
-                                       if (mmsvc_recorder_msg_get(event, &(parseStr[i][0]))) {
+                                       if (muse_recorder_msg_get(event, &(parseStr[i][0]))) {
                                                LOGD("go callback : %d", event);
                                                _client_user_callback(cb_info, event);
                                        }
                                }
                        }else{
-                               LOGD("mmsvc_recorder_msg_get FAIL");
+                               LOGD("muse_recorder_msg_get FAIL");
                        }
                }
        }
@@ -262,9 +262,9 @@ static callback_cb_info_s *_client_callback_new(gint sockfd)
        g_return_val_if_fail(sockfd > 0, NULL);
 
        cb_info = g_new0(callback_cb_info_s, 1);
-       recorder_cond = g_new0(GCond, MMSVC_RECORDER_API_MAX);
-       recorder_mutex = g_new0(GMutex, MMSVC_RECORDER_API_MAX);
-       recorder_activ = g_new0(gint, MMSVC_RECORDER_API_MAX);
+       recorder_cond = g_new0(GCond, MUSE_RECORDER_API_MAX);
+       recorder_mutex = g_new0(GMutex, MUSE_RECORDER_API_MAX);
+       recorder_activ = g_new0(gint, MUSE_RECORDER_API_MAX);
 
        g_atomic_int_set(&cb_info->running, 1);
        cb_info->fd = sockfd;
@@ -278,7 +278,7 @@ static callback_cb_info_s *_client_callback_new(gint sockfd)
        return cb_info;
 }
 
-static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_s *cb_info, int time_out)
+static int client_wait_for_cb_return(muse_recorder_api_e api, callback_cb_info_s *cb_info, int time_out)
 {
        int ret = RECORDER_ERROR_NONE;
        gint64 end_time;
@@ -290,7 +290,7 @@ static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_
        if (cb_info->activating[api] != 1) {
                if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
                        LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
-                       if (!mmsvc_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+                       if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
                                ret = RECORDER_ERROR_INVALID_OPERATION;
                        } else {
                                LOGD("API %d passed successfully", api);
@@ -301,7 +301,7 @@ static int client_wait_for_cb_return(mmsvc_recorder_api_e api, callback_cb_info_
        } else {
                LOGD("condition is already checked for the api : %d.", api);
                cb_info->activating[api] = 0;
-               if (!mmsvc_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+               if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
                        ret = RECORDER_ERROR_INVALID_OPERATION;
                } else {
                        LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
@@ -346,11 +346,11 @@ int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
        int ret = RECORDER_ERROR_NONE;
        camera_cli_s *camera_pc = (camera_cli_s *)camera;
        recorder_cli_s *pc;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CREATE;
-       mmsvc_api_client_e api_client = MMSVC_RECORDER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
+       muse_core_api_module_e muse_module = MUSE_RECORDER;
        intptr_t camera_handle = (intptr_t)camera_pc->remote_handle;
        intptr_t handle;
-       int recorder_type = MMSVC_RECORDER_TYPE_VIDEO;
+       int recorder_type = MUSE_RECORDER_TYPE_VIDEO;
 
        pc = g_new0(recorder_cli_s, 1);
        if (pc == NULL) {
@@ -358,21 +358,22 @@ int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
        }
 
        LOGD("remote handle : 0x%x", camera_handle);
-       sock_fd = mmsvc_core_client_new();
-       sndMsg = mmsvc_core_msg_json_factory_new(api, "client", api_client,
-                                                                                             MUSED_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
-                                                                                             MUSED_TYPE_POINTER, PARAM_CAMERA_HANDLE, camera_handle,
-                                                                                             0);
-       mmsvc_core_ipc_send_msg(sock_fd, sndMsg);
+       sock_fd = muse_core_client_new();
+       sndMsg = muse_core_msg_json_factory_new(api,
+                                             MUSE_TYPE_INT, "module", muse_module,
+                                             MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
+                                             MUSE_TYPE_POINTER, "camera_handle", camera_handle,
+                                             0);
+       muse_core_ipc_send_msg(sock_fd, sndMsg);
        LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg);
-       mmsvc_core_msg_json_factory_free(sndMsg);
+       muse_core_msg_json_factory_free(sndMsg);
 
        pc->cb_info = _client_callback_new(sock_fd);
        LOGD("cb info : %d", pc->cb_info->fd);
 
        ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
+               muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
                if (handle == 0) {
                        LOGE("Receiving Handle Failed!!");
                        goto ErrorExit;
@@ -405,17 +406,20 @@ int recorder_create_audiorecorder(recorder_h *recorder)
        int ret = RECORDER_ERROR_NONE;
        recorder_cli_s *pc = NULL;
 
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CREATE;
-       mmsvc_api_client_e api_client = MMSVC_RECORDER;
-       int recorder_type = MMSVC_RECORDER_TYPE_AUDIO;
+       muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
+       muse_core_api_module_e muse_module = MUSE_RECORDER;
+       int recorder_type = MUSE_RECORDER_TYPE_AUDIO;
 
-       sock_fd = mmsvc_core_client_new();
-       sndMsg = mmsvc_core_msg_json_factory_new(api, "client", api_client,
-                                                                                             MUSED_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
-                                                                                             0);
-       mmsvc_core_ipc_send_msg(sock_fd, sndMsg);
+       LOGW("Enter");
+       sock_fd = muse_core_client_new();
+       sndMsg = muse_core_msg_json_factory_new(api,
+                                             MUSE_TYPE_INT, "module", muse_module,
+                                             MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
+                                             0);
+
+       muse_core_ipc_send_msg(sock_fd, sndMsg);
        LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg);
-       mmsvc_core_msg_json_factory_free(sndMsg);
+       muse_core_msg_json_factory_free(sndMsg);
 
        pc = g_new0(recorder_cli_s, 1);
        if (pc == NULL) {
@@ -423,12 +427,10 @@ int recorder_create_audiorecorder(recorder_h *recorder)
        }
 
        pc->cb_info = _client_callback_new(sock_fd);
-       LOGD("cb info : %d", pc->cb_info->fd);
-
        ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
        if (ret == RECORDER_ERROR_NONE) {
                intptr_t handle = 0;
-               mmsvc_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
+               muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
                if (handle == 0) {
                        LOGE("Receiving Handle Failed!!");
                        goto ErrorExit;
@@ -463,7 +465,7 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state)
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_STATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
@@ -473,10 +475,10 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state)
        int get_state;
 
        LOGD("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_state, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_state, pc->cb_info->recvMsg);
                *state = (recorder_state_e)get_state;
        }
        LOGD("ret : 0x%x, get_state : %d", ret, get_state);
@@ -491,7 +493,7 @@ int recorder_destroy(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_DESTROY;
+       muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -508,8 +510,7 @@ int recorder_destroy(recorder_h recorder)
                return RECORDER_ERROR_INVALID_OPERATION;
        }
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGD("ret : 0x%x", ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        _client_callback_destroy(pc->cb_info);
        g_free(pc);
        pc = NULL;
@@ -526,7 +527,7 @@ int recorder_prepare(recorder_h recorder)
        }
 
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_PREPARE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -537,7 +538,7 @@ int recorder_prepare(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
        LOGD("ret : 0x%x", ret);
 
@@ -552,7 +553,7 @@ int recorder_unprepare(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNPREPARE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -563,7 +564,7 @@ int recorder_unprepare(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -576,7 +577,7 @@ int recorder_start(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_START;
+       muse_recorder_api_e api = MUSE_RECORDER_API_START;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -587,7 +588,7 @@ int recorder_start(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -600,7 +601,7 @@ int recorder_pause(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_PAUSE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -611,7 +612,7 @@ int recorder_pause(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -624,7 +625,7 @@ int recorder_commit(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_COMMIT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -635,7 +636,7 @@ int recorder_commit(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -648,7 +649,7 @@ int recorder_cancel(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_CANCEL;
+       muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -659,7 +660,7 @@ int recorder_cancel(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -672,7 +673,7 @@ int recorder_set_video_resolution(recorder_h recorder, int width, int height)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_VIDEO_RESOLUTION;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -683,12 +684,12 @@ int recorder_set_video_resolution(recorder_h recorder, int width, int height)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send2(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, width,
-                                                               INT, height);
+       muse_recorder_msg_send2(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, width,
+                                                       INT, height);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -705,7 +706,7 @@ int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_VIDEO_RESOLUTION;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -718,10 +719,10 @@ int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_width, pc->cb_info->recvMsg);
-               mmsvc_recorder_msg_get(get_height, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_width, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_height, pc->cb_info->recvMsg);
                *width = get_width;
                *height = get_height;
        }
@@ -740,7 +741,7 @@ int recorder_foreach_supported_video_resolution(recorder_h recorder,
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
+       muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -750,10 +751,10 @@ int recorder_foreach_supported_video_resolution(recorder_h recorder,
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -767,7 +768,7 @@ int recorder_get_audio_level(recorder_h recorder, double *level)
        }
 
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_AUDIO_LEVEL;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -779,9 +780,9 @@ int recorder_get_audio_level(recorder_h recorder, double *level)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_level, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_level, pc->cb_info->recvMsg);
                *level = get_level;
        }
        LOGD("ret : 0x%x", ret);
@@ -801,7 +802,7 @@ int recorder_set_filename(recorder_h recorder,  const char *filename)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_FILENAME;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -812,7 +813,7 @@ int recorder_set_filename(recorder_h recorder,  const char *filename)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, STRING, filename);
+       muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, filename);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -830,7 +831,7 @@ int recorder_get_filename(recorder_h recorder,  char **filename)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_FILENAME;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -838,14 +839,14 @@ int recorder_get_filename(recorder_h recorder,  char **filename)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       char get_filename[MMSVC_RECORDER_MSG_MAX_LENGTH] = {0,};
+       char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg);
+               muse_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg);
                *filename = strdup(get_filename);
        }
        LOGD("ret : 0x%x, filename : %s", ret, *filename);
@@ -864,7 +865,7 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_FILE_FORMAT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -876,7 +877,7 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
 
        LOGD("ENTER, set_format : %d", set_format);
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_format);
+       muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -893,7 +894,7 @@ int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_FILE_FORMAT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -905,10 +906,10 @@ int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_format, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_format, pc->cb_info->recvMsg);
                LOGD("get_fileformat : %d", get_format);
                *format = (recorder_file_format_e)get_format;
        }
@@ -926,7 +927,7 @@ int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_STATE_CHANGED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -936,10 +937,10 @@ int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -952,7 +953,7 @@ int recorder_unset_state_changed_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_STATE_CHANGED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -963,7 +964,7 @@ int recorder_unset_state_changed_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -978,7 +979,7 @@ int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb cal
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_INTERRUPTED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -988,10 +989,10 @@ int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb cal
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1004,7 +1005,7 @@ int recorder_unset_interrupted_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_INTERRUPTED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1015,7 +1016,7 @@ int recorder_unset_interrupted_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1030,7 +1031,7 @@ int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb c
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_AUDIO_STREAM_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1040,10 +1041,10 @@ int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb c
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1056,7 +1057,7 @@ int recorder_unset_audio_stream_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_AUDIO_STREAM_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1067,7 +1068,7 @@ int recorder_unset_audio_stream_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1082,7 +1083,7 @@ int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_ERROR_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1092,10 +1093,10 @@ int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_ERROR] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_ERROR] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1108,7 +1109,7 @@ int recorder_unset_error_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_ERROR_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1119,7 +1120,7 @@ int recorder_unset_error_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1134,7 +1135,7 @@ int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_sta
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_RECORDING_STATUS_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1144,10 +1145,10 @@ int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_sta
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1160,7 +1161,7 @@ int recorder_unset_recording_status_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_RECORDING_STATUS_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1171,7 +1172,7 @@ int recorder_unset_recording_status_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1186,7 +1187,7 @@ int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_record
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1196,10 +1197,10 @@ int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_record
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1212,7 +1213,7 @@ int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1223,7 +1224,7 @@ int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1238,7 +1239,7 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1248,10 +1249,10 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1264,7 +1265,7 @@ int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_SIZE_LIMIT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1275,11 +1276,11 @@ int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, kbyte);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, kbyte);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1292,7 +1293,7 @@ int recorder_attr_set_time_limit(recorder_h recorder, int second)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_TIME_LIMIT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1303,11 +1304,11 @@ int recorder_attr_set_time_limit(recorder_h recorder, int second)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, second);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, second);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1320,7 +1321,7 @@ int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1332,11 +1333,11 @@ int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, set_device);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, set_device);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1354,7 +1355,7 @@ int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_AUDIO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1366,11 +1367,11 @@ int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, set_codec);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, set_codec);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1387,7 +1388,7 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_AUDIO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1399,9 +1400,9 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
                *codec = (recorder_audio_codec_e)get_codec;
        }
        LOGD("ret : 0x%x", ret);
@@ -1420,7 +1421,7 @@ int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_SET_VIDEO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1432,11 +1433,11 @@ int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, set_codec);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, set_codec);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1453,7 +1454,7 @@ int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *code
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_GET_VIDEO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1465,9 +1466,9 @@ int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *code
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
                *codec = (recorder_audio_codec_e)get_codec;
        }
        LOGD("ret : 0x%x", ret);
@@ -1486,7 +1487,7 @@ int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1497,11 +1498,11 @@ int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
 
        LOGD("ENTER, samplerate : %d", samplerate);
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, samplerate);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, samplerate);
        LOGD("ret : 0x%x, samplerate : %d", ret, samplerate);
        return ret;
 }
@@ -1518,7 +1519,7 @@ int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1529,11 +1530,11 @@ int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, bitrate);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, bitrate);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1547,7 +1548,7 @@ int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
        }
 
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1558,11 +1559,11 @@ int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, bitrate);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, bitrate);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1579,7 +1580,7 @@ int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_SIZE_LIMIT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1591,9 +1592,9 @@ int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg);
                *kbyte = get_kbyte;
        }
        LOGD("ret : 0x%x", ret);
@@ -1612,7 +1613,7 @@ int recorder_attr_get_time_limit(recorder_h recorder, int *second)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_TIME_LIMIT;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1624,9 +1625,9 @@ int recorder_attr_get_time_limit(recorder_h recorder, int *second)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_second, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_second, pc->cb_info->recvMsg);
                *second = get_second;
        }
        LOGD("ret : 0x%x", ret);
@@ -1645,7 +1646,7 @@ int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1657,9 +1658,9 @@ int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_device, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_device, pc->cb_info->recvMsg);
                *device = (recorder_audio_device_e)get_device;
        }
 
@@ -1679,7 +1680,7 @@ int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1691,9 +1692,9 @@ int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg);
                *samplerate = get_samplerate;
        }
        LOGD("ret : 0x%x, get_samplerate : %d", ret, get_samplerate);
@@ -1712,7 +1713,7 @@ int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1725,9 +1726,9 @@ int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
                *bitrate = get_bitrate;
        }
        LOGD("ret : 0x%x", ret);
@@ -1746,7 +1747,7 @@ int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1758,9 +1759,9 @@ int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
                *bitrate = get_bitrate;
        }
        LOGD("ret : 0x%x", ret);
@@ -1777,7 +1778,7 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1787,10 +1788,10 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1805,7 +1806,7 @@ int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_suppo
        int ret = RECORDER_ERROR_NONE;
 
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
+       muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
 
        LOGD("Enter, handle :%x", pc->remote_handle);
 
@@ -1815,10 +1816,10 @@ int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_suppo
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
+       pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
+       pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1831,7 +1832,7 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_MUTE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1844,11 +1845,11 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, set_enable);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, set_enable);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1861,7 +1862,7 @@ bool recorder_attr_is_muted(recorder_h recorder)
                return false;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_IS_MUTED;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1872,7 +1873,7 @@ bool recorder_attr_is_muted(recorder_h recorder)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1885,7 +1886,7 @@ int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1896,11 +1897,11 @@ int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               DOUBLE, rate);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       DOUBLE, rate);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1917,7 +1918,7 @@ int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1929,9 +1930,9 @@ int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_rate, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_rate, pc->cb_info->recvMsg);
                *rate = get_rate;
        }
        LOGD("ret : 0x%x", ret);
@@ -1950,7 +1951,7 @@ int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1961,11 +1962,11 @@ int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, channel_count);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, channel_count);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -1982,7 +1983,7 @@ int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1994,9 +1995,9 @@ int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg);
                *channel_count = get_channel_count;
        }
        LOGD("ret : 0x%x", ret);
@@ -2015,7 +2016,7 @@ int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e o
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2027,11 +2028,11 @@ int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e o
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send1(api, pc->remote_handle,
-                                                               sock_fd,
-                                                               pc->cb_info,
-                                                               ret,
-                                                               INT, set_orientation);
+       muse_recorder_msg_send1(api,
+                                                       sock_fd,
+                                                       pc->cb_info,
+                                                       ret,
+                                                       INT, set_orientation);
        LOGD("ret : 0x%x", ret);
        return ret;
 }
@@ -2048,7 +2049,7 @@ int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e
                return RECORDER_ERROR_INVALID_PARAMETER;
        }
        int ret = RECORDER_ERROR_NONE;
-       mmsvc_recorder_api_e api = MMSVC_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
+       muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
        recorder_cli_s *pc = (recorder_cli_s *)recorder;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2060,9 +2061,9 @@ int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e
 
        LOGD("ENTER");
 
-       mmsvc_recorder_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
        if (ret == RECORDER_ERROR_NONE) {
-               mmsvc_recorder_msg_get(get_orientation, pc->cb_info->recvMsg);
+               muse_recorder_msg_get(get_orientation, pc->cb_info->recvMsg);
                *orientation = (recorder_rotation_e)get_orientation;
        }
        LOGD("ret : 0x%x", ret);