path: root/src/recorder.c

/*
* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <camera_internal.h>
#include <recorder.h>
#include <sound_manager.h>
#include <sound_manager_internal.h>
#include <storage.h>
#include <storage-internal.h>
#include <muse_recorder.h>
#include <muse_recorder_msg.h>
#include <muse_core_ipc.h>
#include <muse_core_module.h>
#include <recorder_private.h>
#include <glib.h>
#include <gio/gio.h>
#include <dlog.h>
#include <tzplatform_config.h>

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "TIZEN_N_RECORDER"

/* for device changed callback */
static GMutex g_rec_dev_state_changed_cb_lock;
static GList *g_rec_dev_state_changed_cb_list;
static int g_rec_dev_state_changed_cb_id;
static GDBusConnection *g_rec_dev_state_changed_cb_conn;
static guint g_rec_dev_state_changed_cb_subscribe_id;



static void __recorder_update_api_waiting(recorder_cb_info_s *cb_info, int api, int value)
{
	if (!cb_info ||
		api < 0 || api >= MUSE_RECORDER_API_MAX) {
		LOGE("invalid param %p %d", cb_info, api);
		return;
	}

	g_mutex_lock(&(cb_info->api_mutex[api]));
	cb_info->api_waiting[api] += value;
	g_mutex_unlock(&(cb_info->api_mutex[api]));

	/*LOGD("api %d, value %d, waiting %d",
		api, value, cb_info->api_waiting[api]);*/

	return;
}


static void __recorder_device_state_changed_cb(GDBusConnection *connection,
	const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
	const gchar *signal_name, GVariant *param, gpointer user_data)
{
	int value = 0;
	recorder_type_e type = RECORDER_TYPE_AUDIO;
	recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
	GList *tmp_list = NULL;
	recorder_cb_info *info = NULL;

	g_mutex_lock(&g_rec_dev_state_changed_cb_lock);

	if (!g_rec_dev_state_changed_cb_list || !param) {
		LOGW("no callback or NULL param %p", param);
		goto _DONE;
	}

	/* get device type and state */
	g_variant_get(param, "(i)", &value);

	type = value >> 16;
	state = 0x0000ffff & value;

	LOGD("type %d, state %d", type, state);

	tmp_list = g_rec_dev_state_changed_cb_list;

	do {
		info = (recorder_cb_info *)tmp_list->data;

		if (info) {
			if (info->callback) {
				LOGD("start id[%d] callback", info->id);
				((recorder_device_state_changed_cb)info->callback)(type, state, info->user_data);
				LOGD("returned id[%d] callback", info->id);
			} else {
				LOGW("NULL callback for id %d", info->id);
			}
		}

		tmp_list = tmp_list->next;
	} while (tmp_list);

_DONE:
	g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);

	return;
}


static int _recorder_import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
{
	tbm_bo tmp_bo = NULL;
	tbm_bo_handle tmp_bo_handle = {NULL, };

	if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
		LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
		     bufmgr, bo, bo_handle, tbm_key);
		return false;
	}

	tmp_bo = tbm_bo_import(bufmgr, tbm_key);
	if (tmp_bo == NULL) {
		LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
		return false;
	}

	tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
	if (tmp_bo_handle.ptr == NULL) {
		LOGE("bo map failed %p", tmp_bo);
		tbm_bo_unref(tmp_bo);
		tmp_bo = NULL;
		return false;
	}

	/* set bo and bo_handle */
	*bo = tmp_bo;
	*bo_handle = tmp_bo_handle;

	return true;
}

static void _recorder_release_imported_bo(tbm_bo *bo)
{
	if (bo == NULL || *bo == NULL) {
		LOGW("NULL bo");
		return;
	}

	tbm_bo_unmap(*bo);
	tbm_bo_unref(*bo);
	*bo = NULL;

	return;
}

static void _recorder_client_user_callback(recorder_cb_info_s *cb_info, char *recv_msg, muse_recorder_event_e event)
{
	if (recv_msg == NULL || event >= MUSE_RECORDER_EVENT_TYPE_NUM) {
		LOGE("invalid parameter - recorder msg %p, event %d", recv_msg, event);
		return;
	}

	/*LOGD("get recorder msg %s, event %d", recv_msg, event);*/

	if (cb_info->user_cb[event] == NULL) {
		LOGW("user callback for event %d is not set", event);
		return;
	}

	switch (event) {
	case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
		{
			int previous = 0;
			int current = 0;
			int by_policy = 0;

			muse_recorder_msg_get(previous, recv_msg);
			muse_recorder_msg_get(current, recv_msg);
			muse_recorder_msg_get(by_policy, recv_msg);

			((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)previous,
				(recorder_state_e)current,
				(bool)by_policy,
				cb_info->user_data[event]);
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
		{
			int type = 0;

			muse_recorder_msg_get(type, recv_msg);

			((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)type,
				cb_info->user_data[event]);
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
		{
			int64_t cb_elapsed_time = 0;
			int64_t cb_file_size = 0;

			muse_recorder_msg_get(cb_elapsed_time, recv_msg);
			muse_recorder_msg_get(cb_file_size, recv_msg);

			((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 MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
		{
			int policy = 0;
			int previous = 0;
			int current = 0;

			muse_recorder_msg_get(policy, recv_msg);
			muse_recorder_msg_get(previous, recv_msg);
			muse_recorder_msg_get(current, recv_msg);

			if (policy == RECORDER_POLICY_SOUND)
				LOGW("DEPRECATION WARNING: RECORDER_POLICY_SOUND is deprecated and will be removed from next release.");
			else if (policy == RECORDER_POLICY_SOUND_BY_CALL)
				LOGW("DEPRECATION WARNING: RECORDER_POLICY_SOUND_BY_CALL is deprecated and will be removed from next release.");
			else if (policy == RECORDER_POLICY_SOUND_BY_ALARM)
				LOGW("DEPRECATION WARNING: RECORDER_POLICY_SOUND_BY_ALARM is deprecated and will be removed from next release.");

			((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
				(recorder_state_e)previous,
				(recorder_state_e)current,
				cb_info->user_data[event]);
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
		{
			int tbm_key = 0;
			int size = 0;
			int format = 0;
			int channel = 0;
			int timestamp = 0;
			tbm_bo bo = NULL;
			tbm_bo_handle bo_handle = {.ptr = NULL};
			char *send_msg = NULL;

			muse_recorder_msg_get(tbm_key, recv_msg);
			if (tbm_key == 0) {
				LOGE("invalid key");
				break;
			}

			if (!_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
				LOGE("tbm key %d import failed", tbm_key);
				break;
			}

			muse_recorder_msg_get(size, recv_msg);
			muse_recorder_msg_get(format, recv_msg);
			muse_recorder_msg_get(channel, recv_msg);
			muse_recorder_msg_get(timestamp, recv_msg);

			((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
				size,
				(audio_sample_type_e)format,
				channel,
				(unsigned int)timestamp,
				cb_info->user_data[event]);

			/* release imported bo */
			_recorder_release_imported_bo(&bo);

			/* return buffer */
			send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_RETURN_BUFFER,
				MUSE_TYPE_INT, "tbm_key", tbm_key, NULL);

			if (muse_core_ipc_send_msg(cb_info->fd, send_msg) <= 0)
				LOGE("sending message failed");

			muse_core_msg_json_factory_free(send_msg);
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_ERROR:
		{
			int error = 0;
			int current_state = 0;

			muse_recorder_msg_get(error, recv_msg);
			muse_recorder_msg_get(current_state, recv_msg);

			if (error == RECORDER_ERROR_SOUND_POLICY)
				LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY is deprecated and will be removed from next release.");
			else if (error == RECORDER_ERROR_SOUND_POLICY_BY_CALL)
				LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY_BY_CALL is deprecated and will be removed from next release.");
			else if (error == RECORDER_ERROR_SOUND_POLICY_BY_ALARM)
				LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY_BY_ALARM is deprecated and will be removed from next release.");

			((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)error,
				(recorder_state_e)current_state,
				cb_info->user_data[event]);
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
		{
			int codec = 0;

			muse_recorder_msg_get(codec, recv_msg);

			if (((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)codec, cb_info->user_data[event]) == false) {
				cb_info->user_cb[event] = NULL;
				cb_info->user_data[event] = NULL;
				/*LOGD("stop foreach callback for SUPPORTED_AUDIO_ENCODER");*/
			}
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
		{
			int format = 0;

			muse_recorder_msg_get(format, recv_msg);

			if (((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)format, cb_info->user_data[event]) == false) {
				cb_info->user_cb[event] = NULL;
				cb_info->user_data[event] = NULL;
				/*LOGD("stop foreach callback for SUPPORTED_FILE_FORMAT");*/
			}
			break;
		}
	case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
		{
			int codec = 0;

			muse_recorder_msg_get(codec, recv_msg);

			if (((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)codec, cb_info->user_data[event]) == false) {
				cb_info->user_cb[event] = NULL;
				cb_info->user_data[event] = NULL;
				/*LOGD("stop foreach callback for SUPPORTED_VIDEO_ENCODER");*/
			}
			break;
		}
	default: /* MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION */
		{
			int width = 0;
			int height = 0;

			muse_recorder_msg_get(width, recv_msg);
			muse_recorder_msg_get(height, recv_msg);

			if (((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height, cb_info->user_data[event]) == false) {
				cb_info->user_cb[event] = NULL;
				cb_info->user_data[event] = NULL;
				/*LOGD("stop foreach callback for SUPPORTED_VIDEO_RESOLUTION");*/
			}
			break;
		}
	}

	return;
}


static bool _recorder_idle_event_callback(void *data)
{
	recorder_cb_info_s *cb_info = NULL;
	recorder_idle_event_s *rec_idle_event = (recorder_idle_event_s *)data;

	if (rec_idle_event == NULL) {
		LOGE("rec_idle_event is NULL");
		return false;
	}

	/* lock event */
	g_mutex_lock(&rec_idle_event->event_mutex);

	cb_info = rec_idle_event->cb_info;
	if (cb_info == NULL) {
		LOGW("recorder cb_info is NULL. event %d", rec_idle_event->event);
		goto IDLE_EVENT_CALLBACK_DONE;
	}

	/* remove event from list */
	g_mutex_lock(&cb_info->idle_event_mutex);
	if (cb_info->idle_event_list)
		cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);

	/*LOGD("remove recorder idle event %p, %p", rec_idle_event, cb_info->idle_event_list);*/
	g_mutex_unlock(&cb_info->idle_event_mutex);

	/* user callback */
	_recorder_client_user_callback(rec_idle_event->cb_info, rec_idle_event->recv_msg, rec_idle_event->event);

	/* send signal for waiting thread */
	g_cond_signal(&cb_info->idle_event_cond);

IDLE_EVENT_CALLBACK_DONE:
	/* unlock and release event */
	g_mutex_unlock(&rec_idle_event->event_mutex);
	g_mutex_clear(&rec_idle_event->event_mutex);

	g_free(rec_idle_event);
	rec_idle_event = NULL;

	return false;
}


static void _recorder_remove_idle_event_all(recorder_cb_info_s *cb_info)
{
	recorder_idle_event_s *rec_idle_event = NULL;
	gboolean ret = true;
	GList *list = NULL;
	gint64 end_time = 0;

	if (cb_info == NULL) {
		LOGE("cb_info is NULL");
		return;
	}

	g_mutex_lock(&cb_info->idle_event_mutex);

	if (cb_info->idle_event_list == NULL) {
		LOGD("No event");
	} else {
		list = cb_info->idle_event_list;

		while (list) {
			rec_idle_event = list->data;
			list = g_list_next(list);

			if (!rec_idle_event) {
				LOGW("The event is NULL");
				continue;
			}

			if (!g_mutex_trylock(&rec_idle_event->event_mutex)) {
				LOGW("lock failed");

				end_time = g_get_monotonic_time() + G_TIME_SPAN_MILLISECOND * 100;

				if (g_cond_wait_until(&cb_info->idle_event_cond, &cb_info->idle_event_mutex, end_time))
					LOGW("signal received");
				else
					LOGW("timeout");

				continue;
			}

			ret = g_idle_remove_by_data(rec_idle_event);

			LOGD("remove event %p, ret %d", rec_idle_event, ret);

			if (!ret) {
				rec_idle_event->cb_info = NULL;
				LOGW("idle cb for event %p will be called later", rec_idle_event);
			}

			cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);

			g_mutex_unlock(&rec_idle_event->event_mutex);

			if (ret) {
				g_mutex_clear(&rec_idle_event->event_mutex);

				g_free(rec_idle_event);
				rec_idle_event = NULL;

				LOGD("remove event done");
			}
		}

		g_list_free(cb_info->idle_event_list);
		cb_info->idle_event_list = NULL;
	}

	g_mutex_unlock(&cb_info->idle_event_mutex);

	return;
}


static void __recorder_add_msg_to_queue(recorder_cb_info_s *cb_info, int api, int event, int event_class, char *msg)
{
	recorder_message_s *rec_msg = NULL;

	if (!cb_info || !msg) {
		LOGE("NULL pointer %p %p", cb_info, msg);
		return;
	}

	rec_msg = g_new0(recorder_message_s, 1);
	if (!rec_msg) {
		LOGE("failed to alloc rec_msg for [%s]", msg);
		return;
	}

	rec_msg->api = api;
	rec_msg->event = event;
	rec_msg->event_class = event_class;

	strncpy(rec_msg->recv_msg, msg, sizeof(rec_msg->recv_msg) - 1);

	/*LOGD("add recorder message to queue : api %d, event %d, event_class %d", api, event, event_class);*/

	if (event == MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM) {
		g_mutex_lock(&cb_info->audio_stream_cb_info.mutex);
		g_queue_push_tail(cb_info->audio_stream_cb_info.queue, (gpointer)rec_msg);
		g_cond_signal(&cb_info->audio_stream_cb_info.cond);
		g_mutex_unlock(&cb_info->audio_stream_cb_info.mutex);
	} else {
		g_mutex_lock(&cb_info->msg_handler_info.mutex);
		g_queue_push_tail(cb_info->msg_handler_info.queue, (gpointer)rec_msg);
		g_cond_signal(&cb_info->msg_handler_info.cond);
		g_mutex_unlock(&cb_info->msg_handler_info.mutex);
	}

	rec_msg = NULL;

	return;
}


static void __recorder_get_api_operation(int api, recorder_cb_info_s *cb_info, char *msg)
{
	if (!cb_info || !msg) {
		LOGE("NULL pointer %p %p", cb_info, msg);
		return;
	}

	switch (api) {
	case MUSE_RECORDER_API_GET_STATE:
		{
			int get_state = 0;
			muse_recorder_msg_get(get_state, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_STATE] = get_state;
		}
		break;
	case MUSE_RECORDER_API_GET_VIDEO_RESOLUTION:
		{
			int get_width = 0;
			int get_height = 0;
			muse_recorder_msg_get(get_width, msg);
			muse_recorder_msg_get(get_height, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] = get_width << 16;
			cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] |= get_height;
		}
		break;
	case MUSE_RECORDER_API_GET_FILE_FORMAT:
		{
			int get_format = 0;
			muse_recorder_msg_get(get_format, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT] = get_format;
		}
		break;
	case MUSE_RECORDER_API_GET_AUDIO_ENCODER:
		{
			int get_codec = 0;
			muse_recorder_msg_get(get_codec, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER] = get_codec;
		}
		break;
	case MUSE_RECORDER_API_GET_VIDEO_ENCODER:
		{
			int get_codec = 0;
			muse_recorder_msg_get(get_codec, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER] = get_codec;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT:
		{
			int get_kbyte = 0;
			muse_recorder_msg_get(get_kbyte, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT] = get_kbyte;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT:
		{
			int get_second = 0;
			muse_recorder_msg_get(get_second, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT] = get_second;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE:
		{
			int get_device = 0;
			muse_recorder_msg_get(get_device, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE] = get_device;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE:
		{
			int get_samplerate = 0;
			muse_recorder_msg_get(get_samplerate, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE] = get_samplerate;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE:
		{
			int get_bitrate = 0;
			muse_recorder_msg_get(get_bitrate, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE] = get_bitrate;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE:
		{
			int get_bitrate = 0;
			muse_recorder_msg_get(get_bitrate, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_BITRATE] = get_bitrate;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE:
		{
			double get_rate = 0;
			muse_recorder_msg_get_double(get_rate, msg);
			cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE] = get_rate;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL:
		{
			int get_channel_count = 0;
			muse_recorder_msg_get(get_channel_count, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL] = get_channel_count;
		}
		break;
	case MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG:
		{
			int get_orientation = 0;
			muse_recorder_msg_get(get_orientation, msg);
			cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG] = get_orientation;
		}
		break;
	case MUSE_RECORDER_API_GET_AUDIO_LEVEL:
		{
			double get_level = 0.0;
			muse_recorder_msg_get_double(get_level, msg);
			cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL] = get_level;
		}
		break;
	case MUSE_RECORDER_API_GET_FILENAME:
		{
			char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {'\0',};
			muse_recorder_msg_get_string(get_filename, msg);
			if (cb_info->get_filename) {
				free(cb_info->get_filename);
				cb_info->get_filename = NULL;
			}
			cb_info->get_filename = strdup(get_filename);
		}
		break;
	default:
		break;
	}

	return;
}


static void __recorder_process_msg(recorder_cb_info_s *cb_info, char *msg)
{
	int ret = RECORDER_ERROR_NONE;
	int api = -1;
	int api_class = -1;
	int event = -1;
	int event_class = -1;

	if (!cb_info || !msg) {
		LOGE("invalid ptr %p %p", cb_info, msg);
		return;
	}

	/*LOGD("msg [%s]", msg);*/

	if (!muse_recorder_msg_get(api, msg)) {
		LOGE("failed to get recorder api");
		return;
	}

	if (api == MUSE_RECORDER_CB_EVENT) {
		if (!muse_recorder_msg_get(event, msg) ||
			!muse_recorder_msg_get(event_class, msg)) {
			LOGE("failed to get event or event_class [%s]", msg);
			return;
		}
	} else {
		if (!muse_recorder_msg_get(api_class, msg)) {
			LOGE("failed to get api_class [%s]", msg);
			return;
		}
	}

	if (api_class == MUSE_RECORDER_API_CLASS_IMMEDIATE) {
		if (api >= MUSE_RECORDER_API_MAX) {
			LOGE("invalid api %d", api);
			return;
		}

		if (!muse_recorder_msg_get(ret, msg)) {
			LOGE("failed to get recorder ret");
			return;
		}

		g_mutex_lock(&cb_info->api_mutex[api]);

		if (api == MUSE_RECORDER_API_GET_DEVICE_STATE) {
			g_atomic_int_set(&cb_info->msg_recv_running, 0);
			LOGD("get device state done. close client cb handler");
		} else {
			switch (api) {
			case MUSE_RECORDER_API_CREATE:
				if (ret != RECORDER_ERROR_NONE) {
					g_atomic_int_set(&cb_info->msg_recv_running, 0);
					LOGE("create error 0x%x. closing..", ret);
				}
				break;
			case MUSE_RECORDER_API_DESTROY:
				if (ret == RECORDER_ERROR_NONE) {
					g_atomic_int_set(&cb_info->msg_recv_running, 0);
					LOGD("destroy done. closing..");
				}
				break;
			default:
				__recorder_get_api_operation(api, cb_info, msg);
				break;
			}
		}

		if (cb_info->api_waiting[api] > 0) {
			cb_info->api_ret[api] = ret;
			cb_info->api_activating[api] = 1;

			g_cond_signal(&cb_info->api_cond[api]);
		} else {
			LOGE("no waiting for api [%d]", api);
		}

		g_mutex_unlock(&cb_info->api_mutex[api]);
	} else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB || api == MUSE_RECORDER_CB_EVENT) {
		__recorder_add_msg_to_queue(cb_info, api, event, event_class, msg);
	} else {
		LOGW("unknown recorder api %d and api_class %d", api, api_class);
	}

	return;
}


static void *_recorder_msg_handler_func(gpointer data)
{
	int api = 0;
	int type = 0;
	recorder_message_s *rec_msg = NULL;
	recorder_idle_event_s *rec_idle_event = NULL;
	recorder_msg_handler_info_s *handler_info = (recorder_msg_handler_info_s *)data;
	recorder_cb_info_s *cb_info = NULL;

	if (!handler_info || !handler_info->cb_info) {
		LOGE("NULL handler %p", handler_info);
		return NULL;
	}

	cb_info = (recorder_cb_info_s *)handler_info->cb_info;
	type = handler_info->type;

	LOGD("t:%d start", type);

	g_mutex_lock(&handler_info->mutex);

	while (g_atomic_int_get(&handler_info->running)) {
		if (g_queue_is_empty(handler_info->queue)) {
			/*LOGD("signal wait...");*/
			g_cond_wait(&handler_info->cond, &handler_info->mutex);
			/*LOGD("signal received");*/

			if (g_atomic_int_get(&handler_info->running) == 0) {
				LOGD("stop event thread");
				break;
			}
		}

		rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
		g_mutex_unlock(&handler_info->mutex);
		if (rec_msg == NULL) {
			LOGE("NULL message");
			g_mutex_lock(&handler_info->mutex);
			continue;
		}

		api = rec_msg->api;

		if (api < MUSE_RECORDER_API_MAX) {
			int ret = 0;

			g_mutex_lock(&cb_info->api_mutex[api]);

			if (muse_recorder_msg_get(ret, rec_msg->recv_msg)) {
				if (cb_info->api_waiting[api] > 0) {
					cb_info->api_ret[api] = ret;
					cb_info->api_activating[api] = 1;

					/*LOGD("recorder api %d - return 0x%x", ret);*/

					g_cond_signal(&cb_info->api_cond[api]);
				} else {
					LOGE("no waiting for api [%d]", api);
				}
			} else {
				LOGE("t:%d failed to get ret for api %d, msg %s", type, api, rec_msg->recv_msg);
			}

			g_mutex_unlock(&cb_info->api_mutex[api]);
		} else if (api == MUSE_RECORDER_CB_EVENT) {
			switch (rec_msg->event_class) {
			case MUSE_RECORDER_EVENT_CLASS_THREAD_SUB:
				_recorder_client_user_callback(cb_info, rec_msg->recv_msg, rec_msg->event);
				break;
			case MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN:
				rec_idle_event = g_new0(recorder_idle_event_s, 1);
				if (rec_idle_event == NULL) {
					LOGE("event alloc failed");
					break;
				}

				rec_idle_event->event = rec_msg->event;
				rec_idle_event->cb_info = cb_info;
				g_mutex_init(&rec_idle_event->event_mutex);
				strncpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg) - 1);

				/*LOGD("add recorder event[%d, %p] to IDLE", rec_msg->event, rec_idle_event);*/

				g_mutex_lock(&cb_info->idle_event_mutex);
				cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)rec_idle_event);
				g_mutex_unlock(&cb_info->idle_event_mutex);

				g_idle_add_full(G_PRIORITY_DEFAULT,
					(GSourceFunc)_recorder_idle_event_callback,
					(gpointer)rec_idle_event,
					NULL);
				break;
			default:
				LOGE("unknown event class %d", rec_msg->event_class);
				break;
			}
		} else {
			LOGE("unknown api[%d] message", api);
		}

		g_free(rec_msg);
		rec_msg = NULL;

		g_mutex_lock(&handler_info->mutex);
	}

	/* remove remained event */
	while (!g_queue_is_empty(handler_info->queue)) {
		rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
		if (rec_msg) {
			LOGD("remove message %p", rec_msg);
			free(rec_msg);
			rec_msg = NULL;
		} else {
			LOGW("NULL message");
		}
	}

	g_mutex_unlock(&handler_info->mutex);

	LOGD("return");

	return NULL;
}


static void *_recorder_msg_recv_func(gpointer data)
{
	int recv_length = 0;
	int single_length = 0;
	int remained_length = 0;
	char *recv_msg = NULL;
	char *single_msg = NULL;
	char *remained_msg = NULL;
	int num_msg = 0;
	int cur_pos = 0;
	int prev_pos = 0;
	recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;

	if (cb_info == NULL) {
		LOGE("cb_info NULL");
		return NULL;
	}

	LOGD("start");

	single_msg = (char *)malloc(sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
	if (single_msg == NULL) {
		LOGE("single_msg malloc failed");
		goto CB_HANDLER_EXIT;
	}

	recv_msg = cb_info->recv_msg;

	while (g_atomic_int_get(&cb_info->msg_recv_running)) {
		recv_length = muse_core_ipc_recv_msg(cb_info->fd, recv_msg);
		if (recv_length <= 0) {
			cb_info->is_server_connected = FALSE;
			LOGE("receive msg failed - server disconnected");
			break;
		}

		recv_msg[recv_length] = '\0';

		cur_pos = 0;
		prev_pos = 0;
		num_msg = 0;

		/*LOGD("recv msg : %s, length : %d", recv_msg, recv_length);*/

		/* Need to split the combined entering msgs */
		for (cur_pos = 0; cur_pos < recv_length; cur_pos++) {
			if (recv_msg[cur_pos] == '}') {
				single_length = cur_pos - prev_pos + 1;

				if (single_length < MUSE_RECORDER_MSG_MAX_LENGTH) {
					/* check remained msg */
					if (remained_length > 0) {
						if (remained_msg) {
							strncpy(single_msg, remained_msg, remained_length);
							strncpy(single_msg + remained_length, recv_msg + prev_pos, single_length);
							single_msg[remained_length + single_length] = '\0';

							free(remained_msg);
							remained_msg = NULL;
						} else {
							strncpy(single_msg, recv_msg + prev_pos, single_length);
							single_msg[single_length] = '\0';
							LOGE("lost msg [%s], skip...", single_msg);
						}

						remained_length = 0;
					} else {
						strncpy(single_msg, recv_msg + prev_pos, single_length);
						single_msg[single_length] = '\0';
					}

					if (single_msg[0] == '{') {
						num_msg++;
						/*LOGD("splitted msg : [%s], Index : %d", single_msg, num_msg);*/
						__recorder_process_msg(cb_info, single_msg);
					} else {
						LOGE("invalid msg [%s]", single_msg);
					}
				} else {
					LOGE("too long message [len %d] skip...", single_length);
				}

				prev_pos = cur_pos + 1;
			}
		}

		/* check incompleted message */
		if (recv_msg[recv_length - 1] != '}') {
			remained_length = recv_length - prev_pos;

			LOGW("incompleted message [len %d]", remained_length);

			remained_msg = (char *)malloc(remained_length + 1);
			if (remained_msg) {
				strncpy(remained_msg, recv_msg + prev_pos, remained_length);
				remained_msg[remained_length] = '\0';
			} else {
				LOGE("failed to alloc for remained msg");
			}
		} else {
			remained_length = 0;
		}
	}

	LOGD("client cb exit - server connected %d", cb_info->is_server_connected);

	if (!cb_info->is_server_connected) {
		/* send error msg for server disconnection */
		char *error_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_CB_EVENT,
			MUSE_TYPE_INT, "error", RECORDER_ERROR_SERVICE_DISCONNECTED,
			MUSE_TYPE_INT, "current_state", RECORDER_STATE_NONE,
			NULL);

		if (!error_msg) {
			LOGE("error_msg failed");
			goto CB_HANDLER_EXIT;
		}

		LOGE("add error msg for service disconnection done");

		__recorder_add_msg_to_queue(cb_info,
			MUSE_RECORDER_CB_EVENT,
			MUSE_RECORDER_EVENT_TYPE_ERROR,
			MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
			error_msg);

		muse_core_msg_json_factory_free(error_msg);
		error_msg = NULL;

		LOGE("add error msg for service disconnection done");
	}

CB_HANDLER_EXIT:
	if (single_msg) {
		free(single_msg);
		single_msg = NULL;
	}

	if (remained_msg) {
		free(remained_msg);
		remained_msg = NULL;
	}

	return NULL;
}


static bool __create_msg_handler_thread(recorder_msg_handler_info_s *handler_info,
	int type, const char *thread_name, recorder_cb_info_s *cb_info)
{
	if (!handler_info || !thread_name || !cb_info) {
		LOGE("t:%d NULL %p %p %p",
			type, handler_info, thread_name, cb_info);
		return false;
	}

	LOGD("t:%d", type);

	handler_info->type = type;
	handler_info->queue = g_queue_new();
	if (handler_info->queue == NULL) {
		LOGE("t:%d queue failed", type);
		return false;
	}

	g_mutex_init(&handler_info->mutex);
	g_cond_init(&handler_info->cond);

	handler_info->cb_info = (void *)cb_info;
	g_atomic_int_set(&handler_info->running, 1);

	handler_info->thread = g_thread_try_new(thread_name,
		_recorder_msg_handler_func, (gpointer)handler_info, NULL);
	if (handler_info->thread == NULL) {
		LOGE("t:%d thread failed", type);

		g_mutex_clear(&handler_info->mutex);
		g_cond_clear(&handler_info->cond);
		g_queue_free(handler_info->queue);
		handler_info->queue = NULL;

		return false;
	}

	LOGD("t:%d done", type);

	return true;
}


static void __destroy_msg_handler_thread(recorder_msg_handler_info_s *handler_info)
{
	int type = 0;

	if (!handler_info) {
		LOGE("NULL handler");
		return;
	}

	if (!handler_info->thread) {
		LOGW("thread is not created");
		return;
	}

	type = handler_info->type;

	LOGD("t:%d thread %p", type, handler_info->thread);

	g_mutex_lock(&handler_info->mutex);
	g_atomic_int_set(&handler_info->running, 0);
	g_cond_signal(&handler_info->cond);
	g_mutex_unlock(&handler_info->mutex);

	g_thread_join(handler_info->thread);
	handler_info->thread = NULL;

	g_mutex_clear(&handler_info->mutex);
	g_cond_clear(&handler_info->cond);
	g_queue_free(handler_info->queue);
	handler_info->queue = NULL;

	LOGD("t:%d done", type);

	return;
}


static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd)
{
	recorder_cb_info_s *cb_info = NULL;
	gint i = 0;

	g_return_val_if_fail(sockfd > 0, NULL);

	cb_info = g_new0(recorder_cb_info_s, 1);
	if (cb_info == NULL) {
		LOGE("cb_info failed");
		goto ErrorExit;
	}

	cb_info->api_waiting[MUSE_RECORDER_API_CREATE] = 1;

	for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
		g_mutex_init(&cb_info->api_mutex[i]);
		g_cond_init(&cb_info->api_cond[i]);
	}

	g_mutex_init(&cb_info->idle_event_mutex);
	g_cond_init(&cb_info->idle_event_cond);

	/* message handler thread */
	if (!__create_msg_handler_thread(&cb_info->msg_handler_info,
		_RECORDER_MESSAGE_HANDLER_TYPE_GENERAL, "recorder_msg_handler", cb_info)) {
		LOGE("msg_handler_info failed");
		goto ErrorExit;
	}

	/* message handler thread for audio stream callback */
	if (!__create_msg_handler_thread(&cb_info->audio_stream_cb_info,
		_RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB, "recorder_msg_handler:audio_stream_cb", cb_info)) {
		LOGE("audio_stream_cb_info failed");
		goto ErrorExit;
	}

	cb_info->fd = sockfd;

	/* message receive thread */
	g_atomic_int_set(&cb_info->msg_recv_running, 1);
	cb_info->msg_recv_thread = g_thread_try_new("recorder_msg_recv",
		_recorder_msg_recv_func, (gpointer)cb_info, NULL);
	if (cb_info->msg_recv_thread == NULL) {
		LOGE("message receive thread creation failed");
		goto ErrorExit;
	}

	cb_info->is_server_connected = TRUE;

	return cb_info;

ErrorExit:
	if (cb_info) {
		__destroy_msg_handler_thread(&cb_info->msg_handler_info);
		__destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);

		g_mutex_clear(&cb_info->idle_event_mutex);
		g_cond_clear(&cb_info->idle_event_cond);

		for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
			g_mutex_clear(&cb_info->api_mutex[i]);
			g_cond_clear(&cb_info->api_cond[i]);
		}

		g_free(cb_info);
		cb_info = NULL;
	}

	return NULL;
}

static int _recorder_client_wait_for_cb_return(muse_recorder_api_e api, recorder_cb_info_s *cb_info, int time_out)
{
	int ret = RECORDER_ERROR_NONE;
	gint64 end_time;

	/*LOGD("Enter api : %d", api);*/

	if (!cb_info->is_server_connected) {
		LOGE("server is disconnected");
		return RECORDER_ERROR_SERVICE_DISCONNECTED;
	}

	g_mutex_lock(&(cb_info->api_mutex[api]));

	if (cb_info->api_activating[api] == 0) {
		if (time_out == RECORDER_CB_NO_TIMEOUT) {
			LOGW("wait for api %d", api);
			g_cond_wait(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]));
			ret = cb_info->api_ret[api];
			cb_info->api_activating[api] = 0;
			LOGW("api %d returned 0x%x", api, ret);
		} else {
			end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
			if (g_cond_wait_until(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]), end_time)) {
				ret = cb_info->api_ret[api];
				cb_info->api_activating[api] = 0;
				/*LOGD("return value : 0x%x", ret);*/
			} else {
				ret = RECORDER_ERROR_INVALID_OPERATION;
				LOGE("api %d was TIMED OUT!", api);
			}
		}
	} else {
		ret = cb_info->api_ret[api];
		cb_info->api_activating[api] = 0;

		/*LOGD("condition is already checked for the api[%d], return[0x%x]", api, ret);*/
	}

	if (ret != RECORDER_ERROR_NONE) {
		LOGE("ERROR : api %d - ret 0x%x", api, ret);

		if (ret == RECORDER_ERROR_SOUND_POLICY)
			LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY is deprecated and will be removed from next release.");
		else if (ret == RECORDER_ERROR_SOUND_POLICY_BY_CALL)
			LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY_BY_CALL is deprecated and will be removed from next release.");
		else if (ret == RECORDER_ERROR_SOUND_POLICY_BY_ALARM)
			LOGW("DEPRECATION WARNING: RECORDER_ERROR_SOUND_POLICY_BY_ALARM is deprecated and will be removed from next release.");
	}

	g_mutex_unlock(&(cb_info->api_mutex[api]));

	return ret;
}


static int _recorder_msg_send(int api, recorder_cb_info_s *cb_info, int *ret)
{
	int send_ret = 0;
	char *msg = NULL;

	if (!cb_info || !ret) {
		LOGE("invalid pointer for api %d - %p %p", api, cb_info, ret);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	msg = muse_core_msg_json_factory_new(api, NULL);
	if (!msg) {
		LOGE("msg creation failed: api %d", api);
		return RECORDER_ERROR_OUT_OF_MEMORY;
	}

	/*LOGD("send msg %s", msg);*/

	if (cb_info->is_server_connected) {
		__recorder_update_api_waiting(cb_info, api, 1);

		send_ret = muse_core_ipc_send_msg(cb_info->fd, msg);
	}

	if (send_ret < 0) {
		LOGE("message send failed");
		*ret = RECORDER_ERROR_INVALID_OPERATION;
	} else {
		*ret = _recorder_client_wait_for_cb_return(api, cb_info, RECORDER_CB_TIMEOUT);
	}

	__recorder_update_api_waiting(cb_info, api, -1);

	muse_core_msg_json_factory_free(msg);

	return RECORDER_ERROR_NONE;
}


static int _recorder_msg_send_param1(int api, recorder_cb_info_s *cb_info, int *ret, recorder_msg_param *param)
{
	int send_ret = 0;
	char *msg = NULL;

	if (!cb_info || !ret || !param) {
		LOGE("invalid pointer for api %d - %p %p %p", api, cb_info, ret, param);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	/*LOGD("type %d, name %s", param->type, param->name);*/

	switch (param->type) {
	case MUSE_TYPE_INT:
		msg = muse_core_msg_json_factory_new(api, param->type, param->name, param->value.value_INT, NULL);
		break;
	case MUSE_TYPE_DOUBLE:
		msg = muse_core_msg_json_factory_new(api, param->type, param->name, param->value.value_DOUBLE, NULL);
		break;
	case MUSE_TYPE_STRING:
		msg = muse_core_msg_json_factory_new(api, param->type, param->name, param->value.value_STRING, NULL);
		break;
	default:
		LOGE("unknown type %d", param->type);
		break;
	}

	if (!msg) {
		LOGE("msg creation failed: api %d, type %d, param name %s",
			api, param->type, param->name);
		return RECORDER_ERROR_OUT_OF_MEMORY;
	}

	/*LOGD("send msg %s", msg);*/

	if (cb_info->is_server_connected) {
		__recorder_update_api_waiting(cb_info, api, 1);

		send_ret = muse_core_ipc_send_msg(cb_info->fd, msg);
	}

	if (send_ret < 0) {
		LOGE("message send failed");
		*ret = RECORDER_ERROR_INVALID_OPERATION;
	} else {
		*ret = _recorder_client_wait_for_cb_return(api, cb_info, RECORDER_CB_TIMEOUT);
	}

	__recorder_update_api_waiting(cb_info, api, -1);

	muse_core_msg_json_factory_free(msg);

	return RECORDER_ERROR_NONE;
}


static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info)
{
	gint i = 0;

	g_return_if_fail(cb_info != NULL);

	LOGD("MSG receive thread[%p] destroy", cb_info->msg_recv_thread);

	g_thread_join(cb_info->msg_recv_thread);
	cb_info->msg_recv_thread = NULL;

	LOGD("msg_recv thread removed");

	__destroy_msg_handler_thread(&cb_info->msg_handler_info);
	__destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);

	g_mutex_clear(&cb_info->idle_event_mutex);
	g_cond_clear(&cb_info->idle_event_cond);

	for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
		g_mutex_clear(&cb_info->api_mutex[i]);
		g_cond_clear(&cb_info->api_cond[i]);
	}

	if (cb_info->fd > -1) {
		muse_core_connection_close(cb_info->fd);
		cb_info->fd = -1;
	}

	if (cb_info->bufmgr) {
		tbm_bufmgr_deinit(cb_info->bufmgr);
		cb_info->bufmgr = NULL;
	}
	if (cb_info->get_filename) {
		free(cb_info->get_filename);
		cb_info->get_filename = NULL;
	}

	g_free(cb_info);
	cb_info = NULL;

	return;
}


static int _recorder_storage_device_supported_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
{
	char **root_directory = (char **)user_data;

	if (root_directory == NULL) {
		LOGE("user data is NULL");
		return false;
	}

	LOGD("storage id %d, type %d, state %d, path %s",
		storage_id, type, state, path ? path : "NULL");

	if (type == STORAGE_TYPE_INTERNAL && path) {
		if (*root_directory) {
			free(*root_directory);
			*root_directory = NULL;
		}

		*root_directory = strdup(path);
		if (*root_directory) {
			LOGD("get root directory %s", *root_directory);
			return false;
		} else {
			LOGE("strdup %s failed", path);
		}
	}

	return true;
}

static int _recorder_client_get_root_directory(char **root_directory)
{
	int ret = STORAGE_ERROR_NONE;

	if (root_directory == NULL) {
		LOGE("user data is NULL");
		return false;
	}

	ret = storage_foreach_device_supported((storage_device_supported_cb)_recorder_storage_device_supported_cb, root_directory);
	if (ret != STORAGE_ERROR_NONE) {
		LOGE("storage_foreach_device_supported failed 0x%x", ret);
		return false;
	}

	return true;
}

static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e type, camera_h camera)
{
	int ret = RECORDER_ERROR_NONE;
	int destroy_ret = RECORDER_ERROR_NONE;
	int sock_fd = -1;
	int send_ret = 0;
	char *send_msg = NULL;
	char *root_directory = NULL;
	intptr_t camera_handle = 0;
	intptr_t handle = 0;
	tbm_bufmgr bufmgr = NULL;
	recorder_cli_s *pc = NULL;
	recorder_msg_param param;

	LOGD("Enter - type %d", type);

	if (recorder == NULL) {
		LOGE("NULL pointer for recorder handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (type == MUSE_RECORDER_TYPE_VIDEO && camera == NULL) {
		LOGE("NULL pointer for camera handle on video recorder mode");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	bufmgr = tbm_bufmgr_init(-1);
	if (bufmgr == NULL) {
		LOGE("get tbm bufmgr failed");
		return RECORDER_ERROR_INVALID_OPERATION;
	}

	pc = g_new0(recorder_cli_s, 1);
	if (pc == NULL) {
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
		goto _ERR_RECORDER_EXIT;
	}

	sock_fd = muse_core_client_new();
	if (sock_fd < 0) {
		LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _ERR_RECORDER_EXIT;
	}

	if (type == MUSE_RECORDER_TYPE_AUDIO) {
		send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
			MUSE_TYPE_INT, "module", MUSE_RECORDER,
			MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_AUDIO,
			MUSE_TYPE_INT, "pid", getpid(),
			NULL);
	} else {
		pc->camera = camera;
		camera_handle = (intptr_t)((camera_cli_s *)camera)->remote_handle;
		send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
			MUSE_TYPE_INT, "module", MUSE_RECORDER,
			MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_VIDEO,
			MUSE_TYPE_POINTER, "camera_handle", camera_handle,
			NULL);
	}

	if (!send_msg) {
		LOGE("NULL msg");
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
		goto _ERR_RECORDER_EXIT;
	}

	LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);

	send_ret = muse_core_ipc_send_msg(sock_fd, send_msg);

	muse_core_msg_json_factory_free(send_msg);
	send_msg = NULL;

	if (send_ret < 0) {
		LOGE("send msg failed %d", errno);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _ERR_RECORDER_EXIT;
	}

	pc->cb_info = _recorder_client_callback_new(sock_fd);
	if (pc->cb_info == NULL) {
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
		goto _ERR_RECORDER_EXIT;
	}

	sock_fd = -1;

	ret = _recorder_client_wait_for_cb_return(MUSE_RECORDER_API_CREATE, pc->cb_info, RECORDER_CB_NO_TIMEOUT);

	pc->cb_info->api_waiting[MUSE_RECORDER_API_CREATE] = 0;

	if (ret != RECORDER_ERROR_NONE) {
		LOGE("API_CREATE failed 0x%x", ret);
		goto _ERR_RECORDER_EXIT;
	}

	muse_recorder_msg_get_pointer(handle, pc->cb_info->recv_msg);
	if (handle == 0) {
		LOGE("Receiving Handle Failed!!");
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _ERR_RECORDER_AFTER_CREATE;
	}

	if (!_recorder_client_get_root_directory(&root_directory) || root_directory == NULL) {
		LOGE("failed to get root directory of internal storage");
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _ERR_RECORDER_AFTER_CREATE;
	}

	LOGD("root directory [%s]", root_directory);

	RECORDER_MSG_PARAM_SET(param, STRING, root_directory);

	_recorder_msg_send_param1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY, pc->cb_info, &ret, &param);

	if (ret != RECORDER_ERROR_NONE) {
		LOGE("failed to set root directory %s", root_directory);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _ERR_RECORDER_AFTER_CREATE;
	}

	free(root_directory);
	root_directory = NULL;

	pc->remote_handle = handle;
	pc->cb_info->bufmgr = bufmgr;

	LOGD("recorder[type %d] %p create success : remote handle 0x%x",
		type, pc, pc->remote_handle);

	*recorder = (recorder_h)pc;

	LOGD("done");

	return RECORDER_ERROR_NONE;

_ERR_RECORDER_AFTER_CREATE:
	_recorder_msg_send(MUSE_RECORDER_API_DESTROY, pc->cb_info, &destroy_ret);
	LOGE("destroy return 0x%x", destroy_ret);

_ERR_RECORDER_EXIT:
	tbm_bufmgr_deinit(bufmgr);
	bufmgr = NULL;

	if (root_directory) {
		free(root_directory);
		root_directory = NULL;
	}

	if (sock_fd > -1) {
		muse_core_connection_close(sock_fd);
		sock_fd = -1;
	}

	if (pc) {
		if (pc->cb_info) {
			_recorder_client_callback_destroy(pc->cb_info);
			pc->cb_info = NULL;
		}
		g_free(pc);
		pc = NULL;
	}

	return ret;
}


int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
{
	return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_VIDEO, camera);
}


int recorder_create_audiorecorder(recorder_h *recorder)
{
	return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_AUDIO, NULL);
}


int recorder_get_state(recorder_h recorder, recorder_state_e *state)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (state == NULL) {
		LOGE("NULL pointer state");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, remote_handle : %x", pc->remote_handle);

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*state = (recorder_state_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_STATE];

	LOGD("ret : 0x%x, state : %d", ret, *state);

	return ret;
}


int recorder_destroy(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (pc->cb_info->is_server_connected)
		_recorder_msg_send(api, pc->cb_info, &ret);
	else
		LOGW("server disconnected. release resource without send message.");

	if (ret == RECORDER_ERROR_NONE) {
		_recorder_remove_idle_event_all(pc->cb_info);
		_recorder_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 = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	if (ret == RECORDER_ERROR_NONE && pc->camera)
		camera_start_evas_rendering(pc->camera);

	return ret;
}


int recorder_unprepare(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	camera_state_e camera_state = CAMERA_STATE_NONE;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (pc->camera) {
		ret = camera_get_state(pc->camera, &camera_state);
		if (ret != CAMERA_ERROR_NONE) {
			LOGE("failed to get camera state 0x%x", ret);
			return RECORDER_ERROR_INVALID_OPERATION;
		}

		if (camera_state == CAMERA_STATE_PREVIEW) {
			ret = camera_stop_evas_rendering(pc->camera, false);
			if (ret != CAMERA_ERROR_NONE) {
				LOGE("camera_stop_evas_rendering failed 0x%x", ret);
				return RECORDER_ERROR_INVALID_OPERATION;
			}
		}
	}

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_start(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_START;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_state_e current_state = RECORDER_STATE_NONE;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (pc->camera) {
		ret = recorder_get_state(recorder, &current_state);
		if (ret != RECORDER_ERROR_NONE) {
			LOGE("failed to get current state 0x%x", ret);
			return RECORDER_ERROR_INVALID_OPERATION;
		}

		if (current_state == RECORDER_STATE_READY) {
			ret = camera_stop_evas_rendering(pc->camera, true);
			if (ret != CAMERA_ERROR_NONE) {
				LOGE("camera_stop_evas_rendering failed 0x%x", ret);
				return RECORDER_ERROR_INVALID_OPERATION;
			}
		}
	}

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (pc->camera && current_state == RECORDER_STATE_READY)
		camera_start_evas_rendering(pc->camera);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_pause(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_commit(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_state_e current_state = RECORDER_STATE_NONE;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (pc->camera) {
		ret = recorder_get_state(recorder, &current_state);
		if (ret != RECORDER_ERROR_NONE) {
			LOGE("failed to get current state 0x%x", ret);
			return RECORDER_ERROR_INVALID_OPERATION;
		}

		if (current_state >= RECORDER_STATE_RECORDING) {
			ret = camera_stop_evas_rendering(pc->camera, true);
			if (ret != CAMERA_ERROR_NONE) {
				LOGE("camera_stop_evas_rendering failed 0x%x", ret);
				return RECORDER_ERROR_INVALID_OPERATION;
			}
		}
	}

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
		camera_start_evas_rendering(pc->camera);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_cancel(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_state_e current_state = RECORDER_STATE_NONE;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (pc->camera) {
		ret = recorder_get_state(recorder, &current_state);
		if (ret != RECORDER_ERROR_NONE) {
			LOGE("failed to get current state 0x%x", ret);
			return RECORDER_ERROR_INVALID_OPERATION;
		}

		if (current_state >= RECORDER_STATE_RECORDING) {
			ret = camera_stop_evas_rendering(pc->camera, true);
			if (ret != CAMERA_ERROR_NONE) {
				LOGE("camera_stop_evas_rendering failed 0x%x", ret);
				return RECORDER_ERROR_INVALID_OPERATION;
			}
		}
	}

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
		camera_start_evas_rendering(pc->camera);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_set_video_resolution(recorder_h recorder, int width, int height)
{
	int ret = RECORDER_ERROR_NONE;
	int send_ret = 0;
	char *send_msg = NULL;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	send_msg = muse_core_msg_json_factory_new(api,
		MUSE_TYPE_INT, "width", width,
		MUSE_TYPE_INT, "height", height,
		NULL);
	if (send_msg) {
		if (pc->cb_info->is_server_connected) {
			__recorder_update_api_waiting(pc->cb_info, api, 1);

			send_ret = muse_core_ipc_send_msg(pc->cb_info->fd, send_msg);
		}

		if (send_ret < 0) {
			LOGE("message send failed");
			ret = RECORDER_ERROR_INVALID_OPERATION;
		} else {
			ret = _recorder_client_wait_for_cb_return(api, pc->cb_info, RECORDER_CB_TIMEOUT);
		}

		__recorder_update_api_waiting(pc->cb_info, api, -1);

		muse_core_msg_json_factory_free(send_msg);
	} else {
		LOGE("failed to create msg");
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
	}

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (!width || !height) {
		LOGE("NULL pointer width = [%p], height = [%p]", width, height);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE) {
		*width = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] >> 16;
		*height = (0x0000ffff & pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION]);
	}

	LOGD("ret : 0x%x, %dx%d", ret, *width, *height);

	return ret;
}


int recorder_foreach_supported_video_resolution(recorder_h recorder,
	recorder_supported_video_resolution_cb foreach_cb, void *user_data)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;

	if (!pc || !pc->cb_info || foreach_cb == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_get_audio_level(recorder_h recorder, double *level)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info || level == NULL) {
		LOGE("NULL pointer %p %p", pc, level);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*level = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL];

	LOGD("ret : 0x%x, level %lf", ret, *level);

	return ret;
}


int recorder_set_filename(recorder_h recorder,  const char *filename)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;
	char set_filename[RECORDER_FILENAME_MAX] = {0, };

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (filename == NULL) {
		LOGE("filename is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	if (storage_get_origin_internal_path(filename, RECORDER_FILENAME_MAX, set_filename) < 0) {
		/* Cannot convert. Use original path. */
		strncpy(set_filename, filename, strlen(filename));
	} else {
		/* Converted. Use converted path. */
		LOGD("Converted filename : %s -> %s", filename, set_filename);
	}

	RECORDER_MSG_PARAM_SET(param, STRING, set_filename);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_get_filename(recorder_h recorder,  char **filename)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	char compat_filename[RECORDER_FILENAME_MAX] = {0, };

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (filename == NULL) {
		LOGE("filename is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE) {
		if (storage_get_compat_internal_path(pc->cb_info->get_filename, RECORDER_FILENAME_MAX, compat_filename) < 0) {
			/* Cannot convert. Use original path. */
			*filename = pc->cb_info->get_filename;
		} else {
			/* Converted. Use converted path. */
			LOGD("Converted filename : %s -> %s", pc->cb_info->get_filename, compat_filename);
			*filename = strdup(compat_filename);
			free(pc->cb_info->get_filename);
		}

		pc->cb_info->get_filename = NULL;
	}

	LOGD("ret : 0x%x, filename : [%s]", ret, (*filename) ? *filename : "NULL");

	return ret;
}


int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
{
	int ret = RECORDER_ERROR_NONE;
	int set_format = (int)format;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER, set_format : %d", set_format);

	RECORDER_MSG_PARAM_SET(param, INT, set_format);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);
	return ret;
}


int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (format == NULL) {
		LOGE("NULL pointer data");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*format = (recorder_file_format_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT];

	LOGD("ret : 0x%x, format %d", ret, *format);

	return ret;
}


int recorder_set_sound_stream_info(recorder_h recorder, sound_stream_info_h stream_info)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_SOUND_STREAM_INFO;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	bool is_available = false;
	int stream_index = 0;
	char *stream_type = NULL;
	char *send_msg = NULL;
	int send_ret = 0;

	if (!pc || !pc->cb_info || stream_info == NULL) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_RECORDER, &is_available);
	if (ret != SOUND_MANAGER_ERROR_NONE) {
		LOGE("stream info verification failed");
		return RECORDER_ERROR_INVALID_OPERATION;
	}

	if (is_available == false) {
		LOGE("stream information is not available");
		return RECORDER_ERROR_INVALID_OPERATION;
	}

	ret = sound_manager_get_type_from_stream_information(stream_info, &stream_type);
	ret |= sound_manager_get_index_from_stream_information(stream_info, &stream_index);

	LOGD("sound manager return [0x%x]", ret);

	if (ret == SOUND_MANAGER_ERROR_NONE) {
		send_msg = muse_core_msg_json_factory_new(api,
			MUSE_TYPE_STRING, "stream_type", stream_type,
			MUSE_TYPE_INT, "stream_index", stream_index,
			NULL);
		if (send_msg) {
			if (pc->cb_info->is_server_connected) {
				__recorder_update_api_waiting(pc->cb_info, api, 1);

				send_ret = muse_core_ipc_send_msg(pc->cb_info->fd, send_msg);
			}

			if (send_ret < 0) {
				LOGE("message send failed");
				ret = RECORDER_ERROR_INVALID_OPERATION;
			} else {
				ret = _recorder_client_wait_for_cb_return(api, pc->cb_info, RECORDER_CB_TIMEOUT);
			}

			__recorder_update_api_waiting(pc->cb_info, api, -1);

			muse_core_msg_json_factory_free(send_msg);
		} else {
			LOGE("failed to create msg");
			ret = RECORDER_ERROR_OUT_OF_MEMORY;
		}
	} else {
		ret = RECORDER_ERROR_INVALID_OPERATION;
	}

	return ret;
}


int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data)
{
	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 (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_state_changed_cb(recorder_h recorder)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;

	if (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_interrupted_cb(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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 = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;

	if (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_audio_stream_cb(recorder_h recorder)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;

	if (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
	pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_error_cb(recorder_h recorder)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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)
{
	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;

	if (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_recording_status_cb(recorder_h recorder)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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)
{
	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;

	if (!pc || !pc->cb_info || callback == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, 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 ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;

	if (!pc || !pc->cb_info || foreach_cb == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, kbyte);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_time_limit(recorder_h recorder, int second)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, second);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
{
	int ret = RECORDER_ERROR_NONE;
	int set_device = (int)device;
	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	};

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, set_device);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
{
	int ret = RECORDER_ERROR_NONE;
	int set_codec = (int)codec;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, set_codec);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (codec == NULL) {
		LOGE("codec is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*codec = (recorder_audio_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER];

	LOGD("ret : 0x%x, codec %d", ret, *codec);

	return ret;
}


int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
{
	int ret = RECORDER_ERROR_NONE;
	int set_codec = (int)codec;
	muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, set_codec);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
{
	int ret = RECORDER_ERROR_NONE;
	muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (codec == NULL) {
		LOGE("codec is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*codec = (recorder_video_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER];

	LOGD("ret : 0x%x, codec %d", ret, *codec);

	return ret;
}


int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER, samplerate : %d", samplerate);

	RECORDER_MSG_PARAM_SET(param, INT, samplerate);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, bitrate);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, bitrate);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (kbyte == NULL) {
		LOGE("NULL pointer kbyte");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*kbyte = pc->cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT];

	LOGD("ret : 0x%x, %d kbyte", ret, *kbyte);

	return ret;
}


int recorder_attr_get_time_limit(recorder_h recorder, int *second)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (second == NULL) {
		LOGE("NULL pointer second");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*second = pc->cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT];

	LOGD("ret : 0x%x, %d second", ret, *second);

	return ret;
}


int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (device == NULL) {
		LOGE("NULL pointer device");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*device = (recorder_audio_device_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE];

	LOGD("ret : 0x%x, device %d", ret, *device);

	return ret;
}


int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (samplerate == NULL) {
		LOGE("NULL pointer handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*samplerate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE];

	LOGD("ret : 0x%x, samplerate %d", ret, *samplerate);

	return ret;
}


int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (bitrate == NULL) {
		LOGE("NULL pointer");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE];

	LOGD("ret : 0x%x, bitrate %d", ret, *bitrate);

	return ret;
}


int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (bitrate == NULL) {
		LOGE("NULL pointer");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_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 ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;

	if (!pc || !pc->cb_info || foreach_cb == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, 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 ret = RECORDER_ERROR_NONE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;

	if (!pc || !pc->cb_info || foreach_cb == NULL) {
		LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter, handle :%x", pc->remote_handle);

	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;

	_recorder_msg_send(api, pc->cb_info, &ret);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_set_mute(recorder_h recorder, bool enable)
{
	int ret = RECORDER_ERROR_NONE;
	int set_enable = (int)enable;
	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, set_enable);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


bool recorder_attr_is_muted(recorder_h recorder)
{
	int ret = false;
	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return false;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_SERVICE_DISCONNECTED)
		ret = false;

	LOGD("ret : %d", ret);

	return (bool)ret;
}


int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER - %.20lf", rate);

	RECORDER_MSG_PARAM_SET(param, DOUBLE, rate);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (rate == NULL) {
		LOGE("rate is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);
	if (ret == RECORDER_ERROR_NONE)
		*rate = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE];

	LOGD("ret : 0x%x - rate %.20lf", ret, *rate);

	return ret;
}


int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
{
	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;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, channel_count);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (channel_count == NULL) {
		LOGE("channel_count is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*channel_count = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL];

	LOGD("ret : 0x%x, channel count %d", ret, *channel_count);

	return ret;
}


int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
{
	int ret = RECORDER_ERROR_NONE;
	int set_orientation = (int)orientation;
	muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
	recorder_cli_s *pc = (recorder_cli_s *)recorder;
	recorder_msg_param param;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	RECORDER_MSG_PARAM_SET(param, INT, set_orientation);

	_recorder_msg_send_param1(api, pc->cb_info, &ret, &param);

	LOGD("ret : 0x%x", ret);

	return ret;
}


int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
{
	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;

	if (!pc || !pc->cb_info) {
		LOGE("NULL handle");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	if (orientation == NULL) {
		LOGE("orientation is NULL");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("ENTER");

	_recorder_msg_send(api, pc->cb_info, &ret);

	if (ret == RECORDER_ERROR_NONE)
		*orientation = (recorder_rotation_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG];

	LOGD("ret : 0x%x, orientation %d", ret, *orientation);

	return ret;
}


int recorder_get_device_state(recorder_type_e type, recorder_device_state_e *state)
{
	int ret = RECORDER_ERROR_NONE;
	int sock_fd = -1;
	int get_device_state = 0;
	char *send_msg = NULL;
	char recv_msg[MUSE_RECORDER_MSG_MAX_LENGTH] = {'\0',};

	if (!state) {
		LOGE("NULL pointer");
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	LOGD("Enter - type %d", type);

	sock_fd = muse_core_client_new();
	if (sock_fd < 0) {
		LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _GET_DEVICE_STATE_EXIT;
	}

	send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_GET_DEVICE_STATE,
		MUSE_TYPE_INT, "module", MUSE_RECORDER,
		MUSE_TYPE_INT, PARAM_RECORDER_TYPE, type,
		NULL);
	if (!send_msg) {
		LOGE("NULL msg");
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
		goto _GET_DEVICE_STATE_EXIT;
	}

	LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);

	ret = muse_core_ipc_send_msg(sock_fd, send_msg);

	muse_core_msg_json_factory_free(send_msg);
	send_msg = NULL;

	if (ret < 0) {
		LOGE("send msg failed %d", errno);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _GET_DEVICE_STATE_EXIT;
	}

	ret = muse_core_ipc_recv_msg(sock_fd, recv_msg);
	if (ret <= 0) {
		LOGE("recv msg failed %d", errno);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _GET_DEVICE_STATE_EXIT;
	}

	if (!muse_recorder_msg_get(ret, recv_msg)) {
		LOGE("failed to get return value from msg [%s]", recv_msg);
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _GET_DEVICE_STATE_EXIT;
	}

	if (ret == RECORDER_ERROR_NONE) {
		if (muse_recorder_msg_get(get_device_state, recv_msg)) {
			*state = (recorder_device_state_e)get_device_state;
			LOGD("device type %d state %d", type, *state);
		} else {
			LOGE("failed to get device state from msg [%s]", recv_msg);
			ret = RECORDER_ERROR_INVALID_OPERATION;
		}
	} else {
		LOGE("failed 0x%x", ret);
	}

_GET_DEVICE_STATE_EXIT:
	if (sock_fd > -1) {
		muse_core_connection_close(sock_fd);
		sock_fd = -1;
	}

	return ret;
}


int recorder_add_device_state_changed_cb(recorder_device_state_changed_cb callback, void *user_data, int *cb_id)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
	recorder_cb_info *info = NULL;

	if (!callback || !cb_id) {
		LOGE("invalid pointer %p %p", callback, cb_id);
		return RECORDER_ERROR_INVALID_PARAMETER;
	}

	g_mutex_lock(&g_rec_dev_state_changed_cb_lock);

	/* check recorder support */
	ret = recorder_get_device_state(RECORDER_TYPE_AUDIO, &state);
	if (ret != RECORDER_ERROR_NONE) {
		LOGE("get device state failed");
		g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);
		return ret;
	}

	info = g_new0(recorder_cb_info, 1);
	if (!info) {
		LOGE("info failed");
		ret = RECORDER_ERROR_OUT_OF_MEMORY;
		goto _DONE;
	}

	info->id = ++g_rec_dev_state_changed_cb_id;
	info->callback = (void *)callback;
	info->user_data = user_data;

	*cb_id = info->id;

	/* subscribe dbus signal for camera state change */
	if (!g_rec_dev_state_changed_cb_conn) {
		g_rec_dev_state_changed_cb_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
		if (!g_rec_dev_state_changed_cb_conn) {
			LOGE("failed to get gdbus connection");
			ret = RECORDER_ERROR_INVALID_OPERATION;
			goto _DONE;
		}

		LOGD("subscribe signal %s - %s - %s",
			MM_CAMCORDER_DBUS_OBJECT,
			MM_CAMCORDER_DBUS_INTERFACE_RECORDER,
			MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED);

		g_rec_dev_state_changed_cb_subscribe_id = g_dbus_connection_signal_subscribe(g_rec_dev_state_changed_cb_conn,
			NULL, MM_CAMCORDER_DBUS_INTERFACE_RECORDER, MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED, MM_CAMCORDER_DBUS_OBJECT, NULL,
			G_DBUS_SIGNAL_FLAGS_NONE, (GDBusSignalCallback)__recorder_device_state_changed_cb, NULL, NULL);
		if (!g_rec_dev_state_changed_cb_subscribe_id) {
			LOGE("failed to get gdbus connection");
			ret = RECORDER_ERROR_INVALID_OPERATION;
			goto _DONE;
		}

		LOGD("signal subscribe id %u", g_rec_dev_state_changed_cb_subscribe_id);
	}

	g_rec_dev_state_changed_cb_list = g_list_prepend(g_rec_dev_state_changed_cb_list, (gpointer)info);

	LOGD("callback id %d", info->id);

_DONE:
	if (ret != RECORDER_ERROR_NONE) {
		if (info) {
			g_free(info);
			info = NULL;
		}

		if (g_rec_dev_state_changed_cb_conn) {
			g_object_unref(g_rec_dev_state_changed_cb_conn);
			g_rec_dev_state_changed_cb_conn = NULL;
		}
	}

	g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);

	return ret;
}


int recorder_remove_device_state_changed_cb(int cb_id)
{
	int ret = RECORDER_ERROR_NONE;
	recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
	GList *tmp_list = NULL;
	recorder_cb_info *info = NULL;

	/* check recorder support */
	ret = recorder_get_device_state(RECORDER_TYPE_AUDIO, &state);
	if (ret != RECORDER_ERROR_NONE) {
		LOGE("get device state failed");
		return ret;
	}

	g_mutex_lock(&g_rec_dev_state_changed_cb_lock);

	if (!g_rec_dev_state_changed_cb_list) {
		LOGE("there is no callback info");
		ret = RECORDER_ERROR_INVALID_OPERATION;
		goto _DONE;
	}

	tmp_list = g_rec_dev_state_changed_cb_list;

	do {
		info = tmp_list->data;
		tmp_list = tmp_list->next;

		if (!info) {
			LOGW("NULL info");
			continue;
		}

		if (info->id == cb_id) {
			g_rec_dev_state_changed_cb_list = g_list_remove(g_rec_dev_state_changed_cb_list, info);

			g_free(info);
			info = NULL;

			if (!g_rec_dev_state_changed_cb_list) {
				/* no remained callback */
				if (g_rec_dev_state_changed_cb_conn) {
					/* unsubscribe signal */
					g_dbus_connection_signal_unsubscribe(g_rec_dev_state_changed_cb_conn, g_rec_dev_state_changed_cb_subscribe_id);
					g_rec_dev_state_changed_cb_subscribe_id = 0;

					/* unref connection */
					g_object_unref(g_rec_dev_state_changed_cb_conn);
					g_rec_dev_state_changed_cb_conn = NULL;
				}
			}

			LOGD("id %d callback removed", cb_id);
			ret = RECORDER_ERROR_NONE;

			goto _DONE;
		}
	} while (tmp_list);

	LOGE("id %d callback not found", cb_id);
	ret = RECORDER_ERROR_INVALID_PARAMETER;

_DONE:
	g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);

	return ret;
}