Remove Handle arg, Change Client to Module, Muse naming

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

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b4575a4aed32ea9c891bf01dca8451082bb599cd..bdec4353e218202c6582e9ea9054c29e9e76ad4e 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,7 +73,7 @@ SET_TARGET_PROPERTIES(${fw_name}
 )
 
 
-TARGET_LINK_LIBRARIES(${fw_name} mused-camera ${${fw_name}_LDFLAGS})
+TARGET_LINK_LIBRARIES(${fw_name} muse-camera ${${fw_name}_LDFLAGS})
 
 INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR})
 INSTALL(

diff --git a/include/camera_private.h b/include/camera_private.h
index b6de75dad412a044c9c0272b8431def4da55d341..ca2ab903a946a642f38306f9be3ac0fb2666e8e6 100644 (file)
--- a/include/camera_private.h
+++ b/include/camera_private.h
@@ -21,8 +21,8 @@
 #ifndef __TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__
 #define        __TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__
 #include <camera.h>
-#include <mmsvc_core.h>
-#include <mused_camera.h>
+#include <muse_core.h>
+#include <muse_camera.h>
 #include <mm_camcorder.h>
 
 #ifdef __cplusplus
@@ -56,12 +56,12 @@ typedef struct _callback_cb_info {
        gint running;
        gint fd;
        gint id;
-       gpointer user_cb[MMSVC_CAMERA_EVENT_TYPE_NUM];
-       gpointer user_cb_completed[MMSVC_CAMERA_EVENT_TYPE_NUM];
-       gpointer user_data[MMSVC_CAMERA_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_CAMERA_EVENT_TYPE_NUM];
+       gpointer user_cb_completed[MUSE_CAMERA_EVENT_TYPE_NUM];
+       gpointer user_data[MUSE_CAMERA_EVENT_TYPE_NUM];
+       gchar recvMsg[MUSE_CAMERA_MSG_MAX_LENGTH];
+       gchar recvApiMsg[MUSE_CAMERA_MSG_MAX_LENGTH];
+       gchar recvEventMsg[MUSE_CAMERA_MSG_MAX_LENGTH];
        GCond *pCond;
        GMutex *pMutex;
        gint *activating;
@@ -80,8 +80,8 @@ typedef struct _camera_cli_s{
 typedef struct _camera_s{
        MMHandleType mm_handle;
 
-       void* user_cb[MMSVC_CAMERA_EVENT_TYPE_NUM];
-       void* user_data[MMSVC_CAMERA_EVENT_TYPE_NUM];
+       void* user_cb[MUSE_CAMERA_EVENT_TYPE_NUM];
+       void* user_data[MUSE_CAMERA_EVENT_TYPE_NUM];
        void* display_handle;
 #ifdef HAVE_WAYLAND
        MMCamWaylandInfo *wl_info;
@@ -113,10 +113,10 @@ typedef struct _camera_s{
 } camera_s;
 
 typedef enum {
-       MMSVC_CAMERA_CLIENT_SYNC_CB_HANDLER,
-       MMSVC_CAMERA_CLIENT_USER_CALLBACK,
-       MMSVC_CAMERA_CLIENT_MAX
-} mmsvc_cli_camera_api_e;
+       MUSE_CAMERA_CLIENT_SYNC_CB_HANDLER,
+       MUSE_CAMERA_CLIENT_USER_CALLBACK,
+       MUSE_CAMERA_CLIENT_MAX
+} muse_cli_camera_api_e;
 
 int _camera_get_mm_handle(camera_h camera , MMHandleType *handle);
 int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data);

diff --git a/packaging/capi-media-camera.spec b/packaging/capi-media-camera.spec
index 2639850c3b28b41ce861eb28483b49f15445877a..c2f16107084c2c83278a67e74179ab1f430e04ad 100644 (file)
--- a/packaging/capi-media-camera.spec
+++ b/packaging/capi-media-camera.spec
@@ -16,7 +16,6 @@ BuildRequires:  pkgconfig(mm-common)
 BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(capi-media-sound-manager)
 BuildRequires:  pkgconfig(mmsvc-camera)
-BuildRequires:  pkgconfig(capi-media-recorder)
 BuildRequires:  pkgconfig(appcore-efl)
 BuildRequires:  pkgconfig(elementary)
 BuildRequires:  pkgconfig(ecore)

diff --git a/src/camera.c b/src/camera.c
index 6c748b0b5e5617df27e5cc544c83a6b91aeafed2..d559b92b2dd405190241d572491d32894e7f3ce6 100644 (file)
--- a/src/camera.c
+++ b/src/camera.c
@@ -21,11 +21,11 @@
 #include <mm.h>
 #include <mm_types.h>
 #include <camera.h>
-#include <mused_camera.h>
-#include <mused_camera_msg.h>
-#include <mmsvc_core_ipc.h>
+#include <muse_camera.h>
+#include <muse_camera_msg.h>
+#include <muse_core_ipc.h>
 #include <camera_private.h>
-#include <mmsvc_core.h>
+#include <muse_core.h>
 //#include <glib.h>
 #include <dlog.h>
 #include <Elementary.h>
@@ -42,204 +42,204 @@
 #endif
 #define LOG_TAG "TIZEN_N_CAMERA_CLIENT"
 
-//int mmsvc_camera_ipc_import_tbm(mmsvc_camera_transport_info_s *transport_info);
-//export int mmsvc_camera_ipc_export_tbm_bo(mmsvc_camera_transport_info_s transport_info);
+//int muse_camera_ipc_import_tbm(muse_camera_transport_info_s *transport_info);
+//export int muse_camera_ipc_export_tbm_bo(muse_camera_transport_info_s transport_info);
 
-static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_camera_event_e event )
+static void _client_user_callback(callback_cb_info_s * cb_info, muse_camera_event_e event )
 {
        char *recvMsg = cb_info->recvMsg;
        int param, param1, param2;
-       LOGW("get event %d", event);
+       LOGD("get event %d", event);
 
        switch (event) {
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
-                       mmsvc_camera_msg_get(param1, recvMsg);
-                       mmsvc_camera_msg_get(param2, recvMsg);
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
+                       muse_camera_msg_get(param1, recvMsg);
+                       muse_camera_msg_get(param2, recvMsg);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
-                       mmsvc_camera_msg_get(param, recvMsg);
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
+                       muse_camera_msg_get(param, recvMsg);
                        break;
                default:
                        break;
        }
 
        switch(event) {
-               case MMSVC_CAMERA_EVENT_TYPE_STATE_CHANGE:
+               case MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE:
                {
                        int cb_previous, cb_current, cb_by_policy;
-                       mmsvc_camera_msg_get(cb_previous, recvMsg);
-                       mmsvc_camera_msg_get(cb_current, recvMsg);
-                       mmsvc_camera_msg_get(cb_by_policy, recvMsg);
+                       muse_camera_msg_get(cb_previous, recvMsg);
+                       muse_camera_msg_get(cb_current, recvMsg);
+                       muse_camera_msg_get(cb_by_policy, recvMsg);
                        ((camera_state_changed_cb)cb_info->user_cb[event])((camera_state_e)cb_previous,
                                                                                                        (camera_state_e)cb_current,
                                                                                                        (bool)cb_by_policy,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_FOCUS_CHANGE:
+               case MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE:
                {
                        int cb_state;
-                       mmsvc_camera_msg_get(cb_state, recvMsg);
+                       muse_camera_msg_get(cb_state, recvMsg);
                        ((camera_focus_changed_cb)cb_info->user_cb[event])((camera_focus_state_e)cb_state,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE:
+               case MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE:
                        ((camera_capture_completed_cb)cb_info->user_cb[event])(cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_PREVIEW:
+               case MUSE_CAMERA_EVENT_TYPE_PREVIEW:
                        ((camera_preview_cb)cb_info->user_cb[event])(NULL,
                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW:
+               case MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW:
                        ((camera_media_packet_preview_cb)cb_info->user_cb[event])(NULL,
                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_HDR_PROGRESS:
+               case MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS:
                {
                        int progress;
-                       mmsvc_camera_msg_get(progress, recvMsg);
+                       muse_camera_msg_get(progress, recvMsg);
                        ((camera_attr_hdr_progress_cb)cb_info->user_cb[event])(progress,
                                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_INTERRUPTED:
+               case MUSE_CAMERA_EVENT_TYPE_INTERRUPTED:
                {
                        int cb_policy, cb_previous, cb_current;
-                       mmsvc_camera_msg_get(cb_policy, recvMsg);
-                       mmsvc_camera_msg_get(cb_previous, recvMsg);
-                       mmsvc_camera_msg_get(cb_current, recvMsg);
+                       muse_camera_msg_get(cb_policy, recvMsg);
+                       muse_camera_msg_get(cb_previous, recvMsg);
+                       muse_camera_msg_get(cb_current, recvMsg);
                        ((camera_interrupted_cb)cb_info->user_cb[event])((camera_policy_e)cb_policy,
                                                                                                                (camera_state_e)cb_previous,
                                                                                                                (camera_state_e)cb_current,
                                                                                                                cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_FACE_DETECTION:
+               case MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION:
                {
                        int count;
-                       mmsvc_camera_msg_get(count, recvMsg);
+                       muse_camera_msg_get(count, recvMsg);
                        ((camera_face_detected_cb)cb_info->user_cb[event])(NULL,
                                                                                                        count,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_ERROR:
+               case MUSE_CAMERA_EVENT_TYPE_ERROR:
                {
                        int cb_error, cb_current_state;
-                       mmsvc_camera_msg_get(cb_error, recvMsg);
-                       mmsvc_camera_msg_get(cb_current_state, recvMsg);
+                       muse_camera_msg_get(cb_error, recvMsg);
+                       muse_camera_msg_get(cb_current_state, recvMsg);
                        ((camera_error_cb)cb_info->user_cb[event])((camera_error_e)cb_error,
                                                                                                        (camera_state_e)cb_current_state,
                                                                                                        cb_info->user_data[event]);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
                        ((camera_supported_preview_resolution_cb)cb_info->user_cb[event])(param1, param2,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
                        ((camera_supported_capture_resolution_cb)cb_info->user_cb[event])(param1, param2,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
                        ((camera_supported_capture_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
                        ((camera_supported_preview_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
                        ((camera_attr_supported_af_mode_cb)cb_info->user_cb[event])((camera_attr_af_mode_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
                        ((camera_attr_supported_exposure_mode_cb)cb_info->user_cb[event])((camera_attr_exposure_mode_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
                        ((camera_attr_supported_iso_cb)cb_info->user_cb[event])((camera_attr_iso_e)param,
                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
                        ((camera_attr_supported_whitebalance_cb)cb_info->user_cb[event])((camera_attr_whitebalance_e)param,
                                                                                                                                                cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
                        ((camera_attr_supported_effect_cb)cb_info->user_cb[event])((camera_attr_effect_mode_e)param,
                                                                                                                                cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
                        ((camera_attr_supported_scene_mode_cb)cb_info->user_cb[event])((camera_attr_scene_mode_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
                        ((camera_attr_supported_flash_mode_cb)cb_info->user_cb[event])((camera_attr_flash_mode_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
                        ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param,
                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
                        ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param,
                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
                        ((camera_attr_supported_stream_flip_cb)cb_info->user_cb[event])((camera_flip_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
                        ((camera_attr_supported_stream_rotation_cb)cb_info->user_cb[event])((camera_rotation_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
+               case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
                        ((camera_attr_supported_theater_mode_cb)cb_info->user_cb[event])((camera_attr_theater_mode_e)param,
                                                                                                                                        cb_info->user_data[event]);
                        break;
-               case MMSVC_CAMERA_EVENT_TYPE_CAPTURE:
+               case MUSE_CAMERA_EVENT_TYPE_CAPTURE:
                {
                        camera_image_data_s *rImage = NULL;
                        camera_image_data_s *rPostview = NULL;
                        camera_image_data_s *rThumbnail = NULL;
                        unsigned char *buf_pos = NULL;
-                       mmsvc_camera_transport_info_s transport_info;
+                       muse_camera_transport_info_s transport_info;
                        int tKey = 0;
                        int is_postview = 0;
                        int is_thumbnail = 0;
 
-                       LOGW("camera2 capture callback came in.");
-                       mmsvc_camera_msg_get(tKey, recvMsg);
-                       mmsvc_camera_msg_get(is_postview, recvMsg);
-                       mmsvc_camera_msg_get(is_thumbnail, recvMsg);
+                       LOGD("camera capture callback came in.");
+                       muse_camera_msg_get(tKey, recvMsg);
+                       muse_camera_msg_get(is_postview, recvMsg);
+                       muse_camera_msg_get(is_thumbnail, recvMsg);
 
                        if (tKey != 0) {
                                transport_info.tbm_key = tKey;
-                               LOGE("Read key_info INFO : %d", transport_info.tbm_key);
+                               LOGD("Read key_info INFO : %d", transport_info.tbm_key);
 
-                               if (mmsvc_camera_ipc_init_tbm(&transport_info) == FALSE) {
+                               if (muse_camera_ipc_init_tbm(&transport_info) == FALSE) {
                                        LOGE("camera_init_tbm ERROR!!");
                                        break;
                                }
 
-                               if(mmsvc_camera_ipc_import_tbm(&transport_info) == FALSE) {
+                               if(muse_camera_ipc_import_tbm(&transport_info) == FALSE) {
                                        LOGE("camera_import_tbm ERROR!!");
-                                       mmsvc_camera_unref_tbm(&transport_info);
+                                       muse_camera_unref_tbm(&transport_info);
                                        break;
                                } else {
                                        if (transport_info.bo_handle.ptr != NULL) {
@@ -267,16 +267,12 @@ static void _client_user_callback(callback_cb_info_s * cb_info, mmsvc_camera_eve
                                break;
                        }
 
-                       LOGW("read image info height: %d, width : %d, size : %d", rImage->height, rImage->width, rImage->size);
-
+                       LOGD("read image info height: %d, width : %d, size : %d", rImage->height, rImage->width, rImage->size);
                        ((camera_capturing_cb)cb_info->user_cb[event])(rImage, rPostview, rThumbnail, cb_info->user_data[event]);
-
-                       mmsvc_camera_unref_tbm(&transport_info);
-
-                       LOGW("finished capture callback");
+                       muse_camera_unref_tbm(&transport_info);
                        break;
                }
-               case MMSVC_CAMERA_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR:
+               case MUSE_CAMERA_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR:
                        break;
 
                default:
@@ -295,10 +291,10 @@ 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_CAMERA_PARSE_STRING_SIZE][MUSE_CAMERA_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';
@@ -306,49 +302,49 @@ static void *client_cb_handler(gpointer data)
                str_pos = 0;
                prev_pos = 0;
                num_token = 0;
-               memset(parseStr, 0, MMSVC_PARSE_STRING_SIZE * MMSVC_MSG_MAX_LENGTH);
+               memset(parseStr, 0, MUSE_CAMERA_PARSE_STRING_SIZE * MUSE_CAMERA_MSG_MAX_LENGTH);
 
-               LOGW("recvMSg : %s, length : %d", recvMsg, ret);
+               LOGD("recvMSg : %s, length : %d", recvMsg, ret);
 
-               /* Need to split the combined entering msgs. 
+               /* Need to split the combined entering msgs.
                    This module supports up to 5 combined msgs. */
                for (str_pos = 0; str_pos < ret; str_pos++) {
                        if(recvMsg[str_pos] == '}') {
                                strncpy(&(parseStr[num_token][0]), recvMsg + prev_pos, str_pos - prev_pos + 1);
-                               LOGW("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
+                               LOGD("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
                                prev_pos = str_pos+1;
                                num_token++;
                        }
                }
-               LOGW("num_token : %d", num_token);
+               LOGD("num_token : %d", num_token);
 
                /* Re-construct to the useful single msg. */
                for (i = 0; i < num_token; i++) {
 
-                       if (i >= MMSVC_PARSE_STRING_SIZE)
+                       if (i >= MUSE_CAMERA_PARSE_STRING_SIZE)
                                break;
 
-                       if (mmsvc_camera_msg_get(api, &(parseStr[i][0]))) {
-                               if(api < MMSVC_CAMERA_API_MAX){
-                                       LOGW("Set Condition");
+                       if (muse_camera_msg_get(api, &(parseStr[i][0]))) {
+                               if(api < MUSE_CAMERA_API_MAX){
+                                       LOGD("Set Condition");
                                        g_mutex_lock(&(cb_info->pMutex[api]));
                                        /* The api msgs should be distinguished from the event msg. */
                                        memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
                                        strcpy(cb_info->recvApiMsg, &(parseStr[i][0]));
-                                       LOGW("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
+                                       LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
                                        cb_info->activating[api] = 1;
                                        g_cond_signal(&(cb_info->pCond[api]));
                                        g_mutex_unlock(&(cb_info->pMutex[api]));
                                        //msleep(100);
-                                       if(api == MMSVC_CAMERA_API_DESTROY) {
+                                       if(api == MUSE_CAMERA_API_DESTROY) {
                                                g_atomic_int_set(&cb_info->running, 0);
-                                               LOGW("close client cb handler");
+                                               LOGD("close client cb handler");
                                        }
 
-                               } else if(api == MMSVC_CAMERA_CB_EVENT) {
+                               } else if(api == MUSE_CAMERA_CB_EVENT) {
                                        int event;
-                                       if (mmsvc_camera_msg_get(event, &(parseStr[i][0]))) {
-                                               LOGW("go callback : %d", event);
+                                       if (muse_camera_msg_get(event, &(parseStr[i][0]))) {
+                                               LOGD("go callback : %d", event);
                                                _client_user_callback(cb_info, event);
                                        }
                                }
@@ -358,7 +354,7 @@ static void *client_cb_handler(gpointer data)
                }
 
        }
-       LOGW("client cb exit");
+       LOGD("client cb exit");
 
        return NULL;
 }
@@ -372,9 +368,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);
-       camera_cond = g_new0(GCond, MMSVC_CAMERA_API_MAX);
-       camera_mutex = g_new0(GMutex, MMSVC_CAMERA_API_MAX);
-       camera_activ = g_new0(gint, MMSVC_CAMERA_API_MAX);
+       camera_cond = g_new0(GCond, MUSE_CAMERA_API_MAX);
+       camera_mutex = g_new0(GMutex, MUSE_CAMERA_API_MAX);
+       camera_activ = g_new0(gint, MUSE_CAMERA_API_MAX);
 
        g_atomic_int_set(&cb_info->running, 1);
        cb_info->fd = sockfd;
@@ -388,41 +384,41 @@ static callback_cb_info_s *client_callback_new(gint sockfd)
        return cb_info;
 }
 
-static int client_wait_for_cb_return(mmsvc_camera_api_e api, callback_cb_info_s *cb_info, int time_out)
+static int client_wait_for_cb_return(muse_camera_api_e api, callback_cb_info_s *cb_info, int time_out)
 {
        int ret = CAMERA_ERROR_NONE;
        gint64 end_time;
 
-       LOGW("Enter api : %d", api);
+       LOGD("Enter api : %d", api);
        g_mutex_lock(&(cb_info->pMutex[api]));
 
        if (cb_info->activating[api] == 0) {
                end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
                if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
-                       LOGW("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
-                       if (!mmsvc_camera_msg_get(ret, cb_info->recvApiMsg)) {
+                       LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
+                       if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
                                LOGE("Get cb msg failed.");
                                ret = CAMERA_ERROR_INVALID_OPERATION;
                        } else {
-                               LOGW("Wait passed, ret : 0x%x", ret);
+                               LOGD("Wait passed, ret : 0x%x", ret);
                        }
                        if (cb_info->activating[api])
                                cb_info->activating[api] = 0;
                } else {
-                       LOGW("api %d was TIMED OUT!", api);
+                       LOGD("api %d was TIMED OUT!", api);
                        ret = CAMERA_ERROR_INVALID_OPERATION;
                }
        } else {
                LOGE("condition is already checked for the api : %d.", api);
-               if (!mmsvc_camera_msg_get(ret, cb_info->recvApiMsg)) {
+               if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
                        LOGE("Get cb msg failed.");
                        ret = CAMERA_ERROR_INVALID_OPERATION;
                } else {
-                       LOGW("Already checked condition, Wait passed, ret : 0x%x", ret);
-               }       
+                       LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
+               }
        }
        g_mutex_unlock(&(cb_info->pMutex[api]));
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -459,18 +455,18 @@ int camera_create(camera_device_e device, camera_h* camera)
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = NULL;
 
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_CREATE;
-       mmsvc_api_client_e api_client = MMSVC_CAMERA;
+       muse_camera_api_e api = MUSE_CAMERA_API_CREATE;
+       muse_core_api_module_e muse_module = MUSE_CAMERA;
        int device_type = (int)device;
 
-       sock_fd = mmsvc_core_client_new();
+       sock_fd = muse_core_client_new();
 
-       sndMsg = mmsvc_core_msg_json_factory_new(api, "client", api_client,
-                                                                                             MUSED_TYPE_INT, PARAM_DEVICE_TYPE, (int)device_type,
-                                                                                             0);
-       mmsvc_core_ipc_send_msg(sock_fd, sndMsg);
-       LOGW("sock_fd : %d, msg : %s", sock_fd, sndMsg);
-       mmsvc_core_msg_json_factory_free(sndMsg);
+       sndMsg = muse_core_msg_json_factory_new(api,
+                                                                       MUSE_TYPE_INT, "module", muse_module,
+                                                                       MUSE_TYPE_INT, PARAM_DEVICE_TYPE, (int)device_type,
+                                                                       0);
+       muse_core_ipc_send_msg(sock_fd, sndMsg);
+       muse_core_msg_json_factory_free(sndMsg);
 
        pc = g_new0(camera_cli_s, 1);
        if (pc == NULL) {
@@ -478,14 +474,13 @@ int camera_create(camera_device_e device, camera_h* camera)
        }
 
        pc->cb_info = client_callback_new(sock_fd);
-       LOGW("cb info : %d", pc->cb_info->fd);
+       LOGD("cb info : %d", pc->cb_info->fd);
 
        ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
-       LOGW("ret value : 0x%x", ret);
+       LOGD("ret value : 0x%x", ret);
        if (ret == CAMERA_ERROR_NONE) {
                intptr_t handle = 0;
-
-               mmsvc_camera_msg_get_pointer(handle, pc->cb_info->recvMsg);
+               muse_camera_msg_get_pointer(handle, pc->cb_info->recvMsg);
                if (handle == 0) {
                        LOGE("Receiving Handle Failed!!");
                        ret = CAMERA_ERROR_INVALID_OPERATION;
@@ -493,7 +488,7 @@ int camera_create(camera_device_e device, camera_h* camera)
                } else {
                        pc->remote_handle = handle;
                }
-               LOGW("camera create 0x%x", pc->remote_handle);
+               LOGD("camera create 0x%x", pc->remote_handle);
                *camera = (camera_h) pc;
        } else
                goto ErrorExit;
@@ -502,7 +497,7 @@ int camera_create(camera_device_e device, camera_h* camera)
 
 ErrorExit:
        g_free(pc);
-       LOGW("ret value : 0x%x", ret);
+       LOGD("ret value : 0x%x", ret);
        return ret;
 }
 
@@ -514,21 +509,21 @@ ErrorExit:
        }
 
        int ret = CAMERA_ERROR_NONE;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_DESTROY;
+       muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
        camera_cli_s *pc = (camera_cli_s *)camera;
        int sock_fd = pc->cb_info->fd;
-       LOGW("ENTER");
+       LOGD("ENTER");
 
        if (pc == NULL) {
-               LOGW("pc is already nul!!");
+               LOGD("pc is already nul!!");
                return CAMERA_ERROR_INVALID_PARAMETER;
        } else if (pc->cb_info == NULL) {
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
        if(ret == CAMERA_ERROR_NONE) {
-               LOGW("destroy client");
+               LOGD("destroy client");
 
        }
        client_callback_destroy(pc->cb_info);
@@ -536,23 +531,23 @@ ErrorExit:
        g_free(pc);
        pc = NULL;
 
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
 int camera_start_preview(camera_h camera)
 {
-       LOGW("start");
+       LOGD("start");
        if (camera == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
 
        int ret = CAMERA_ERROR_NONE;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_START_PREVIEW;
+       muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
        camera_cli_s *pc = (camera_cli_s *)camera;
        int sock_fd;
-       char caps[MM_MSG_MAX_LENGTH] = {0};
+       char caps[MUSE_CAMERA_MSG_MAX_LENGTH] = {0};
 
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -561,23 +556,21 @@ int camera_start_preview(camera_h camera)
 
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter,  handle :0x%x", pc->remote_handle);
-       mmsvc_camera_msg_send_longtime(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("Enter,  ret :0x%x", ret);
+       muse_camera_msg_send_longtime(api, sock_fd, pc->cb_info, ret);
+       LOGD("Enter,  ret :0x%x", ret);
        if(ret == CAMERA_ERROR_NONE) {
-               LOGW("Enter");
-               mmsvc_camera_msg_get_string(caps, pc->cb_info->recvMsg);
-               LOGW("caps : %s", caps);
+               muse_camera_msg_get_string(caps, pc->cb_info->recvMsg);
+               LOGD("caps : %s", caps);
                if (pc->cli_display_handle != 0) {
-                       LOGW("client's display handle is : 0x%x", pc->cli_display_handle);
+                       LOGD("client's display handle is : 0x%x", pc->cli_display_handle);
                        if(strlen(caps) > 0 &&
                                        mm_camcorder_client_realize(pc->client_handle, caps) != MM_ERROR_NONE)
                                ret = CAMERA_ERROR_INVALID_OPERATION;
                } else {
-                       LOGW("display handle is NULL");
+                       LOGD("display handle is NULL");
                }
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -590,7 +583,7 @@ int camera_stop_preview(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
        int sock_fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_STOP_PREVIEW;
+       muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
 
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -598,23 +591,21 @@ int camera_stop_preview(camera_h camera)
        }
 
        sock_fd = pc->cb_info->fd;
-
-       LOGW("Enter,  handle :%x", pc->remote_handle);
-
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter");
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if(ret == CAMERA_ERROR_NONE) {
                if (pc->cli_display_handle != 0) {
-                       LOGW("Unrealize client");
+                       LOGD("Unrealize client");
                        if (pc->client_handle != NULL) {
                                ret = mm_camcorder_client_unrealize(pc->client_handle);
                                mm_camcorder_client_destroy(pc->client_handle);
                        }
                } else {
-                       LOGW("Client did not realized : Display handle is NULL");
+                       LOGD("Client did not realized : Display handle is NULL");
                }
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -627,11 +618,11 @@ int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , cam
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_START_CAPTURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
        int sock_fd;
        int is_capturing_cb = 0;
        int is_completed_cb = 0;
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -640,22 +631,21 @@ int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , cam
 
        sock_fd = pc->cb_info->fd;
 
-
        if (capturing_cb != NULL) {
                is_capturing_cb = 1;
-               pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
-               pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
+               pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
+               pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
        }
 
        if(completed_cb != NULL) {
                is_completed_cb = 1;
-               pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
-               pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
+               pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
+               pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
        }
 
-       LOGW("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
+       LOGD("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -668,7 +658,7 @@ bool camera_is_supported_continuous_capture(camera_h camera)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
        int sock_fd;
 
        if (pc->cb_info == NULL) {
@@ -678,9 +668,9 @@ bool camera_is_supported_continuous_capture(camera_h camera)
 
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return (bool)ret;
 }
 
@@ -694,9 +684,9 @@ int camera_start_continuous_capture(camera_h camera, int count, int interval, ca
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_START_CONTINUOUS_CAPTURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -705,12 +695,12 @@ int camera_start_continuous_capture(camera_h camera, int count, int interval, ca
        }
        sock_fd = pc->cb_info->fd;
 
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
-       pc->cb_info->user_cb_completed[MMSVC_CAMERA_EVENT_TYPE_CAPTURE] = completed_cb;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
+       pc->cb_info->user_cb_completed[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = completed_cb;
 
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -725,16 +715,16 @@ int camera_stop_continuous_capture(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
-       LOGW("Enter,  handle :%x", pc->remote_handle);
+       muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
+       LOGD("Enter,  handle :%x", pc->remote_handle);
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -747,7 +737,7 @@ bool camera_is_supported_face_detection(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SUPPORT_FACE_DETECTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -755,9 +745,9 @@ bool camera_is_supported_face_detection(camera_h camera)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return (bool)ret;
 }
 
@@ -770,7 +760,7 @@ bool camera_is_supported_zero_shutter_lag(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -778,9 +768,9 @@ bool camera_is_supported_zero_shutter_lag(camera_h camera)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return (bool)ret;
 }
 
@@ -794,7 +784,7 @@ bool camera_is_supported_media_packet_preview_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -802,9 +792,9 @@ bool camera_is_supported_media_packet_preview_cb(camera_h camera)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return (bool)ret;
 }
 
@@ -817,7 +807,7 @@ int camera_get_device_count(camera_h camera, int *device_count)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_DEVICE_COUNT;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -826,14 +816,14 @@ int camera_get_device_count(camera_h camera, int *device_count)
        sock_fd = pc->cb_info->fd;
        int get_device_count;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_device_count, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_device_count, pc->cb_info->recvMsg);
                *device_count = get_device_count;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -847,20 +837,20 @@ int camera_start_face_detection(camera_h camera, camera_face_detected_cb callbac
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_START_FACE_DETECTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -874,16 +864,16 @@ int camera_stop_face_detection(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_STOP_FACE_DETECTION;
-       LOGW("Enter,  handle :%x", pc->remote_handle);
+       muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
+       LOGD("Enter,  handle :%x", pc->remote_handle);
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -896,7 +886,7 @@ int camera_get_state(camera_h camera, camera_state_e * state)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_STATE;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -905,14 +895,14 @@ int camera_get_state(camera_h camera, camera_state_e * state)
        sock_fd = pc->cb_info->fd;
        int get_state;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_state, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_state, pc->cb_info->recvMsg);
                *state = (camera_state_e)get_state;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -926,7 +916,7 @@ int camera_start_focusing(camera_h camera, bool continuous)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_START_FOCUSING;
+       muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -935,9 +925,9 @@ int camera_start_focusing(camera_h camera, bool continuous)
        sock_fd = pc->cb_info->fd;
        int is_continuous = (int)continuous;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, is_continuous);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, is_continuous);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -951,7 +941,7 @@ int camera_cancel_focusing(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_CANCEL_FOCUSING;
+       muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -959,9 +949,9 @@ int camera_cancel_focusing(camera_h camera)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -974,7 +964,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
        camera_s *handle = NULL;
        Evas_Object *obj = NULL;
        const char *object_type = NULL;
-       char socket_path[MM_MSG_MAX_LENGTH] = {0,};
+       char socket_path[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
 
        if (camera == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
@@ -988,7 +978,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
 
        int display_type = (int)type;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_DISPLAY;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -996,7 +986,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
+       LOGD("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
 
        handle = (camera_s *)camera;
        handle->display_type = type;
@@ -1004,7 +994,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
        if (type == CAMERA_DISPLAY_TYPE_NONE) {
                set_display_handle = 0;
                set_surface = MM_DISPLAY_SURFACE_NULL;
-               LOGW("display type NONE");
+               LOGD("display type NONE");
        } else {
                obj = (Evas_Object *)display;
                object_type = evas_object_type_get(obj);
@@ -1044,13 +1034,13 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
                                /* x window overlay surface */
                                set_display_handle = (void *)elm_win_xwindow_get(obj);
                                set_surface = MM_DISPLAY_SURFACE_X;
-                               LOGW("display type OVERLAY : handle %p", set_display_handle);
+                               LOGD("display type OVERLAY : handle %p", set_display_handle);
 #endif
                        } else if (type == CAMERA_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) {
                                /* evas object surface */
                                set_display_handle = (void *)display;
                                set_surface = MM_DISPLAY_SURFACE_EVAS;
-                               LOGW("display type EVAS : handle %p", set_display_handle);
+                               LOGD("display type EVAS : handle %p", set_display_handle);
                        } else {
                                LOGE("unknown evas object [%p,%s] or type [%d] mismatch", obj, object_type, type);
                                return CAMERA_ERROR_INVALID_PARAMETER;
@@ -1063,7 +1053,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
 
        pc->cli_display_handle = (intptr_t)set_display_handle;
        display_surface = (int)set_surface;
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret,
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret,
                                                            INT, display_type,
                                                            INT, display_surface);
 
@@ -1072,7 +1062,7 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
                        LOGE("camera client create Failed");
                        return CAMERA_ERROR_INVALID_OPERATION;
                }
-               mmsvc_camera_msg_get_string(socket_path, pc->cb_info->recvMsg);
+               muse_camera_msg_get_string(socket_path, pc->cb_info->recvMsg);
                LOGD("shmsrc stream path : %s", socket_path);
                if(mm_camcorder_client_set_shm_socket_path(pc->client_handle, socket_path)
                                != MM_ERROR_NONE)
@@ -1084,10 +1074,10 @@ int camera_set_display(camera_h camera, camera_display_type_e type, camera_displ
                        ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
                                                          MMCAM_DISPLAY_HANDLE, pc->cli_display_handle, sizeof(void *),
                                                          NULL);
-                       LOGW("ret : 0x%x", ret);
+                       LOGD("ret : 0x%x", ret);
                }
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1100,7 +1090,7 @@ int camera_set_preview_resolution(camera_h camera,  int width, int height)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_PREVIEW_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1108,9 +1098,9 @@ int camera_set_preview_resolution(camera_h camera,  int width, int height)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, width, INT, height);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1125,7 +1115,7 @@ int camera_set_capture_resolution(camera_h camera,  int width, int height)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_CAPTURE_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1133,9 +1123,9 @@ int camera_set_capture_resolution(camera_h camera,  int width, int height)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, width, INT, height);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1150,7 +1140,7 @@ int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
        int set_format = (int)format;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_CAPTURE_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1158,9 +1148,9 @@ int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_format);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1175,7 +1165,7 @@ int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
        int set_format = (int)format;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_PREVIEW_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1183,9 +1173,9 @@ int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_format);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1200,7 +1190,7 @@ int camera_get_preview_resolution(camera_h camera,  int *width, int *height)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_PREVIEW_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1210,16 +1200,16 @@ int camera_get_preview_resolution(camera_h camera,  int *width, int *height)
        int get_width;
        int get_height;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_width, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_height, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
                *width = get_width;
                *height = get_height;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1232,7 +1222,7 @@ int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_DISPLAY_ROTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1241,9 +1231,9 @@ int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
        sock_fd = pc->cb_info->fd;
        int set_rotation = (int)rotation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_rotation);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1257,7 +1247,7 @@ int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_DISPLAY_ROTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1266,14 +1256,14 @@ int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
        sock_fd = pc->cb_info->fd;
        int get_rotation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
                *rotation = (camera_rotation_e)get_rotation;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1287,7 +1277,7 @@ int camera_set_display_flip(camera_h camera, camera_flip_e flip)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_DISPLAY_FLIP;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1296,9 +1286,9 @@ int camera_set_display_flip(camera_h camera, camera_flip_e flip)
        sock_fd = pc->cb_info->fd;
        int set_flip = (int)flip;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_flip);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1312,7 +1302,7 @@ int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_DISPLAY_FLIP;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1321,14 +1311,14 @@ int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
        sock_fd = pc->cb_info->fd;
        int get_flip;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_flip, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
                *flip = (camera_flip_e)get_flip;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1342,7 +1332,7 @@ int camera_set_display_visible(camera_h camera, bool visible)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_DISPLAY_VISIBLE;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
        int set_visible = (int)visible;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1351,9 +1341,9 @@ int camera_set_display_visible(camera_h camera, bool visible)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_visible);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_visible);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1367,7 +1357,7 @@ int camera_is_display_visible(camera_h camera, bool* visible)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_IS_DISPLAY_VISIBLE;
+       muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1376,14 +1366,14 @@ int camera_is_display_visible(camera_h camera, bool* visible)
        sock_fd = pc->cb_info->fd;
        int get_visible;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_visible, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_visible, pc->cb_info->recvMsg);
                *visible = (bool)get_visible;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1398,7 +1388,7 @@ int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
        int set_mode = (int)mode;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_DISPLAY_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1406,9 +1396,9 @@ int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1422,7 +1412,7 @@ int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_DISPLAY_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1431,14 +1421,14 @@ int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
        sock_fd = pc->cb_info->fd;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_display_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1451,7 +1441,7 @@ int camera_get_capture_resolution(camera_h camera, int *width, int *height)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_CAPTURE_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1461,16 +1451,16 @@ int camera_get_capture_resolution(camera_h camera, int *width, int *height)
        int get_width;
        int get_height;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_width, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_height, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
                *width = get_width;
                *height = get_height;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1483,7 +1473,7 @@ int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_CAPTURE_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
        int get_format;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1492,14 +1482,14 @@ int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_format, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
                *format = (camera_pixel_format_e)get_format;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1513,7 +1503,7 @@ int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_PREVIEW_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
        int get_format;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1522,14 +1512,14 @@ int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_format, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
                *format = (camera_pixel_format_e)get_format;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1548,15 +1538,15 @@ int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void* use
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_PREVIEW_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_PREVIEW] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1570,9 +1560,9 @@ int camera_unset_preview_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_PREVIEW_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1580,11 +1570,11 @@ int camera_unset_preview_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1603,9 +1593,9 @@ int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_prev
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1613,11 +1603,11 @@ int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_prev
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1631,9 +1621,9 @@ int camera_unset_media_packet_preview_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1641,11 +1631,11 @@ int camera_unset_media_packet_preview_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1658,9 +1648,9 @@ int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callbac
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_STATE_CHANGED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1668,11 +1658,11 @@ int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callbac
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 int camera_unset_state_changed_cb(camera_h camera)
@@ -1684,9 +1674,9 @@ int camera_unset_state_changed_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_STATE_CHANGED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1694,11 +1684,11 @@ int camera_unset_state_changed_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1711,9 +1701,9 @@ int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, v
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_INTERRUPTED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1721,11 +1711,11 @@ int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, v
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1738,9 +1728,9 @@ int camera_unset_interrupted_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_INTERRUPTED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1748,11 +1738,11 @@ int camera_unset_interrupted_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1765,9 +1755,9 @@ int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callbac
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_FOCUS_CHANGED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1775,11 +1765,11 @@ int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callbac
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1792,9 +1782,9 @@ int camera_unset_focus_changed_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1802,11 +1792,11 @@ int camera_unset_focus_changed_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1819,9 +1809,9 @@ int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_da
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_ERROR_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1829,11 +1819,11 @@ int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_da
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_ERROR] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_ERROR] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1846,9 +1836,9 @@ int camera_unset_error_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_UNSET_ERROR_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1856,11 +1846,11 @@ int camera_unset_error_cb(camera_h camera)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1873,9 +1863,9 @@ int camera_foreach_supported_preview_resolution(camera_h camera, camera_supporte
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1883,11 +1873,11 @@ int camera_foreach_supported_preview_resolution(camera_h camera, camera_supporte
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1900,9 +1890,9 @@ int camera_foreach_supported_capture_resolution(camera_h camera, camera_supporte
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1910,11 +1900,11 @@ int camera_foreach_supported_capture_resolution(camera_h camera, camera_supporte
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1927,9 +1917,9 @@ int camera_foreach_supported_capture_format(camera_h camera, camera_supported_ca
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1937,11 +1927,11 @@ int camera_foreach_supported_capture_format(camera_h camera, camera_supported_ca
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1955,9 +1945,9 @@ int camera_foreach_supported_preview_format(camera_h camera, camera_supported_pr
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
+       muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -1965,11 +1955,11 @@ int camera_foreach_supported_preview_format(camera_h camera, camera_supported_pr
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -1983,7 +1973,7 @@ int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -1993,16 +1983,16 @@ int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *
        int get_width;
        int get_height;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_width, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_height, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
                *width = get_width;
                *height = get_height;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2016,7 +2006,7 @@ int camera_attr_get_lens_orientation(camera_h camera, int *angle)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2025,14 +2015,14 @@ int camera_attr_get_lens_orientation(camera_h camera, int *angle)
        sock_fd = pc->cb_info->fd;
        int get_angle;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_angle, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_angle, pc->cb_info->recvMsg);
                *angle = get_angle;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2044,7 +2034,7 @@ int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mod
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_THEATER_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2052,9 +2042,9 @@ int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mod
        }
        sock_fd = pc->cb_info->fd;
        int set_mode = (int)mode;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2067,7 +2057,7 @@ int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mo
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_THEATER_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2075,14 +2065,14 @@ int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mo
        }
        sock_fd = pc->cb_info->fd;
        int get_mode;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_theater_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2095,9 +2085,9 @@ int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supp
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2105,12 +2095,12 @@ int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supp
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
-       LOGW("Finish, return :%x", ret);
+       LOGD("Finish, return :%x", ret);
 
        return ret;
 }
@@ -2123,7 +2113,7 @@ int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_PREVIEW_FPS;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2131,9 +2121,9 @@ int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps)
        }
        sock_fd = pc->cb_info->fd;
        int set_fps = (int)fps;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_fps);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_fps);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2147,16 +2137,16 @@ int camera_attr_set_image_quality(camera_h camera,  int quality)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, quality);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, quality);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2169,7 +2159,7 @@ int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_PREVIEW_FPS;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
        int get_fps;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2178,14 +2168,14 @@ int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_fps, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_fps, pc->cb_info->recvMsg);
                *fps = (camera_attr_fps_e)get_fps;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2199,7 +2189,7 @@ int camera_attr_get_image_quality(camera_h camera, int *quality)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2207,14 +2197,14 @@ int camera_attr_get_image_quality(camera_h camera, int *quality)
        }
        sock_fd = pc->cb_info->fd;
        int get_quality;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_quality, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_quality, pc->cb_info->recvMsg);
                *quality = get_quality;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2228,7 +2218,7 @@ int camera_attr_set_zoom(camera_h camera, int zoom)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_ZOOM;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2236,9 +2226,9 @@ int camera_attr_set_zoom(camera_h camera, int zoom)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, zoom);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, zoom);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2251,7 +2241,7 @@ int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_AF_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2259,9 +2249,9 @@ int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode)
        }
        sock_fd = pc->cb_info->fd;
        int set_mode = (int)mode;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2273,11 +2263,11 @@ int camera_attr_set_af_area(camera_h camera, int x, int y)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_AF_AREA;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
        int sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, x, INT, y);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, x, INT, y);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2291,16 +2281,16 @@ int camera_attr_clear_af_area(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_CLEAR_AF_AREA;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2319,7 +2309,7 @@ int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
        int set_mode = (int)mode;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2327,9 +2317,9 @@ int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2343,7 +2333,7 @@ int camera_attr_set_exposure(camera_h camera, int value)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_EXPOSURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2351,9 +2341,9 @@ int camera_attr_set_exposure(camera_h camera, int value)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, value);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, value);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2367,7 +2357,7 @@ int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_ISO;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2375,9 +2365,9 @@ int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
        }
        sock_fd = pc->cb_info->fd;
        int set_iso = (int)iso;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_iso);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_iso);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2391,7 +2381,7 @@ int camera_attr_set_brightness(camera_h camera, int level)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_BRIGHTNESS;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2399,9 +2389,9 @@ int camera_attr_set_brightness(camera_h camera, int level)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, level);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2415,7 +2405,7 @@ int camera_attr_set_contrast(camera_h camera, int level)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_CONTRAST;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2423,9 +2413,9 @@ int camera_attr_set_contrast(camera_h camera, int level)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, level);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2442,11 +2432,10 @@ int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
                return CAMERA_ERROR_NOT_SUPPORTED;
        }
 
-       
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_WHITEBALANCE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2454,9 +2443,9 @@ int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
        }
        sock_fd = pc->cb_info->fd;
        int set_whitebalance = (int)wb;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2470,7 +2459,7 @@ int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_EFFECT;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2478,9 +2467,9 @@ int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
        }
        sock_fd = pc->cb_info->fd;
        int set_effect = (int)effect;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_effect);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_effect);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2494,7 +2483,7 @@ int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_SCENE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2502,9 +2491,9 @@ int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
        }
        sock_fd = pc->cb_info->fd;
        int set_mode = (int)mode;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2517,7 +2506,7 @@ int camera_attr_enable_tag(camera_h camera, bool enable)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_ENABLE_TAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2526,9 +2515,9 @@ int camera_attr_enable_tag(camera_h camera, bool enable)
        sock_fd = pc->cb_info->fd;
        int set_enable = (int)enable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_enable);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2545,16 +2534,16 @@ int camera_attr_set_tag_image_description(camera_h camera, const char *descripti
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, STRING, description);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, description);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2567,7 +2556,7 @@ int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientatio
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2576,9 +2565,9 @@ int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientatio
        sock_fd = pc->cb_info->fd;
        int set_orientation = (int)orientation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_orientation);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_orientation);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2595,16 +2584,16 @@ int camera_attr_set_tag_software(camera_h camera,  const char *software)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, STRING, software);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, software);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2617,7 +2606,7 @@ int camera_attr_set_geotag(camera_h camera, double latitude , double longitude,
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_GEOTAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2626,10 +2615,10 @@ int camera_attr_set_geotag(camera_h camera, double latitude , double longitude,
        sock_fd = pc->cb_info->fd;
        double set_geotag[3] = { latitude, longitude, altitude };
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send_array(api, pc->remote_handle, sock_fd, pc->cb_info, ret,
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send_array(api, sock_fd, pc->cb_info, ret,
                                                                        set_geotag, sizeof(set_geotag), sizeof(double));
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2642,16 +2631,16 @@ int camera_attr_remove_geotag(camera_h camera)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_REMOVE_GEOTAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2664,7 +2653,7 @@ int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_FLASH_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2673,9 +2662,9 @@ int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
        sock_fd = pc->cb_info->fd;
        int set_mode = (int)mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2689,7 +2678,7 @@ int camera_attr_get_zoom(camera_h camera, int *zoom)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_ZOOM;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
        int get_zoom;
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -2698,14 +2687,14 @@ int camera_attr_get_zoom(camera_h camera, int *zoom)
        }
        sock_fd = pc->cb_info->fd;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_zoom, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_zoom, pc->cb_info->recvMsg);
                *zoom = get_zoom;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2724,20 +2713,20 @@ int camera_attr_get_zoom_range(camera_h camera, int *min, int *max)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_ZOOM_RANGE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
        int get_min;
        int get_max;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_min, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_max, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
                *min = get_min;
                *max = get_max;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2756,17 +2745,17 @@ int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_AF_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_af_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2785,17 +2774,17 @@ int camera_attr_get_exposure_mode( camera_h camera, camera_attr_exposure_mode_e
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_exposure_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2813,17 +2802,17 @@ int camera_attr_get_exposure(camera_h camera, int *value)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_EXPOSURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
        int get_value;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_value, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_value, pc->cb_info->recvMsg);
                *value = get_value;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2842,20 +2831,20 @@ int camera_attr_get_exposure_range(camera_h camera, int *min, int *max)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
        int get_min;
        int get_max;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_min, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_max, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
                *min = get_min;
                *max = get_max;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2874,17 +2863,17 @@ int camera_attr_get_iso( camera_h camera,  camera_attr_iso_e *iso)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_ISO;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
        int get_iso;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_iso, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_iso, pc->cb_info->recvMsg);
                *iso = (camera_attr_iso_e)get_iso;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2903,17 +2892,17 @@ int camera_attr_get_brightness(camera_h camera,  int *level)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_BRIGHTNESS;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
        int get_level;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_level, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
                *level = get_level;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2932,20 +2921,20 @@ int camera_attr_get_brightness_range(camera_h camera, int *min, int *max)
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
        int get_min;
        int get_max;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_min, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_max, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
                *min = get_min;
                *max = get_max;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2958,7 +2947,7 @@ int camera_attr_get_contrast(camera_h camera,  int *level)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_CONTRAST;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2967,14 +2956,14 @@ int camera_attr_get_contrast(camera_h camera,  int *level)
        sock_fd = pc->cb_info->fd;
        int get_level;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_level, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
                *level = get_level;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -2987,7 +2976,7 @@ int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -2997,16 +2986,16 @@ int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
        int get_min;
        int get_max;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_min, pc->cb_info->recvMsg);
-               mmsvc_camera_msg_get(get_max, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
                *min = get_min;
                *max = get_max;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3019,7 +3008,7 @@ int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *w
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_WHITEBALANCE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3028,14 +3017,14 @@ int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *w
        sock_fd = pc->cb_info->fd;
        int get_wb;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_wb, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_wb, pc->cb_info->recvMsg);
                *wb = (camera_attr_whitebalance_e)get_wb;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3049,7 +3038,7 @@ int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_EFFECT;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3058,14 +3047,14 @@ int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
        sock_fd = pc->cb_info->fd;
        int get_effect;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_effect, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_effect, pc->cb_info->recvMsg);
                *effect = (camera_attr_effect_mode_e)get_effect;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3079,7 +3068,7 @@ int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_SCENE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3088,14 +3077,14 @@ int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode)
        sock_fd = pc->cb_info->fd;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_scene_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3109,7 +3098,7 @@ int camera_attr_is_enabled_tag(camera_h camera,  bool *enable)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_ENABLED_TAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3118,14 +3107,14 @@ int camera_attr_is_enabled_tag(camera_h camera,  bool *enable)
        sock_fd = pc->cb_info->fd;
        int get_enable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_enable, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_enable, pc->cb_info->recvMsg);
                *enable = (bool)get_enable;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3139,23 +3128,23 @@ int camera_attr_get_tag_image_description(camera_h camera,  char **description)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       char get_description[MMSVC_MSG_MAX_LENGTH] = {0,};
+       char get_description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get_string(get_description, pc->cb_info->recvMsg);
+               muse_camera_msg_get_string(get_description, pc->cb_info->recvMsg);
                *description = strdup(get_description);
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3169,7 +3158,7 @@ int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3178,15 +3167,15 @@ int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation
        sock_fd = pc->cb_info->fd;
        int get_orientation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_orientation, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_orientation, pc->cb_info->recvMsg);
                *orientation = (camera_attr_tag_orientation_e)get_orientation;
-               LOGW("success, orientation : %d", *orientation);
+               LOGD("success, orientation : %d", *orientation);
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3200,23 +3189,23 @@ int camera_attr_get_tag_software(camera_h camera, char **software)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       char get_software[MMSVC_MSG_MAX_LENGTH] = {0,};
+       char get_software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get_string(get_software, pc->cb_info->recvMsg);
+               muse_camera_msg_get_string(get_software, pc->cb_info->recvMsg);
                *software = strdup(get_software);
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3230,7 +3219,7 @@ int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_GEOTAG;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
        double get_geotag[3] = {0,};
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3239,11 +3228,11 @@ int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude
        }
        sock_fd = pc->cb_info->fd;
        int valid = 0;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get_array(get_geotag, pc->cb_info->recvMsg);
+               muse_camera_msg_get_array(get_geotag, pc->cb_info->recvMsg);
                *latitude = get_geotag[0];
                *longitude = get_geotag[1];
                *altitude = get_geotag[2];
@@ -3253,7 +3242,7 @@ int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude
                *longitude = 0;
                *altitude = 0;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3267,7 +3256,7 @@ int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_FLASH_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3276,14 +3265,14 @@ int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode)
        sock_fd = pc->cb_info->fd;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_flash_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3297,9 +3286,9 @@ int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supporte
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3307,11 +3296,11 @@ int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supporte
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3325,9 +3314,9 @@ int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_sup
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3335,11 +3324,11 @@ int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_sup
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3353,9 +3342,9 @@ int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_is
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3363,11 +3352,11 @@ int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_is
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3381,9 +3370,9 @@ int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supp
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3391,11 +3380,11 @@ int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supp
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3409,9 +3398,9 @@ int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3419,11 +3408,11 @@ int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3437,9 +3426,9 @@ int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_suppor
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3447,11 +3436,11 @@ int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_suppor
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3465,9 +3454,9 @@ int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_suppor
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
 
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
        int sock_fd;
        if (pc->cb_info == NULL) {
@@ -3475,11 +3464,11 @@ int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_suppor
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3493,19 +3482,19 @@ int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
+       LOGD("Enter, handle :%x", pc->remote_handle);
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, handle :%x", pc->remote_handle);
        return ret;
 }
 
@@ -3518,19 +3507,19 @@ int camera_attr_foreach_supported_fps_by_resolution(camera_h camera, int width,
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
+       LOGD("Enter, handle :%x", pc->remote_handle);
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
 
-       mmsvc_camera_msg_send2(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, width, INT, height);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3543,19 +3532,19 @@ int camera_attr_foreach_supported_stream_flip(camera_h camera, camera_attr_suppo
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
+       LOGD("Enter, handle :%x", pc->remote_handle);
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3569,19 +3558,19 @@ int camera_attr_foreach_supported_stream_rotation(camera_h camera, camera_attr_s
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
+       LOGD("Enter, handle :%x", pc->remote_handle);
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3595,7 +3584,7 @@ int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_STREAM_ROTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3604,9 +3593,9 @@ int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation
        sock_fd = pc->cb_info->fd;
        int set_rotation = (int)rotation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_rotation);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3620,7 +3609,7 @@ int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotatio
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_STREAM_ROTATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3629,14 +3618,14 @@ int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotatio
        sock_fd = pc->cb_info->fd;
        int get_rotation;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
                *rotation = (camera_rotation_e)get_rotation;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3650,7 +3639,7 @@ int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_STREAM_FLIP;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3659,9 +3648,9 @@ int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
        sock_fd = pc->cb_info->fd;
        int set_flip = (int)flip;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_flip);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3675,7 +3664,7 @@ int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_STREAM_FLIP;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3684,14 +3673,14 @@ int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
        sock_fd = pc->cb_info->fd;
        int get_flip;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_flip, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
                *flip = (camera_flip_e)get_flip;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3704,7 +3693,7 @@ int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_HDR_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3713,9 +3702,9 @@ int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
        sock_fd = pc->cb_info->fd;
        int set_mode = (int)mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_mode);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3732,7 +3721,7 @@ int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_GET_HDR_MODE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3741,14 +3730,14 @@ int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
        sock_fd = pc->cb_info->fd;
        int get_mode;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_mode, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
                *mode = (camera_attr_hdr_mode_e)get_mode;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3762,16 +3751,16 @@ bool camera_attr_is_supported_hdr_capture(camera_h camera)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return (bool)ret;
 }
 
@@ -3789,20 +3778,20 @@ int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_pro
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3817,20 +3806,20 @@ int camera_attr_unset_hdr_capture_progress_cb(camera_h camera)
        int ret = CAMERA_ERROR_NONE;
 
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, handle :%x", pc->remote_handle);
+       LOGD("Enter, handle :%x", pc->remote_handle);
 
-       pc->cb_info->user_cb[MMSVC_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
-       pc->cb_info->user_data[MMSVC_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
+       pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
+       pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
 
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3844,7 +3833,7 @@ int camera_attr_enable_anti_shake(camera_h camera, bool enable)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3853,9 +3842,9 @@ int camera_attr_enable_anti_shake(camera_h camera, bool enable)
        sock_fd = pc->cb_info->fd;
        int set_enable = (int)enable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_enable);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3872,7 +3861,7 @@ int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3881,14 +3870,14 @@ int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
        sock_fd = pc->cb_info->fd;
        int get_enabled;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
                *enabled = (bool)get_enabled;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3903,16 +3892,16 @@ bool camera_attr_is_supported_anti_shake(camera_h camera)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3926,7 +3915,7 @@ int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3935,9 +3924,9 @@ int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
        sock_fd = pc->cb_info->fd;
        int set_enable = (int)enable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_enable);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3954,7 +3943,7 @@ int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -3963,14 +3952,14 @@ int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
        sock_fd = pc->cb_info->fd;
        int get_enabled;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
                *enabled = (bool)get_enabled;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -3984,16 +3973,16 @@ bool camera_attr_is_supported_video_stabilization(camera_h camera)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -4007,7 +3996,7 @@ int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -4016,9 +4005,9 @@ int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
        sock_fd = pc->cb_info->fd;
        int set_enable = (int)enable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_enable);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -4035,7 +4024,7 @@ int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
        }
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -4044,14 +4033,14 @@ int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
        sock_fd = pc->cb_info->fd;
        int get_enabled;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 
        if (ret == CAMERA_ERROR_NONE) {
-               mmsvc_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
+               muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
                *enabled = (bool)get_enabled;
        }
-       LOGW("ret : 0x%x", ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -4065,16 +4054,16 @@ bool camera_attr_is_supported_auto_contrast(camera_h camera)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
                return CAMERA_ERROR_INVALID_PARAMETER;
        }
        sock_fd = pc->cb_info->fd;
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send(api, pc->remote_handle, sock_fd, pc->cb_info, ret);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }
 
@@ -4088,7 +4077,7 @@ int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
 
        int ret = CAMERA_ERROR_NONE;
        camera_cli_s *pc = (camera_cli_s *)camera;
-       mmsvc_camera_api_e api = MMSVC_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
+       muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
        int sock_fd;
        if (pc->cb_info == NULL) {
                LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
@@ -4097,8 +4086,8 @@ int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
        sock_fd = pc->cb_info->fd;
        int set_disable = (int)disable;
 
-       LOGW("Enter, remote_handle : %x", pc->remote_handle);
-       mmsvc_camera_msg_send1(api, pc->remote_handle, sock_fd, pc->cb_info, ret, INT, set_disable);
-       LOGW("ret : 0x%x", ret);
+       LOGD("Enter, remote_handle : %x", pc->remote_handle);
+       muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_disable);
+       LOGD("ret : 0x%x", ret);
        return ret;
 }