Transfer to the muse daemonsubmit/tizen/20151006.093657submit/tizen/20151006.070518submit/tizen/20151005.082535

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

4 files changed, 1375 insertions, 1302 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 509cead..8b6928d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,7 +23,7 @@ SET(service "media")
 SET(submodule "recorder")
 
 # for package file
-SET(dependents "dlog mm-camcorder capi-media-camera capi-media-audio-io audio-session-mgr")
+SET(dependents "dlog mm-camcorder capi-media-camera capi-media-audio-io")
 SET(pc_dependents "capi-base-common capi-media-camera capi-media-audio-io")
 
 SET(fw_name "${project_prefix}-${service}-${submodule}")
diff --git a/include/recorder_private.h b/include/recorder_private.h
index efcf0ed..59de601 100644
--- a/include/recorder_private.h
+++ b/include/recorder_private.h
@@ -21,11 +21,14 @@
 #include <camera.h>
 #include <mm_camcorder.h>
 #include <recorder.h>
+#include <muse_core.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define RECORDER_PARSE_STRING_SIZE 200
+
 typedef union _mediaSource{
 	camera_h camera;
 }mediasource;
@@ -41,29 +44,31 @@ typedef enum {
 	_RECORDER_EVENT_TYPE_NUM
 }_recorder_event_e;
 
-typedef enum {
-	_RECORDER_TYPE_AUDIO = 0,
-	_RECORDER_TYPE_VIDEO
-}_recorder_type_e;
+typedef struct _callback_cb_info {
+	GThread *thread;
+	gint running;
+	gint fd;
+	gpointer user_cb[MUSE_RECORDER_EVENT_TYPE_NUM];
+	gpointer user_cb_completed[MUSE_RECORDER_EVENT_TYPE_NUM];
+	gpointer user_data[MUSE_RECORDER_EVENT_TYPE_NUM];
+	gchar recvMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
+	gchar recvApiMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
+	gchar recvEventMsg[MUSE_RECORDER_MSG_MAX_LENGTH];
+	GCond *pCond;
+	GMutex *pMutex;
+	gint *activating;
+} callback_cb_info_s;
 
-typedef enum {
-	_RECORDER_SOURCE_TYPE_UNKNOWN,
-	_RECORDER_SOURCE_TYPE_CAMERA,
-}_recorder_source_type_e;
+typedef struct _recorder_cli_s{
+	intptr_t remote_handle;
+	callback_cb_info_s *cb_info;
+}recorder_cli_s;
 
-typedef struct _recorder_s{
-	MMHandleType mm_handle;
-	mediasource mm_source;
-	void* user_cb[_RECORDER_EVENT_TYPE_NUM];
-	void* user_data[_RECORDER_EVENT_TYPE_NUM];
-	unsigned int state;
-	int camera_device_count;
-	_recorder_type_e type;
-	_recorder_source_type_e src_type;
-	int origin_preview_format;
-	int changed_preview_format;
-	double last_max_input_level;
-} recorder_s;
+typedef struct _camera_cli_s{
+	intptr_t remote_handle;
+	MMHandleType client_handle;
+	callback_cb_info_s *cb_info;
+}camera_cli_s;
 
 int __convert_recorder_error_code(const char *func, int code);
 #ifdef __cplusplus
diff --git a/packaging/capi-media-recorder.spec b/packaging/capi-media-recorder.spec
index 00d5ead..914c5c8 100644
--- a/packaging/capi-media-recorder.spec
+++ b/packaging/capi-media-recorder.spec
@@ -1,18 +1,24 @@
 Name:       capi-media-recorder
 Summary:    A Recorder library in Tizen Native API
-Version:    0.2.5
+Version:    0.2.6
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake
 BuildRequires:  pkgconfig(dlog)
-BuildRequires:  pkgconfig(mm-camcorder)
-BuildRequires:  pkgconfig(audio-session-mgr)
 BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(capi-media-camera)
+BuildRequires:  pkgconfig(mmsvc-camera)
+BuildRequires:  pkgconfig(mmsvc-recorder)
+BuildRequires:  pkgconfig(glib-2.0)
+BuildRequires:  pkgconfig(mused)
+BuildRequires:  pkgconfig(capi-media-tool)
+BuildRequires:  pkgconfig(json)
 BuildRequires:  pkgconfig(capi-media-audio-io)
-
+BuildRequires:  pkgconfig(mm-camcorder)
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
 
 %description
 A Recorder library in Tizen Native API
diff --git a/src/recorder.c b/src/recorder.c
index 3d3d5d5..ff32452 100644
--- a/src/recorder.c
+++ b/src/recorder.c
@@ -14,491 +14,324 @@
 * limitations under the License.
 */
 
-
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <mm.h>
-#include <audio-session-manager-types.h>
-#include <mm_camcorder.h>
 #include <mm_types.h>
-#include <math.h>
-#include <camera.h>
+#include <recorder.h>
+#include <muse_recorder.h>
+#include <muse_recorder_msg.h>
+#include <muse_core_ipc.h>
 #include <recorder_private.h>
+#include <glib.h>
+#include <muse_core.h>
+#include <muse_core_msg_json.h>
 #include <dlog.h>
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
 
 #ifdef LOG_TAG
 #undef LOG_TAG
 #endif
 #define LOG_TAG "TIZEN_N_RECORDER"
 
-#define LOWSET_DECIBEL -300.0
-#define RECORDER_PATH_RECORDER_RESOURCE    "/usr/share/sounds/mm-camcorder/recorder_resource"
-
-
-/*
- * camera_private function
-*/
-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);
-int _camera_set_use(camera_h camera, bool used);
-bool _camera_is_used(camera_h camera);
-/*
- * end of camera_private function
- */
-
-static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param);
-static int __mm_recorder_msg_cb(int message, void *param, void *user_data);
-
-
-static int __convert_error_code_camera_to_recorder(int code)
+static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_event_e event )
 {
-	int new_code = code;
-
-	switch (code) {
-	case CAMERA_ERROR_INVALID_STATE :
-		new_code = RECORDER_ERROR_INVALID_STATE;
-		break;
-	case CAMERA_ERROR_DEVICE:
-		new_code = RECORDER_ERROR_DEVICE;
-		break;
-	case CAMERA_ERROR_SOUND_POLICY:
-		new_code = RECORDER_ERROR_SOUND_POLICY;
-		break;
-	case CAMERA_ERROR_SECURITY_RESTRICTED:
-		new_code = RECORDER_ERROR_SECURITY_RESTRICTED;
-		break;
-	default:
-		break;
-	}
-
-	return new_code;
-}
-
-
-int __convert_recorder_error_code(const char *func, int code)
-{
-	int ret = RECORDER_ERROR_INVALID_OPERATION;
-	const char *errorstr = NULL;
-
-	switch (code) {
-	case RECORDER_ERROR_INVALID_PARAMETER:
-		ret = RECORDER_ERROR_INVALID_PARAMETER;
-		errorstr = "INVALID_PARAMETER";
-		break;
-	case MM_ERROR_NONE:
-		ret = RECORDER_ERROR_NONE;
-		errorstr = "ERROR_NONE";
-		break;
-	case MM_ERROR_CAMCORDER_INVALID_ARGUMENT :
-	case MM_ERROR_COMMON_INVALID_ATTRTYPE :
-		ret = RECORDER_ERROR_INVALID_PARAMETER;
-		errorstr = "INVALID_PARAMETER";
-		break;
-	case MM_ERROR_COMMON_INVALID_PERMISSION :
-		ret = RECORDER_ERROR_PERMISSION_DENIED;
-		errorstr = "ERROR_PERMISSION_DENIED";
-		break;
-	case MM_ERROR_CAMCORDER_NOT_INITIALIZED :
-	case MM_ERROR_CAMCORDER_INVALID_STATE :
-		ret = RECORDER_ERROR_INVALID_STATE;
-		errorstr = "INVALID_STATE";
-		break;
-	case MM_ERROR_CAMCORDER_DEVICE :
-	case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND :
-	case MM_ERROR_CAMCORDER_DEVICE_BUSY :
-	case MM_ERROR_CAMCORDER_DEVICE_OPEN :
-	case MM_ERROR_CAMCORDER_DEVICE_IO :
-	case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
-	case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
-	case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER :
-		ret = RECORDER_ERROR_DEVICE;
-		errorstr = "ERROR_DEVICE";
-		break;
-	case MM_ERROR_CAMCORDER_GST_CORE :
-	case MM_ERROR_CAMCORDER_GST_LIBRARY :
-	case MM_ERROR_CAMCORDER_GST_RESOURCE :
-	case MM_ERROR_CAMCORDER_GST_STREAM :
-	case MM_ERROR_CAMCORDER_GST_STATECHANGE :
-	case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
-	case MM_ERROR_CAMCORDER_GST_LINK :
-	case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
-	case MM_ERROR_CAMCORDER_ENCODER :
-	case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
-	case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE :
-	case MM_ERROR_CAMCORDER_ENCODER_WORKING :
-	case MM_ERROR_CAMCORDER_INTERNAL :
-	case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
-	case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
-	case MM_ERROR_CAMCORDER_DSP_FAIL :
-	case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
-	case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
-	case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
-	case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
-	case MM_ERROR_CAMCORDER_INVALID_CONDITION :
-		ret = RECORDER_ERROR_INVALID_OPERATION;
-		errorstr = "INVALID_OPERATION";
-		break;
-	case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
-	case MM_ERROR_COMMON_OUT_OF_MEMORY:
-		ret = RECORDER_ERROR_OUT_OF_MEMORY;
-		errorstr = "OUT_OF_MEMORY";
-		break;
-	case MM_ERROR_POLICY_BLOCKED:
-		ret = RECORDER_ERROR_SOUND_POLICY;
-		errorstr = "ERROR_SOUND_POLICY";
-		break;
-	case MM_ERROR_POLICY_BLOCKED_BY_CALL:
-		ret = RECORDER_ERROR_SOUND_POLICY_BY_CALL;
-		errorstr = "ERROR_SOUND_POLICY_BY_CALL";
-		break;
-	case MM_ERROR_POLICY_BLOCKED_BY_ALARM:
-		ret = RECORDER_ERROR_SOUND_POLICY_BY_ALARM;
-		errorstr = "ERROR_SOUND_POLICY_BY_ALARM";
-		break;
-	case MM_ERROR_POLICY_RESTRICTED:
-		ret = RECORDER_ERROR_SECURITY_RESTRICTED;
-		errorstr = "ERROR_RESTRICTED";
-		break;
-	case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
-		ret = RECORDER_ERROR_ESD;
-		errorstr = "ERROR_ESD";
-		break;
-	case MM_ERROR_OUT_OF_STORAGE:
-		ret = RECORDER_ERROR_OUT_OF_STORAGE;
-		errorstr = "OUT_OF_STORAGE";
-		break;
-	case MM_ERROR_COMMON_OUT_OF_ARRAY:
-	case MM_ERROR_COMMON_OUT_OF_RANGE:
-	case MM_ERROR_COMMON_ATTR_NOT_EXIST:
-	case MM_ERROR_CAMCORDER_NOT_SUPPORTED:
-		ret = RECORDER_ERROR_NOT_SUPPORTED;
-		errorstr = "NOT_SUPPORTED";
-		break;
-	default:
-		ret = RECORDER_ERROR_INVALID_OPERATION;
-		errorstr = "INVALID_OPERATION";
-		break;
-	}
-
-	LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)", func, errorstr, ret, code);
-
-	return ret;
-}
-
-
-static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state)
-{
-	recorder_state_e state = RECORDER_STATE_NONE;
-	switch (mm_state) {
-	case MM_CAMCORDER_STATE_NONE:
-		state = RECORDER_STATE_NONE;
-		break;
-	case MM_CAMCORDER_STATE_NULL:
-		state = RECORDER_STATE_CREATED;
-		break;
-	case MM_CAMCORDER_STATE_READY:
-		state = RECORDER_STATE_CREATED;
-		break;
-	case MM_CAMCORDER_STATE_PREPARE:
-		state = RECORDER_STATE_READY;
-		break;
-	case MM_CAMCORDER_STATE_CAPTURING:
-		state = RECORDER_STATE_READY;
-		break;
-	case MM_CAMCORDER_STATE_RECORDING:
-		state = RECORDER_STATE_RECORDING;
-		break;
-	case MM_CAMCORDER_STATE_PAUSED:
-		state = RECORDER_STATE_PAUSED;
-		break;
-	default:
-		state = RECORDER_STATE_NONE;
-		break;
-	}
-
-	return state;
-}
-
-
-static int __mm_recorder_msg_cb(int message, void *param, void *user_data)
-{
-	recorder_s * handle = (recorder_s *)user_data;
-	MMMessageParamType *m = (MMMessageParamType *)param;
-	recorder_state_e previous_state;
-	recorder_recording_limit_type_e type;
-	int recorder_error = 0;
-
-	switch (message) {
-	case MM_MESSAGE_READY_TO_RESUME:
-		LOGW("not supported message");
-		break;
-	case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
-	case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
-	case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
-		previous_state = handle->state;
-		handle->state = __recorder_state_convert(m->state.current);
-		recorder_policy_e policy = RECORDER_POLICY_NONE;
-		if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM) {
-			switch (m->state.code) {
-			case ASM_EVENT_SOURCE_CALL_START:
-			case ASM_EVENT_SOURCE_CALL_END:
-				policy = RECORDER_POLICY_SOUND_BY_CALL;
-				LOGE("RECORDER_POLICY_SOUND_BY_CALL");
-				break;
-			case ASM_EVENT_SOURCE_ALARM_START:
-			case ASM_EVENT_SOURCE_ALARM_END:
-				policy = RECORDER_POLICY_SOUND_BY_ALARM;
-				LOGE("RECORDER_POLICY_SOUND_BY_ALARM");
-				break;
-			default:
-				policy = RECORDER_POLICY_SOUND;
-				LOGE("RECORDER_POLICY_SOUND");
-				break;
-			}
-		} else if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY) {
-			policy = RECORDER_POLICY_SECURITY;
-			LOGE("RECORDER_POLICY_SECURITY");
-		}
-
-		if (previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE]) {
-			((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy, handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
-		}
-
-		/* should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state */
-		if (policy != RECORDER_POLICY_NONE &&
-		    (m->state.current == MM_CAMCORDER_STATE_PAUSED || m->state.current == MM_CAMCORDER_STATE_NULL)) {
-			if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED]) {
-				((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]);
-			} else {
-				LOGW("_RECORDER_EVENT_TYPE_INTERRUPTED cb is NULL");
-			}
-		}
-		break;
-	case MM_MESSAGE_CAMCORDER_MAX_SIZE:
-	case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
-	case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
-		if (MM_MESSAGE_CAMCORDER_MAX_SIZE == message) {
-			type = RECORDER_RECORDING_LIMIT_SIZE;
-		} else if (MM_MESSAGE_CAMCORDER_NO_FREE_SPACE == message) {
-			type = RECORDER_RECORDING_LIMIT_FREE_SPACE;
-		} else {
-			type = RECORDER_RECORDING_LIMIT_TIME;
-		}
-		if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]) {
-			((recorder_recording_limit_reached_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])(type, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
+	char *recvMsg = cb_info->recvMsg;
+	LOGD("get event %d", event);
+
+	switch (event) {
+		case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
+		{
+			int cb_previous, cb_current, cb_by_policy;
+			muse_recorder_msg_get(cb_previous, recvMsg);
+			muse_recorder_msg_get(cb_current, recvMsg);
+			muse_recorder_msg_get(cb_by_policy, recvMsg);
+			((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)cb_previous,
+													(recorder_state_e)cb_current,
+													(bool)cb_by_policy,
+													cb_info->user_data[event]);
+			break;
 		}
-		break;
-	case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
-		if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS]) {
-			((recorder_recording_status_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS])(m->recording_status.elapsed, m->recording_status.filesize, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
+		case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
+		{
+			int cb_type;
+			muse_recorder_msg_get(cb_type, recvMsg);
+			((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)cb_type,
+															cb_info->user_data[event]);
+			break;
 		}
-		break;
-	case MM_MESSAGE_CAMCORDER_ERROR:
-		switch (m->code) {
-		case MM_ERROR_CAMCORDER_DEVICE:
-		case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT:
-		case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG:
-			recorder_error = RECORDER_ERROR_DEVICE;
+		case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
+		{
+			double cb_elapsed_time;
+			double cb_file_size;
+			muse_recorder_msg_get(cb_elapsed_time, recvMsg);
+			muse_recorder_msg_get(cb_file_size, recvMsg);
+			((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time,
+															(unsigned long long)cb_file_size,
+															cb_info->user_data[event]);
 			break;
-		case MM_ERROR_CAMCORDER_GST_CORE:
-		case MM_ERROR_CAMCORDER_GST_LIBRARY:
-		case MM_ERROR_CAMCORDER_GST_RESOURCE:
-		case MM_ERROR_CAMCORDER_GST_STREAM:
-		case MM_ERROR_CAMCORDER_GST_NEGOTIATION:
-		case MM_ERROR_CAMCORDER_GST_FLOW_ERROR:
-		case MM_ERROR_CAMCORDER_ENCODER:
-		case MM_ERROR_CAMCORDER_ENCODER_BUFFER:
-		case MM_ERROR_CAMCORDER_ENCODER_WORKING:
-		case MM_ERROR_CAMCORDER_MNOTE_CREATION:
-		case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY:
-		case MM_ERROR_CAMCORDER_INTERNAL:
-		case MM_ERROR_FILE_NOT_FOUND:
-		case MM_ERROR_FILE_READ:
-			recorder_error = RECORDER_ERROR_INVALID_OPERATION;
+		}
+		case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
+		{
+			int cb_policy, cb_previous, cb_current;
+			muse_recorder_msg_get(cb_policy, recvMsg);
+			muse_recorder_msg_get(cb_previous, recvMsg);
+			muse_recorder_msg_get(cb_current, recvMsg);
+			((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)cb_policy,
+														(recorder_state_e)cb_previous,
+														(recorder_state_e)cb_current,
+														cb_info->user_data[event]);
 			break;
-		case MM_ERROR_CAMCORDER_LOW_MEMORY:
-		case MM_ERROR_CAMCORDER_MNOTE_MALLOC:
-			recorder_error = RECORDER_ERROR_OUT_OF_MEMORY;
+		}
+		case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
+		{
+			muse_recorder_transport_info_s transport_info;
+			int tKey = 0;
+			int cb_size = 0;
+			int cb_format;
+			int cb_channel;
+			int cb_timestamp;
+			unsigned char *stream = NULL;
+			muse_recorder_msg_get(tKey, recvMsg);
+
+			if (tKey != 0) {
+				transport_info.tbm_key = tKey;
+				LOGE("Read key_info INFO : %d", transport_info.tbm_key);
+
+				if(muse_recorder_ipc_init_tbm(&transport_info) == FALSE) {
+					LOGE("Initialize TBM ERROR!!");
+					break;
+				}
+
+				if(muse_recorder_ipc_import_tbm(&transport_info) == FALSE) {
+					LOGE("Import TBM Key ERROR!!");
+					break;
+				} else {
+					muse_recorder_msg_get(cb_size, recvMsg);
+					if (cb_size > 0) {
+						stream = (unsigned char *)transport_info.bo_handle.ptr;
+					}
+				}
+			} else {
+				LOGE("Get KEY INFO sock msg ERROR!!");
+				break;
+			}
+			muse_recorder_msg_get(cb_format, recvMsg);
+			muse_recorder_msg_get(cb_channel, recvMsg);
+			muse_recorder_msg_get(cb_timestamp, recvMsg);
+			((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)stream,
+													cb_size,
+													(audio_sample_type_e)cb_format,
+													cb_channel,
+													(unsigned int)cb_timestamp,
+													cb_info->user_data[event]);
+			//unref tbm after hand over the buffer.
+			muse_recorder_ipc_unref_tbm(&transport_info);
 			break;
-		case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
-			recorder_error = RECORDER_ERROR_ESD;
+		}
+		case MUSE_RECORDER_EVENT_TYPE_ERROR:
+		{
+			int cb_error, cb_current_state;
+			muse_recorder_msg_get(cb_error, recvMsg);
+			muse_recorder_msg_get(cb_current_state, recvMsg);
+			((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)cb_error,
+													(recorder_state_e)cb_current_state,
+													cb_info->user_data[event]);
 			break;
-		case MM_ERROR_OUT_OF_STORAGE:
-			recorder_error = RECORDER_ERROR_OUT_OF_STORAGE;
+		}
+		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
+		{
+			int cb_codec;
+			muse_recorder_msg_get(cb_codec, recvMsg);
+			((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)cb_codec,
+																	cb_info->user_data[event]);
 			break;
-		default:
-			recorder_error = RECORDER_ERROR_INVALID_OPERATION;
+		}
+		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
+		{
+			int cb_format;
+			muse_recorder_msg_get(cb_format, recvMsg);
+			((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)cb_format,
+																	cb_info->user_data[event]);
 			break;
 		}
-
-		if (recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR]) {
-			((recorder_error_cb)handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])(recorder_error, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_ERROR]);
+		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
+		{
+			int cb_codec;
+			muse_recorder_msg_get(cb_codec, recvMsg);
+			((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)cb_codec,
+																	cb_info->user_data[event]);
+			break;
 		}
-		break;
-	case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
-		if (handle->last_max_input_level < m->rec_volume_dB) {
-			handle->last_max_input_level = m->rec_volume_dB;
+		case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
+		{
+			int width;
+			int height;
+			muse_recorder_msg_get(width, recvMsg);
+			muse_recorder_msg_get(height, recvMsg);
+			((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width,
+																	height,
+																	cb_info->user_data[event]);
+			break;
 		}
-		break;
-	default:
-		break;
-	}
-
-	return 1;
-}
-
 
-static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
-{
-	if (user_param == NULL || stream == NULL) {
-		return 0;
-	}
-
-	recorder_s *handle = (recorder_s *)user_param;
-	audio_sample_type_e format = AUDIO_SAMPLE_TYPE_U8;
-
-	if (stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE) {
-		format = AUDIO_SAMPLE_TYPE_S16_LE;
-	}
-
-	if( handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] ){
-		((recorder_audio_stream_cb)(handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]))(stream->data, stream->length, format,
-												 stream->channel, stream->timestamp,
-												 handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
+		default:
+			LOGE("Unknonw event");
+			break;
 	}
-
-	return 1;
+	return;
 }
 
-
-static int _recorder_check_and_set_attribute(recorder_h recorder, const char *attribute_name, int set_value)
+static void *_client_cb_handler(gpointer data)
 {
-	bool reset_pipeline = false;
-	bool restore_set = false;
-	int ret = MM_ERROR_NONE;
-	int ret2 = MM_ERROR_NONE;
-	int current_value = -1;
-	int current_audio_disable = 0;
-
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
-
-	if (recorder == NULL) {
-		LOGE("handle is NULL");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-
-	mm_camcorder_get_state(handle->mm_handle, &mmstate);
-	if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
-		LOGE("invalid state %d", mmstate);
-		return RECORDER_ERROR_INVALID_STATE;
-	}
-
-	if (handle->type == _RECORDER_TYPE_AUDIO && mmstate == MM_CAMCORDER_STATE_PREPARE) {
-		mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					    MMCAM_AUDIO_DISABLE, &current_audio_disable,
-					    attribute_name, &current_value,
-					    NULL);
-
-		if (current_value != set_value) {
-			LOGD("try to reset pipeline");
-
-			ret = mm_camcorder_stop(handle->mm_handle);
-			if (ret != MM_ERROR_NONE) {
-				LOGE("mm_camcorder_stop failed 0x%x", ret);
-				return __convert_recorder_error_code(attribute_name, ret);
+	int ret;
+	int api;
+	int num_token = 0;
+	int i = 0;
+	int str_pos = 0;
+	int prev_pos = 0;
+	callback_cb_info_s *cb_info = data;
+	char *recvMsg = cb_info->recvMsg;
+	char parseStr[RECORDER_PARSE_STRING_SIZE][MUSE_RECORDER_MSG_MAX_LENGTH] = {{0,0},};
+
+	while (g_atomic_int_get(&cb_info->running)) {
+		ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg);
+		if (ret <= 0)
+			break;
+		recvMsg[ret] = '\0';
+		str_pos = 0;
+		prev_pos = 0;
+		num_token = 0;
+		memset(parseStr, 0, RECORDER_PARSE_STRING_SIZE * MUSE_RECORDER_MSG_MAX_LENGTH);
+		LOGD("recvMSg : %s, length : %d", recvMsg, ret);
+
+		/* 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);
+				LOGD("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
+				prev_pos = str_pos+1;
+				num_token++;
 			}
+		}
+		LOGD("num_token : %d", num_token);
+		/* Re-construct to the useful single msg. */
+		for (i = 0; i < num_token; i++) {
 
-			ret = mm_camcorder_unrealize(handle->mm_handle);
-			if (ret != MM_ERROR_NONE) {
-				LOGE("mm_camcorder_unrealize failed 0x%x", ret);
-				mm_camcorder_start(handle->mm_handle);
-				return __convert_recorder_error_code(attribute_name, ret);
+			if (i >= RECORDER_PARSE_STRING_SIZE)
+				break;
+			if (muse_recorder_msg_get(api, &(parseStr[i][0]))) {
+				if(api < MUSE_RECORDER_API_MAX){
+					LOGD("api : %d, wait ends.", api);
+					g_mutex_lock(&(cb_info->pMutex[api]));
+					/* The api msgs should be distinguished from the event msg. */
+					memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
+					strcpy(cb_info->recvApiMsg, &(parseStr[i][0]));
+					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]));
+					if(api == MUSE_RECORDER_API_DESTROY) {
+						g_atomic_int_set(&cb_info->running, 0);
+						LOGD("close client cb handler");
+					}
+
+				} else if(api == MUSE_RECORDER_CB_EVENT) {
+					int event;
+					if (muse_recorder_msg_get(event, &(parseStr[i][0]))) {
+						LOGD("go callback : %d", event);
+						_client_user_callback(cb_info, event);
+					}
+				}
+			}else{
+				LOGD("muse_recorder_msg_get FAIL");
 			}
-
-			reset_pipeline = true;
 		}
 	}
+	LOGD("client cb exit");
 
-	if (!strcmp(attribute_name, MMCAM_AUDIO_ENCODER)) {
-		if (set_value == RECORDER_AUDIO_CODEC_DISABLE) {
-			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-							  MMCAM_AUDIO_DISABLE, true,
-						          NULL);
-		} else {
-			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-							  MMCAM_AUDIO_DISABLE, false,
-							  MMCAM_AUDIO_ENCODER, set_value,
-							  NULL);
-		}
-	} else {
-		ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-						  attribute_name, set_value,
-						  NULL);
-	}
+	return NULL;
+}
 
-	if (ret != MM_ERROR_NONE) {
-		LOGE("set [%s] failed 0x%x", attribute_name, ret);
-	}
+static callback_cb_info_s *_client_callback_new(gint sockfd)
+{
+	callback_cb_info_s *cb_info;
+	GCond *recorder_cond;
+	GMutex *recorder_mutex;
+	gint *recorder_activ;
+	g_return_val_if_fail(sockfd > 0, NULL);
+
+	cb_info = g_new0(callback_cb_info_s, 1);
+	recorder_cond = g_new0(GCond, MUSE_RECORDER_API_MAX);
+	recorder_mutex = g_new0(GMutex, MUSE_RECORDER_API_MAX);
+	recorder_activ = g_new0(gint, MUSE_RECORDER_API_MAX);
+
+	g_atomic_int_set(&cb_info->running, 1);
+	cb_info->fd = sockfd;
+	cb_info->pCond = recorder_cond;
+	cb_info->pMutex = recorder_mutex;
+	cb_info->activating = recorder_activ;
+	cb_info->thread =
+		g_thread_new("callback_thread", _client_cb_handler,
+			     (gpointer) cb_info);
+
+	return cb_info;
+}
 
-	if (reset_pipeline) {
-		ret2 = mm_camcorder_realize(handle->mm_handle);
-		if (ret2 == MM_ERROR_NONE) {
-			ret2 = mm_camcorder_start(handle->mm_handle);
-			if (ret2 == MM_ERROR_NONE) {
-				LOGW("restart pipeline done.");
+static int client_wait_for_cb_return(muse_recorder_api_e api, callback_cb_info_s *cb_info, int time_out)
+{
+	int ret = RECORDER_ERROR_NONE;
+	gint64 end_time;
+
+	LOGD("Enter api : %d", api);
+	g_mutex_lock(&(cb_info->pMutex[api]));
+
+	end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
+	if (cb_info->activating[api] != 1) {
+		if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
+			LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
+			if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+				ret = RECORDER_ERROR_INVALID_OPERATION;
 			} else {
-				LOGE("mm_camcorder_start failed 0x%x", ret2);
-				mm_camcorder_unrealize(handle->mm_handle);
+				LOGD("API %d passed successfully", api);
 			}
 		} else {
-			LOGE("mm_camcorder_realize failed 0x%x", ret2);
+			ret = RECORDER_ERROR_INVALID_OPERATION;
 		}
-
-		if (ret2 != MM_ERROR_NONE) {
-			restore_set = true;
-			/* determine return value */
-			if (ret == MM_ERROR_NONE) {
-				ret = ret2;
-			}
+	} else {
+		LOGD("condition is already checked for the api : %d.", api);
+		cb_info->activating[api] = 0;
+		if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
+			ret = RECORDER_ERROR_INVALID_OPERATION;
+		} else {
+			LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
 		}
 	}
+	g_mutex_unlock(&(cb_info->pMutex[api]));
+	LOGD("ret of api %d : 0x%x", api, ret);
+	return ret;
+}
 
-	if (restore_set) {
-		ret2 = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-						   MMCAM_AUDIO_DISABLE, current_audio_disable,
-						   attribute_name, current_value,
-						   NULL);
-		LOGW("restore attribute set : 0x%x", ret2);
+static void _client_callback_destroy(callback_cb_info_s * cb_info)
+{
+	g_return_if_fail(cb_info != NULL);
 
-		ret2 = mm_camcorder_realize(handle->mm_handle);
-		LOGW("restore mm_camcorder_realize : 0x%x", ret2);
+	LOGI("%p Callback destroyed", cb_info->thread);
+	g_thread_join(cb_info->thread);
+	g_thread_unref(cb_info->thread);
 
-		ret2 = mm_camcorder_start(handle->mm_handle);
-		LOGW("restore mm_camcorder_realize : 0x%x", ret2);
-		if (ret2 != MM_ERROR_NONE) {
-			ret2 = mm_camcorder_unrealize(handle->mm_handle);
-			LOGW("restore mm_camcorder_unrealize : 0x%x", ret2);
-		}
-	}
 
-	return __convert_recorder_error_code(attribute_name, ret);
+	if (cb_info->pCond) {
+		g_free(cb_info->pCond);
+	}
+	if (cb_info->pMutex) {
+		g_free(cb_info->pMutex);
+	}
+	g_free(cb_info);
 }
 
-
 int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
 {
-	int ret = MM_ERROR_NONE;
-	int resource_fd = -1;
-	recorder_s *handle = NULL;
-	int preview_format = MM_PIXEL_FORMAT_NV12;
-	int camera_device_count = 0;
-
 	if (camera == NULL) {
 		LOGE("NULL pointer camera handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
@@ -508,158 +341,118 @@ int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	/* Check already used in another recorder */
-	if (_camera_is_used(camera)) {
-		LOGE("[%s] camera is using in another recorder.", __func__);
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-
-	resource_fd = open(RECORDER_PATH_RECORDER_RESOURCE, O_RDONLY);
-	if (resource_fd < 0) {
-		LOGE("failed to open recorder resource : errno [%d]", errno);
-		if (errno == EPERM || errno == EACCES) {
-			LOGE("permission denied");
-			return RECORDER_ERROR_PERMISSION_DENIED;
-		} else {
-			LOGE("invalid operation");
-			return RECORDER_ERROR_INVALID_OPERATION;
-		}
-	}
+	int sock_fd = -1;
+	char *sndMsg;
+	int ret = RECORDER_ERROR_NONE;
+	camera_cli_s *camera_pc = (camera_cli_s *)camera;
+	recorder_cli_s *pc;
+	muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
+	muse_core_api_module_e muse_module = MUSE_RECORDER;
+	intptr_t camera_handle = (intptr_t)camera_pc->remote_handle;
+	intptr_t handle;
+	int recorder_type = MUSE_RECORDER_TYPE_VIDEO;
 
-	close(resource_fd);
-	resource_fd = -1;
-
-	LOGW("permission check done");
-
-	handle = (recorder_s*)malloc( sizeof(recorder_s) );
-	if(handle == NULL){
-		LOGE("[%s] malloc error", __func__);
-		return RECORDER_ERROR_OUT_OF_MEMORY;
-	}
-
-	memset(handle, 0 , sizeof(recorder_s));
-	handle->src_type = _RECORDER_SOURCE_TYPE_CAMERA;
-	handle->last_max_input_level = LOWSET_DECIBEL;
-	handle->changed_preview_format = -1;
-	handle->mm_source.camera = camera;
-
-	_camera_get_mm_handle(camera, &handle->mm_handle);
-	_camera_set_relay_mm_message_callback(camera, __mm_recorder_msg_cb , (void*)handle);
-	handle->type = _RECORDER_TYPE_VIDEO;
-	recorder_get_state((recorder_h)handle, (recorder_state_e*)&handle->state);
-
-	mm_camcorder_get_attributes(handle->mm_handle, NULL,
-				    MMCAM_CAMERA_FORMAT, &preview_format,
-				    NULL);
-	handle->origin_preview_format = preview_format;
-	mm_camcorder_get_attributes(handle->mm_handle, NULL,
-				    MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
-				    NULL);
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
-				    MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
-				    NULL);
-	if (ret != MM_ERROR_NONE) {
-		free(handle);
-		handle = NULL;
-		LOGE("get device count error");
-		return __convert_recorder_error_code(__func__, ret);
-	}
-	if (camera_device_count == 0) {
-		free(handle);
-		handle = NULL;
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	} else {
-		handle->camera_device_count = camera_device_count;
+	pc = g_new0(recorder_cli_s, 1);
+	if (pc == NULL) {
+		return 0;
 	}
 
-	_camera_set_use(camera, true);
-	if (handle->state == RECORDER_STATE_CREATED) {
-		ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-						  MMCAM_CAMERA_FORMAT, preview_format,
-						  NULL);
-		if (ret == MM_ERROR_NONE) {
-			handle->changed_preview_format = preview_format;
+	LOGD("remote handle : 0x%x", camera_handle);
+	sock_fd = muse_core_client_new();
+	sndMsg = muse_core_msg_json_factory_new(api,
+					      MUSE_TYPE_INT, "module", muse_module,
+					      MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
+					      MUSE_TYPE_POINTER, "camera_handle", camera_handle,
+					      0);
+	muse_core_ipc_send_msg(sock_fd, sndMsg);
+	LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg);
+	muse_core_msg_json_factory_free(sndMsg);
+
+	pc->cb_info = _client_callback_new(sock_fd);
+	LOGD("cb info : %d", pc->cb_info->fd);
+
+	ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
+		if (handle == 0) {
+			LOGE("Receiving Handle Failed!!");
+			goto ErrorExit;
+		} else {
+			pc->remote_handle = handle;
 		}
-	}
-	*recorder = (recorder_h)handle;
+		LOGD("recorder create 0x%x", pc->remote_handle);
+		*recorder = (recorder_h) pc;
+	} else
+		goto ErrorExit;
+	LOGD("ret : 0x%x", ret);
+	return ret;
 
-	return RECORDER_ERROR_NONE;
+ErrorExit:
+	g_free(pc);
+	LOGD("ErrorExit!!! ret value : %d", ret);
+	return ret;
 }
 
 
 int recorder_create_audiorecorder(recorder_h *recorder)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = NULL;
-	MMCamPreset info;
-	int camera_device_count = 0;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	info.videodev_type = MM_VIDEO_DEVICE_NONE;
-
-	handle = (recorder_s *)malloc(sizeof(recorder_s));
-	if (handle == NULL) {
-		LOGE("OUT_OF_MEMORY(0x%08x)", RECORDER_ERROR_OUT_OF_MEMORY);
-		return RECORDER_ERROR_OUT_OF_MEMORY;
-	}
-
-	memset(handle, 0, sizeof(recorder_s));
+	int sock_fd = -1;
+	char *sndMsg;
+	int ret = RECORDER_ERROR_NONE;
+	recorder_cli_s *pc = NULL;
 
-	handle->last_max_input_level = LOWSET_DECIBEL;
+	muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
+	muse_core_api_module_e muse_module = MUSE_RECORDER;
+	int recorder_type = MUSE_RECORDER_TYPE_AUDIO;
 
-	ret = mm_camcorder_create(&handle->mm_handle, &info);
-	if (ret != MM_ERROR_NONE) {
-		free(handle);
-		handle = NULL;
-		LOGE("mm_camcorder_create fail");
-		return __convert_recorder_error_code(__func__, ret);
-	}
+	LOGW("Enter");
+	sock_fd = muse_core_client_new();
+	sndMsg = muse_core_msg_json_factory_new(api,
+					      MUSE_TYPE_INT, "module", muse_module,
+					      MUSE_TYPE_INT, PARAM_RECORDER_TYPE, recorder_type,
+					      0);
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
-					  MMCAM_PID_FOR_SOUND_FOCUS, getpid(),
-					  NULL);
+	muse_core_ipc_send_msg(sock_fd, sndMsg);
+	LOGD("sock_fd : %d, msg : %s", sock_fd, sndMsg);
+	muse_core_msg_json_factory_free(sndMsg);
 
-	if (ret != MM_ERROR_NONE) {
-		mm_camcorder_destroy(handle->mm_handle);
-		free(handle);
-		handle = NULL;
-		LOGE("AUDIO mode setting fail");
-		return __convert_recorder_error_code(__func__, ret);
-	}
-	ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
-				    MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count, NULL);
-	if (ret != MM_ERROR_NONE) {
-		mm_camcorder_destroy(handle->mm_handle);
-		free(handle);
-		handle = NULL;
-		LOGE("get device count error");
-		return __convert_recorder_error_code(__func__, ret);
-	} else {
-		handle->camera_device_count = camera_device_count;
+	pc = g_new0(recorder_cli_s, 1);
+	if (pc == NULL) {
+		return 0;
 	}
-	handle->state = RECORDER_STATE_CREATED;
-	handle->mm_source.camera = NULL;
-	handle->type = _RECORDER_TYPE_AUDIO;
-
-	mm_camcorder_set_message_callback(handle->mm_handle, __mm_recorder_msg_cb, (void*)handle);
 
-	*recorder = (recorder_h)handle;
+	pc->cb_info = _client_callback_new(sock_fd);
+	ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
+	if (ret == RECORDER_ERROR_NONE) {
+		intptr_t handle = 0;
+		muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
+		if (handle == 0) {
+			LOGE("Receiving Handle Failed!!");
+			goto ErrorExit;
+		} else {
+			pc->remote_handle = handle;
+		}
+		LOGD("recorder create 0x%x", pc->remote_handle);
+		*recorder = (recorder_h)pc;
+	} else
+		goto ErrorExit;
+	LOGD("ret : 0x%x", ret);
+	return ret;
 
-	return RECORDER_ERROR_NONE;
+ErrorExit:
+	g_free(pc);
+	LOGD("ret value : %d", ret);
+	return ret;
 }
 
 
 int recorder_get_state(recorder_h recorder, recorder_state_e *state)
 {
-	int ret = MM_ERROR_NONE;
-	MMCamcorderStateType mmstate;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
@@ -669,308 +462,336 @@ int recorder_get_state(recorder_h recorder, recorder_state_e *state)
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	recorder_s *handle = (recorder_s*)recorder;
+	int ret = RECORDER_ERROR_NONE;
 
-	ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_recorder_error_code(__func__, ret);
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	int get_state;
 
-	*state = __recorder_state_convert(mmstate);
+	LOGD("Enter, remote_handle : %x", pc->remote_handle);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
-	return RECORDER_ERROR_NONE;
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_state, pc->cb_info->recvMsg);
+		*state = (recorder_state_e)get_state;
+	}
+	LOGD("ret : 0x%x, get_state : %d", ret, get_state);
+	return ret;
 }
 
 
 int recorder_destroy(recorder_h recorder)
 {
-	recorder_s *handle = NULL;
-	int ret = MM_ERROR_NONE;
-	int preview_format;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	handle = (recorder_s *)recorder;
-
-	if (handle->type == _RECORDER_TYPE_VIDEO) {
-		/* set to unsed */
-		_camera_set_use(handle->mm_source.camera, false);
-		ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-						  MMCAM_CAMERA_FORMAT, &preview_format,
-						  NULL);
-
-		/* preview format was changed? */
-		if (ret == MM_ERROR_NONE && preview_format == handle->changed_preview_format) {
-			ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-							  MMCAM_CAMERA_FORMAT, handle->origin_preview_format,
-							  NULL);
-		}
-
-		if (ret == MM_ERROR_NONE) {
-			_camera_set_relay_mm_message_callback(handle->mm_source.camera, NULL, NULL);
-		}
-	} else {
-		ret = mm_camcorder_destroy(handle->mm_handle);
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	if (ret == MM_ERROR_NONE) {
-		free(handle);
+	if (pc == NULL) {
+		return RECORDER_ERROR_INVALID_OPERATION;
+	} else if (pc->cb_info == NULL) {
+		return RECORDER_ERROR_INVALID_OPERATION;
 	}
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	_client_callback_destroy(pc->cb_info);
+	g_free(pc);
+	pc = NULL;
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_prepare(recorder_h recorder)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamcorderStateType mmstate;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	if (handle->type == _RECORDER_TYPE_VIDEO) {
-		return __convert_error_code_camera_to_recorder(camera_start_preview(handle->mm_source.camera));
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
+	LOGD("ENTER");
 
-	if (ret == MM_ERROR_NONE && mmstate < MM_CAMCORDER_STATE_READY) {
-		ret = mm_camcorder_realize(handle->mm_handle);
-		if (ret != MM_ERROR_NONE) {
-			LOGE("mm_camcorder_realize fail");
-			return __convert_recorder_error_code(__func__, ret);
-		}
-	}
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 
-	ret = mm_camcorder_start(handle->mm_handle);
-	if (ret != MM_ERROR_NONE) {
-		LOGE("mm_camcorder_start fail");
-		mm_camcorder_unrealize(handle->mm_handle);
-		return __convert_recorder_error_code(__func__, ret);
-	}
+	LOGD("ret : 0x%x", ret);
 
-	return RECORDER_ERROR_NONE;
+	return ret;
 }
 
 
 int recorder_unprepare(recorder_h recorder)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamcorderStateType mmstate;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
-	if (ret == MM_ERROR_NONE && mmstate == MM_CAMCORDER_STATE_PREPARE) {
-		ret = mm_camcorder_stop(handle->mm_handle);
-		if( ret != MM_ERROR_NONE){
-			LOGE("mm_camcorder_stop fail");
-		}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
 
-	if (ret == MM_ERROR_NONE) {
-		ret = mm_camcorder_unrealize(handle->mm_handle);
-		if (ret != MM_ERROR_NONE) {
-			LOGE("mm_camcorder_unrealize fail");
-			mm_camcorder_start(handle->mm_handle);
-		}
-	}
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_start(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_START;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, mm_camcorder_record(handle->mm_handle));
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_pause(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, mm_camcorder_pause(handle->mm_handle));
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_commit(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	return __convert_recorder_error_code(__func__, mm_camcorder_commit(handle->mm_handle));
+	LOGD("ENTER");
+
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_cancel(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	return __convert_recorder_error_code(__func__, mm_camcorder_cancel(handle->mm_handle));
+	LOGD("ENTER");
+
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_video_resolution(recorder_h recorder, int width, int height)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s*)recorder;
-	recorder_state_e state;
-
-	if (handle == NULL) {
+	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
-	recorder_get_state(recorder, &state);
-	if (state > RECORDER_STATE_READY) {
-		LOGE("RECORDER_ERROR_INVALID_STATE (state:%d)", state);
-		return RECORDER_ERROR_INVALID_STATE;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_WIDTH, width,
-					  MMCAM_VIDEO_HEIGHT, height,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send2(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, width,
+							INT, height);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s*)recorder;
-
-	if (!handle) {
+	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
-
 	if (!width || !height) {
 		LOGE("NULL pointer width = [%p], height = [%p]", width, height);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_width;
+	int get_height;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_WIDTH, width,
-					  MMCAM_VIDEO_HEIGHT, height,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_width, pc->cb_info->recvMsg);
+		muse_recorder_msg_get(get_height, pc->cb_info->recvMsg);
+		*width = get_width;
+		*height = get_height;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_foreach_supported_video_resolution(recorder_h recorder,
                                                 recorder_supported_video_resolution_cb foreach_cb, void *user_data)
 {
-	int i = 0;
-	int ret = MM_ERROR_NONE;
-	recorder_s * handle = (recorder_s*)recorder;
-	MMCamAttrsInfo video_width;
-	MMCamAttrsInfo video_height;
-
-	if (!handle) {
-		LOGE("NULL pointer handle");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
-
-	if (!foreach_cb) {
-		LOGE("NULL pointer callback");
+	if( recorder == NULL || foreach_cb == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
 
-	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_WIDTH, &video_width);
-	ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_HEIGHT, &video_height);
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
 
-	if (ret != MM_ERROR_NONE ) {
-		return __convert_recorder_error_code(__func__, ret);
-	}
+	LOGD("Enter, handle :%x", pc->remote_handle);
 
-	for (i = 0 ; i < video_width.int_array.count ; i++) {
-		if (!foreach_cb(video_width.int_array.array[i], video_height.int_array.array[i], user_data)) {
-			break;
-		}
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_audio_level(recorder_h recorder, double *level)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-	recorder_state_e state;
-
 	if (recorder == NULL || level == NULL) {
 		LOGE("NULL pointer %p %p", recorder, level);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 
-	recorder_get_state(recorder, &state);
-	if (state < RECORDER_STATE_RECORDING) {
-		LOGE("RECORDER_ERROR_INVALID_STATE(0x%08x)", RECORDER_ERROR_INVALID_STATE);
-		return RECORDER_ERROR_INVALID_STATE;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	double get_level;
 
-	*level = handle->last_max_input_level;
-	handle->last_max_input_level = LOWSET_DECIBEL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_level, pc->cb_info->recvMsg);
+		*level = get_level;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_filename(recorder_h recorder,  const char *filename)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
-
 	if (recorder == NULL) {
 		LOGE("handle is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
@@ -980,28 +801,26 @@ int recorder_set_filename(recorder_h recorder,  const char *filename)
 		LOGE("filename is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	mm_camcorder_get_state(handle->mm_handle, &mmstate);
-	if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
-		LOGE("invalid state %d", mmstate);
-		return RECORDER_ERROR_INVALID_STATE;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_FILENAME, filename, strlen(filename),
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, filename);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_filename(recorder_h recorder,  char **filename)
 {
-	int ret = MM_ERROR_NONE;
-	char *record_filename = NULL;
-	int record_filename_size;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("handle is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
@@ -1011,999 +830,1242 @@ int recorder_get_filename(recorder_h recorder,  char **filename)
 		LOGE("filename is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_FILENAME, &record_filename, &record_filename_size,
-					  NULL);
-	if (ret == MM_ERROR_NONE && record_filename) {
-		*filename = strdup(record_filename);
-	} else {
-		LOGE("internal return (0x%08x), get filename p:%p", ret, record_filename);
-		*filename = NULL;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
+
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg);
+		*filename = strdup(get_filename);
+	}
+	LOGD("ret : 0x%x, filename : %s", ret, *filename);
+	return ret;
 }
 
 
 int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
 {
-	int format_table[6] = { MM_FILE_FORMAT_3GP, /* RECORDER_FILE_FORMAT_3GP */
-	                        MM_FILE_FORMAT_MP4, /* RECORDER_FILE_FORMAT_MP4 */
-	                        MM_FILE_FORMAT_AMR, /* RECORDER_FILE_FORMAT_AMR */
-	                        MM_FILE_FORMAT_AAC, /* RECORDER_FILE_FORMAT_ADTS */
-	                        MM_FILE_FORMAT_WAV, /* RECORDER_FILE_FORMAT_WAV */
-	                        MM_FILE_FORMAT_OGG  /* RECORDER_FILE_FORMAT_OGG */
-	};
-
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
 	if (format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_OGG) {
 		LOGE("invalid format %d", format);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int set_format = (int)format;
+
+	LOGD("ENTER, set_format : %d", set_format);
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_FILE_FORMAT, format_table[format]);
+	muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-	int mm_format;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
 	if (format == NULL) {
-		LOGE("format is NULL");
+		LOGE("NULL pointer data");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_FILE_FORMAT, &mm_format,
-					  NULL);
-	if (ret == MM_ERROR_NONE) {
-		switch (mm_format) {
-		case MM_FILE_FORMAT_3GP:
-			*format = RECORDER_FILE_FORMAT_3GP;
-			break;
-		case MM_FILE_FORMAT_MP4 :
-			*format = RECORDER_FILE_FORMAT_MP4;
-			break;
-		case MM_FILE_FORMAT_AMR :
-			*format = RECORDER_FILE_FORMAT_AMR;
-			break;
-		case MM_FILE_FORMAT_AAC :
-			*format = RECORDER_FILE_FORMAT_ADTS;
-			break;
-		case MM_FILE_FORMAT_WAV:
-			*format = RECORDER_FILE_FORMAT_WAV;
-			break;
-		case MM_FILE_FORMAT_OGG:
-			*format = RECORDER_FILE_FORMAT_OGG;
-			break;
-		default :
-			ret = MM_ERROR_CAMCORDER_INTERNAL;
-			break;
-		}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	int get_format;
+
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_format, pc->cb_info->recvMsg);
+		LOGD("get_fileformat : %d", get_format);
+		*format = (recorder_file_format_e)get_format;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
 
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
-	handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
-
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_state_changed_cb(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
+
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
-	handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
-
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_interrupted_cb(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
 
-	ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, __mm_audio_stream_cb, handle);
-	if (ret == MM_ERROR_NONE){
-		handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
-		handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_audio_stream_cb(recorder_h recorder)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
-
-	ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, NULL, NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
+
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = callback;
-	handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = user_data;
-
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_error_cb(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = NULL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
+
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
-	handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
-
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_recording_status_cb(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
+	if( recorder == NULL || callback == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (callback == NULL) {
-		LOGE("NULL pointer callback");
+	int ret = RECORDER_ERROR_NONE;
+
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
+
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
-	handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
-
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
-	handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
+	LOGD("ENTER");
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb, void *user_data)
 {
-	int i = 0;
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamAttrsInfo info;
-	int format;
-
-	if (recorder == NULL) {
-		LOGE("NULL pointer handle");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-	if (foreach_cb == NULL) {
-		LOGE("NULL pointer foreach_cb");
+	if( recorder == NULL || foreach_cb == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
 
-	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILE_FORMAT, &info);
-	if (ret != MM_ERROR_NONE) {
-		LOGE("mm_camcorder_get_attribute_info failed 0x%x", ret);
-		return __convert_recorder_error_code(__func__, ret);;
-	}
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
 
-	for (i = 0 ; i < info.int_array.count ; i++) {
-		switch (info.int_array.array[i]) {
-		case MM_FILE_FORMAT_3GP:
-			format = RECORDER_FILE_FORMAT_3GP;
-			break;
-		case MM_FILE_FORMAT_MP4 :
-			format = RECORDER_FILE_FORMAT_MP4;
-			break;
-		case MM_FILE_FORMAT_AMR :
-			format = RECORDER_FILE_FORMAT_AMR;
-			break;
-		case MM_FILE_FORMAT_AAC:
-			format = RECORDER_FILE_FORMAT_ADTS;
-			break;
-		case MM_FILE_FORMAT_WAV:
-			format = RECORDER_FILE_FORMAT_WAV;
-			break;
-		default :
-			format = -1;
-			break;
-		}
+	LOGD("Enter, handle :%x", pc->remote_handle);
 
-		if (format != -1 && !foreach_cb(format,user_data)) {
-			break;
-		}
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_MAX_SIZE, kbyte,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, kbyte);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_time_limit(recorder_h recorder, int second)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
 		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_TIME_LIMIT, second,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, second);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
 {
-	if (device < RECORDER_AUDIO_DEVICE_MIC || device > RECORDER_AUDIO_DEVICE_MODEM) {
-		LOGE("invalid device %d", device);
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int set_device = (int)device;
+
+	LOGD("ENTER");
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_DEVICE, device);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, set_device);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
 {
-	recorder_s *handle = (recorder_s *)recorder;
-	int audio_table[4] = { MM_AUDIO_CODEC_AMR,      /* RECORDER_AUDIO_CODEC_AMR */
-			       MM_AUDIO_CODEC_AAC,      /* RECORDER_AUDIO_CODEC_AAC */
-			       MM_AUDIO_CODEC_VORBIS,   /* RECORDER_AUDIO_CODEC_VORBIS */
-			       MM_AUDIO_CODEC_WAVE      /* RECORDER_AUDIO_CODEC_PCM */
-	};
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
 	if (codec != RECORDER_AUDIO_CODEC_DISABLE &&
 	    (codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM)) {
 		LOGE("invalid parameter : codec %d", codec);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	if (handle->type == _RECORDER_TYPE_AUDIO && codec == RECORDER_AUDIO_CODEC_DISABLE) {
-		LOGE("AUDIO_CODEC_DISABLE is not supported in audio mode");
-		return RECORDER_ERROR_NOT_SUPPORTED;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	int set_codec = (int)codec;
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER, codec == RECORDER_AUDIO_CODEC_DISABLE ? RECORDER_AUDIO_CODEC_DISABLE : audio_table[codec]);
+	LOGD("ENTER");
+
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, set_codec);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
 {
-	int ret = MM_ERROR_NONE;
-	int mm_codec = 0;
-	int audio_disable = 0;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
 	if (codec == NULL) {
 		LOGE("codec is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_codec;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_ENCODER, &mm_codec,
-					  MMCAM_AUDIO_DISABLE, &audio_disable,
-					  NULL);
+	LOGD("ENTER");
 
-	if (ret == MM_ERROR_NONE && audio_disable == 0) {
-		switch (mm_codec) {
-		case MM_AUDIO_CODEC_AMR :
-			*codec = RECORDER_AUDIO_CODEC_AMR;
-			break;
-		case MM_AUDIO_CODEC_AAC :
-			*codec = RECORDER_AUDIO_CODEC_AAC;
-			break;
-		case MM_AUDIO_CODEC_VORBIS:
-			*codec = RECORDER_AUDIO_CODEC_VORBIS;
-			break;
-		case MM_AUDIO_CODEC_WAVE:
-			*codec = RECORDER_AUDIO_CODEC_PCM;
-			break;
-		default :
-			ret = MM_ERROR_CAMCORDER_INTERNAL;
-			break;
-		}
-	} else if (ret == MM_ERROR_NONE && audio_disable) {
-		*codec = RECORDER_AUDIO_CODEC_DISABLE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
+		*codec = (recorder_audio_codec_e)get_codec;
 	}
-
-	return __convert_recorder_error_code(__func__, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
 {
-	int ret = MM_ERROR_NONE;
-	int video_table[4] = { MM_VIDEO_CODEC_H263,     /* RECORDER_VIDEO_CODEC_H263 */
-			       MM_VIDEO_CODEC_H264,     /* RECORDER_VIDEO_CODEC_H264 */
-			       MM_VIDEO_CODEC_MPEG4,    /* RECORDER_VIDEO_CODEC_MPEG4 */
-			       MM_VIDEO_CODEC_THEORA    /* RECORDER_VIDEO_CODEC_THEORA */
-	};
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
-
 	if (codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA) {
 		LOGE("invalid codec %d", codec);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int set_codec = (int)codec;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_ENCODER, video_table[codec],
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, set_codec);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
 {
-	int ret = MM_ERROR_NONE;
-	int mm_codec = 0;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
 	if (codec == NULL) {
 		LOGE("codec is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_ENCODER, &mm_codec,
-					  NULL);
-	if (ret == MM_ERROR_NONE) {
-		switch(mm_codec) {
-		case MM_VIDEO_CODEC_H263 :
-			*codec = RECORDER_VIDEO_CODEC_H263;
-			break;
-		case MM_VIDEO_CODEC_H264 :
-			*codec = RECORDER_VIDEO_CODEC_H264;
-			break;
-		case MM_VIDEO_CODEC_MPEG4 :
-			*codec = RECORDER_VIDEO_CODEC_MPEG4;
-			break;
-		case MM_VIDEO_CODEC_THEORA:
-			*codec = RECORDER_VIDEO_CODEC_THEORA;
-			break;
-		default :
-			ret = MM_ERROR_CAMCORDER_INTERNAL;
-			break;
-		}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	int get_codec;
 
-	return __convert_recorder_error_code(__func__, ret);
+	LOGD("ENTER");
+
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
+		*codec = (recorder_audio_codec_e)get_codec;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
 {
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
 	if (samplerate < 1) {
 		LOGE("invalid samplerate %d", samplerate);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_SAMPLERATE, samplerate);
+	LOGD("ENTER, samplerate : %d", samplerate);
+
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, samplerate);
+	LOGD("ret : 0x%x, samplerate : %d", ret, samplerate);
+	return ret;
 }
 
 
 int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
 {
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
 	if (bitrate < 1) {
 		LOGE("invalid bitrate %d", bitrate);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER_BITRATE, bitrate);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, bitrate);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
+
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, bitrate);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	if (kbyte == NULL) {
+		LOGE("NULL pointer kbyte");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_kbyte;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_MAX_SIZE, kbyte,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg);
+		*kbyte = get_kbyte;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_time_limit(recorder_h recorder, int *second)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	if (second == NULL) {
+		LOGE("NULL pointer second");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_second;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_TARGET_TIME_LIMIT, second,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_second, pc->cb_info->recvMsg);
+		*second = get_second;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	if (device == NULL) {
+		LOGE("NULL pointer device");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_device;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_DEVICE, device,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_device, pc->cb_info->recvMsg);
+		*device = (recorder_audio_device_e)get_device;
+	}
+
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	if (samplerate == NULL) {
+		LOGE("NULL pointer handle");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_samplerate;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_SAMPLERATE, samplerate,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg);
+		*samplerate = get_samplerate;
+	}
+	LOGD("ret : 0x%x, get_samplerate : %d", ret, get_samplerate);
+	return ret;
 }
 
 
 int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	if (bitrate == NULL) {
+		LOGE("NULL pointer");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_bitrate;
+	pc->cb_info->activating[api] = 0;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_ENCODER_BITRATE, bitrate,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
+		*bitrate = get_bitrate;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
+	if (bitrate == NULL) {
+		LOGE("NULL pointer");
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
-					  NULL);
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_bitrate;
+
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
+		*bitrate = get_bitrate;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb, void *user_data)
 {
-	int i = 0;
-	int ret = MM_ERROR_NONE;
-	int codec;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamAttrsInfo info;
-
-	if (recorder == NULL) {
-		LOGE("handle is NULL");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-	if (foreach_cb == NULL) {
-		LOGE("foreach_cb is NULL");
+	if( recorder == NULL || foreach_cb == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
 
-	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_AUDIO_ENCODER, &info);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_recorder_error_code(__func__, ret);
-	}
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
 
-	for (i = 0 ; i < info.int_array.count ; i++) {
-		switch (info.int_array.array[i]) {
-		case MM_AUDIO_CODEC_AMR:
-			codec = RECORDER_AUDIO_CODEC_AMR;
-			break;
-		case MM_AUDIO_CODEC_AAC :
-			codec = RECORDER_AUDIO_CODEC_AAC;
-			break;
-		case MM_AUDIO_CODEC_VORBIS:
-			codec = RECORDER_AUDIO_CODEC_VORBIS;
-			break;
-		case MM_AUDIO_CODEC_WAVE:
-			codec = RECORDER_AUDIO_CODEC_PCM;
-			break;
-		default :
-			codec = -1;
-			break;
-		}
-		if (codec != -1 && !foreach_cb(codec,user_data)) {
-			break;
-		}
+	LOGD("Enter, handle :%x", pc->remote_handle);
+
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb, void *user_data)
 {
-	int i = 0;
-	int ret = MM_ERROR_NONE;
-	int codec;
-	recorder_s *handle = (recorder_s *)recorder;
-	MMCamAttrsInfo info;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
-		return RECORDER_ERROR_INVALID_PARAMETER;
-	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
-	if (foreach_cb == NULL) {
-		LOGE("foreach_cb is NULL");
+	if( recorder == NULL || foreach_cb == NULL){
+		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
 
-	ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_ENCODER, &info);
-	if (ret != MM_ERROR_NONE) {
-		return __convert_recorder_error_code(__func__, ret);
-	}
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
 
-	for (i = 0 ; i < info.int_array.count ; i++) {
-		switch (info.int_array.array[i]){
-		case MM_VIDEO_CODEC_H263 :
-			codec = RECORDER_VIDEO_CODEC_H263;
-			break;
-		case MM_VIDEO_CODEC_H264 :
-			codec = RECORDER_VIDEO_CODEC_H264;
-			break;
-		case MM_VIDEO_CODEC_MPEG4 :
-			codec = RECORDER_VIDEO_CODEC_MPEG4;
-			break;
-		case MM_VIDEO_CODEC_THEORA :
-			codec = RECORDER_VIDEO_CODEC_THEORA;
-			break;
-		default :
-			codec = -1;
-			break;
-		}
+	LOGD("Enter, handle :%x", pc->remote_handle);
 
-		if (codec != -1 && !foreach_cb(codec,user_data)) {
-			break;
-		}
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	sock_fd = pc->cb_info->fd;
+	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
+	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
 
-	return RECORDER_ERROR_NONE;
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_mute(recorder_h recorder, bool enable)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int set_enable = (int)enable;
+	pc->cb_info->activating[api] = 0;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_VOLUME, enable ? 0.0 : 1.0,
-					  NULL);
+	LOGD("ENTER");
 
-	return  __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, set_enable);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 bool recorder_attr_is_muted(recorder_h recorder)
 {
-	int ret = MM_ERROR_NONE;
-	double volume = 1.0;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return false;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_VOLUME, &volume,
-					  NULL);
-
-	set_last_result(__convert_recorder_error_code(__func__, ret));
+	LOGD("ENTER");
 
-	if (volume == 0.0) {
-		return true;
-	} else {
-		return false;
-	}
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
-					  NULL);
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	return  __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							DOUBLE, rate);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
 	if (rate == NULL) {
 		LOGE("rate is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	double get_rate;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
-					  NULL);
+	LOGD("ENTER");
 
-	return  __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_rate, pc->cb_info->recvMsg);
+		*rate = get_rate;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
 {
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
 	if (channel_count < 1) {
 		LOGE("invalid channel %d", channel_count);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+
+	LOGD("ENTER");
 
-	return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_CHANNEL, channel_count);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, channel_count);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
 	if (recorder == NULL) {
-		LOGE("handle is NULL");
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
 	if (channel_count == NULL) {
 		LOGE("channel_count is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_channel_count;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_AUDIO_CHANNEL, channel_count,
-					  NULL);
+	LOGD("ENTER");
 
-	return  __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg);
+		*channel_count = get_channel_count;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
 	if (orientation > RECORDER_ROTATION_270) {
 		LOGE("invalid orientation %d", orientation);
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int set_orientation = (int)orientation;
 
-	ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
-					  MMCAM_RECORDER_TAG_ENABLE, true,
-					  MMCAM_TAG_VIDEO_ORIENTATION, orientation,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send1(api,
+							sock_fd,
+							pc->cb_info,
+							ret,
+							INT, set_orientation);
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }
 
 
 int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
 {
-	int ret = MM_ERROR_NONE;
-	recorder_s *handle = (recorder_s *)recorder;
-
-	if (handle == NULL) {
-		LOGE("handle is NULL");
+	if (recorder == NULL) {
+		LOGE("NULL pointer handle");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
-	if (handle->camera_device_count == 0) {
-		LOGE("RECORDER_ERROR_NOT_SUPPORTED");
-		return RECORDER_ERROR_NOT_SUPPORTED;
-	}
 	if (orientation == NULL) {
 		LOGE("orientation is NULL");
 		return RECORDER_ERROR_INVALID_PARAMETER;
 	}
+	int ret = RECORDER_ERROR_NONE;
+	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
+	recorder_cli_s *pc = (recorder_cli_s *)recorder;
+	int sock_fd;
+	if (pc->cb_info == NULL) {
+		LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
+		return RECORDER_ERROR_INVALID_PARAMETER;
+	}
+	sock_fd = pc->cb_info->fd;
+	int get_orientation;
 
-	ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
-					  MMCAM_TAG_VIDEO_ORIENTATION, orientation,
-					  NULL);
+	LOGD("ENTER");
 
-	return __convert_recorder_error_code(__func__, ret);
+	muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
+	if (ret == RECORDER_ERROR_NONE) {
+		muse_recorder_msg_get(get_orientation, pc->cb_info->recvMsg);
+		*orientation = (recorder_rotation_e)get_orientation;
+	}
+	LOGD("ret : 0x%x", ret);
+	return ret;
 }