Update muse-recorder by the splited muse library

Change-Id: If00bd5315883957a294abe750689cbed4afe87b8

diff --git a/muse/CMakeLists.txt b/muse/CMakeLists.txt
index a7d2306..c7f5cec 100644 (file)
--- a/muse/CMakeLists.txt
+++ b/muse/CMakeLists.txt
@@ -2,7 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 SET(service "muse")
 SET(submodule "recorder")
 
-SET(dependents "dlog mused mm-common glib-2.0 gstreamer-1.0")
+SET(dependents "dlog muse-server mm-common glib-2.0 gstreamer-1.0")
 SET(fw_name "${service}-${submodule}")
 
 PROJECT(${fw_name})

diff --git a/muse/include/muse_recorder_msg.h b/muse/include/muse_recorder_msg.h
index 1bf47d3..1a02e13 100644 (file)
--- a/muse/include/muse_recorder_msg.h
+++ b/muse/include/muse_recorder_msg.h
@@ -21,7 +21,7 @@
 extern "C" {
 #endif
 
-#include "muse_core_msg_json.h"
+#include <muse_core.h>
 
 /**
  * @file muse_recorder_msg.h
@@ -114,7 +114,7 @@ typedef const char* STRING;
  * @param[out] buf The string of message buffer.
  */
 #define muse_recorder_msg_get(param, buf) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, &param, NULL, MUSE_TYPE_ANY)
+       muse_core_msg_deserialize(#param, buf, NULL, NULL, MUSE_TYPE_ANY, &param)
 
 /**
  * @brief Query the specific value from the input message via ipc.
@@ -122,7 +122,7 @@ typedef const char* STRING;
  * @param[out] buf The string of message buffer.
  */
 #define muse_recorder_msg_get_double(param, buf) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, &param, NULL, MUSE_TYPE_DOUBLE)
+       muse_core_msg_deserialize(#param, buf, NULL, NULL, MUSE_TYPE_DOUBLE, &param)
 
 /**
  * @brief Query the specific string type value from the input message via ipc.
@@ -130,7 +130,7 @@ typedef const char* STRING;
  * @param[out] buf The string of message buffer.
  */
 #define muse_recorder_msg_get_string(param, buf) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, param, NULL, MUSE_TYPE_STRING)
+       muse_core_msg_deserialize(#param, buf, NULL, NULL, MUSE_TYPE_STRING, param)
 
 /**
  * @brief Query the specific array type value from the input message via ipc.
@@ -138,7 +138,7 @@ typedef const char* STRING;
  * @param[out] buf The string of message buffer.
  */
 #define muse_recorder_msg_get_array(param, buf) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, param, NULL, MUSE_TYPE_ARRAY)
+       muse_core_msg_deserialize(#param, buf, NULL, NULL, MUSE_TYPE_ARRAY, param)
 
 /**
  * @brief Query the specific pointer type value from the input message via ipc.
@@ -146,7 +146,7 @@ typedef const char* STRING;
  * @param[out] buf The string of message buffer.
  */
 #define muse_recorder_msg_get_pointer(param, buf) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, &param, NULL, MUSE_TYPE_POINTER)
+       muse_core_msg_deserialize(#param, buf, NULL, NULL, MUSE_TYPE_POINTER, &param)
 
 
 /**
@@ -156,7 +156,7 @@ typedef const char* STRING;
  * @param[out] e The error return from the core api.
  */
 #define muse_recorder_msg_get_error_e(param, buf, e) \
-       muse_core_msg_json_deserialize(#param, buf, NULL, &param, &e, MUSE_TYPE_ANY)
+       muse_core_msg_deserialize(#param, buf, NULL, &e, MUSE_TYPE_ANY, &param)
 
 /**
  * @brief Returning the ack message from the server to client side.
@@ -169,16 +169,16 @@ typedef const char* STRING;
        do {    \
                char *__sndMsg__; \
                int __len__; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                        MUSE_TYPE_INT, PARAM_RET, ret, \
                        0); \
-               __len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
+               __len__ = muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = RECORDER_ERROR_INVALID_OPERATION; \
                } \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -195,17 +195,17 @@ typedef const char* STRING;
                char *__sndMsg__; \
                int __len__; \
                type __value__ = (type)param; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                        MUSE_TYPE_INT, PARAM_RET, ret, \
                        MUSE_TYPE_##type, #param, __value__, \
                        0); \
-               __len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
+               __len__ = muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = RECORDER_ERROR_INVALID_OPERATION; \
                } \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -225,18 +225,18 @@ typedef const char* STRING;
                int __len__; \
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_API_CLASS, class, \
                        MUSE_TYPE_INT, PARAM_RET, ret, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
                        MUSE_TYPE_##type2, #param2, __value2__, \
                        0); \
-               __len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
+               __len__ = muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
                if (__len__ <= 0) { \
                        LOGE("sending message failed"); \
                        ret = RECORDER_ERROR_INVALID_OPERATION; \
                } \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -249,12 +249,12 @@ typedef const char* STRING;
 #define muse_recorder_msg_event(api, event, class, module) \
        do {    \
                char *__sndMsg__; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_EVENT, event, \
                        MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                        0); \
-               muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -270,13 +270,13 @@ typedef const char* STRING;
        do {    \
                char *__sndMsg__; \
                type __value__ = (type)param; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_EVENT, event, \
                        MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                        MUSE_TYPE_##type, #param, __value__, \
                        0); \
-               muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -294,14 +294,14 @@ typedef const char* STRING;
                char *__sndMsg__; \
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_EVENT, event, \
                        MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
                        MUSE_TYPE_##type2, #param2, __value2__, \
                        0); \
-               muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -322,15 +322,15 @@ typedef const char* STRING;
                type1 __value1__ = (type1)param1; \
                type2 __value2__ = (type2)param2; \
                type3 __value3__ = (type3)param3; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_EVENT, event, \
                        MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
                        MUSE_TYPE_##type2, #param2, __value2__, \
                        MUSE_TYPE_##type3, #param3, __value3__, \
                        0); \
-               muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 /**
@@ -357,7 +357,7 @@ typedef const char* STRING;
                type3 __value3__ = (type3)param3; \
                type4 __value4__ = (type4)param4; \
                type5 __value5__ = (type5)param5; \
-               __sndMsg__ = muse_core_msg_json_factory_new(api, \
+               __sndMsg__ = muse_core_msg_new(api, \
                        MUSE_TYPE_INT, PARAM_EVENT, event, \
                        MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
                        MUSE_TYPE_##type1, #param1, __value1__, \
@@ -366,8 +366,8 @@ typedef const char* STRING;
                        MUSE_TYPE_##type4, #param4, __value4__, \
                        MUSE_TYPE_##type5, #param5, __value5__, \
                        0); \
-               muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
-               muse_core_msg_json_factory_free(__sndMsg__); \
+               muse_core_msg_send(muse_server_module_get_msg_fd(module), __sndMsg__); \
+               muse_core_msg_free(__sndMsg__); \
        } while (0)
 
 #ifdef __cplusplus

diff --git a/muse/src/muse_recorder_dispatcher.c b/muse/src/muse_recorder_dispatcher.c
index f432608..2752ec4 100644 (file)
--- a/muse/src/muse_recorder_dispatcher.c
+++ b/muse/src/muse_recorder_dispatcher.c
@@ -23,9 +23,7 @@
 #include <stdio.h>
 #include "muse_recorder.h"
 #include "muse_recorder_msg.h"
-#include <muse_core.h>
-#include <muse_core_ipc.h>
-#include <muse_core_security.h>
+#include <muse_server.h>
 #include <muse_camera_internal.h>
 #include <mm_types.h>
 #include <dlog.h>
@@ -130,7 +128,7 @@ void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e
                INT, current,
                INT, by_policy);
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (!muse_recorder) {
                LOGW("NULL muse recorder handle");
                return;
@@ -145,7 +143,7 @@ void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e
                snprintf(value_key, KEY_LENGTH, "%s", RECORDER_DEVICE_STATE_KEY_VIDEO);
 
        /* get current status */
-       muse_core_client_get_value(module, value_key, &device_status);
+       muse_server_module_get_value(module, value_key, &device_status);
        device_recording = device_status >> 16;
        device_paused = 0x0000ffff & device_status;
 
@@ -171,7 +169,7 @@ void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e
 
        LOGD("set [%s] 0x%8x", value_key, device_status);
 
-       muse_core_client_set_value(module, value_key, device_status);
+       muse_server_module_set_value(module, value_key, device_status);
 
        /* check whether emit signal or not */
        if (device_recording > 0)
@@ -275,7 +273,7 @@ void _recorder_disp_audio_stream_cb(void* stream, int size, recorder_sample_type
                return;
        }
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                return;
@@ -358,7 +356,7 @@ void _recorder_disp_muxed_stream_cb(void* stream, int size, unsigned long long o
                return;
        }
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (!muse_recorder) {
                LOGE("NULL handle");
                return;
@@ -513,7 +511,7 @@ static int _recorder_remove_export_data(muse_module_h module, int key, int remov
                return FALSE;
        }
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                return FALSE;
@@ -581,7 +579,7 @@ int recorder_dispatcher_create(muse_module_h module)
        muse_camera_handle_s *muse_camera = NULL;
        intptr_t handle = 0;
 
-       muse_recorder_msg_get(recorder_type, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(recorder_type, muse_server_module_get_msg(module));
 
        LOGD("Enter - type %d", recorder_type);
 
@@ -599,15 +597,15 @@ int recorder_dispatcher_create(muse_module_h module)
        muse_recorder->type = recorder_type;
        g_mutex_init(&muse_recorder->list_lock);
 
-       if (muse_core_ipc_get_bufmgr(&muse_recorder->bufmgr) != MM_ERROR_NONE ||
-               muse_core_ipc_get_gdbus_connection((GDBusConnection **)&gdbus_connection) != MM_ERROR_NONE) {
+       if (muse_server_ipc_get_bufmgr(&muse_recorder->bufmgr) != MM_ERROR_NONE ||
+               muse_server_ipc_get_gdbus_connection((GDBusConnection **)&gdbus_connection) != MM_ERROR_NONE) {
                LOGE("tbm bufmgr or gdbus conntection failed %p %p", muse_recorder->bufmgr, gdbus_connection);
                ret = RECORDER_ERROR_INVALID_OPERATION;
                goto _CREATE_ERROR;
        }
 
        if (recorder_type == MUSE_RECORDER_TYPE_VIDEO) {
-               muse_recorder_msg_get_pointer(camera_handle, muse_core_client_get_msg(module));
+               muse_recorder_msg_get_pointer(camera_handle, muse_server_module_get_msg(module));
                if (camera_handle == 0) {
                        LOGE("NULL handle");
                        ret = RECORDER_ERROR_INVALID_PARAMETER;
@@ -620,7 +618,7 @@ int recorder_dispatcher_create(muse_module_h module)
 
                ret = legacy_recorder_create_videorecorder(muse_camera->camera_handle, &muse_recorder->recorder_handle);
        } else if (recorder_type == MUSE_RECORDER_TYPE_AUDIO) {
-               muse_recorder_msg_get(pid, muse_core_client_get_msg(module));
+               muse_recorder_msg_get(pid, muse_server_module_get_msg(module));
 
                LOGD("audio type - pid %d", pid);
 
@@ -638,7 +636,7 @@ int recorder_dispatcher_create(muse_module_h module)
                goto _CREATE_ERROR;
 
        /* microphone feature support check */
-       if (muse_core_get_platform_info(MICROPHONE_FEATURE_NAME, &microphone_feature_supported) != MM_ERROR_NONE)
+       if (muse_server_get_platform_info(MICROPHONE_FEATURE_NAME, &microphone_feature_supported) != MM_ERROR_NONE)
                LOGE("failed to get platform info for microphone support");
 
        if (!microphone_feature_supported) {
@@ -656,7 +654,7 @@ int recorder_dispatcher_create(muse_module_h module)
        LOGD("recorder handle : %p, module : %p", muse_recorder, module);
 
        handle = (intptr_t)muse_recorder->recorder_handle;
-       muse_core_ipc_set_handle(module, (intptr_t)muse_recorder);
+       muse_server_ipc_set_handle(module, (intptr_t)muse_recorder);
        muse_recorder_msg_return1(api, class, ret, module, POINTER, handle);
 
        return MUSE_RECORDER_ERROR_NONE;
@@ -685,7 +683,7 @@ int recorder_dispatcher_destroy(muse_module_h module)
        muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -723,7 +721,7 @@ int recorder_dispatcher_get_state(muse_module_h module)
        recorder_state_e get_state = RECORDER_STATE_NONE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -745,7 +743,7 @@ int recorder_dispatcher_prepare(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -767,7 +765,7 @@ int recorder_dispatcher_unprepare(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -790,7 +788,7 @@ int recorder_dispatcher_start(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -799,8 +797,8 @@ int recorder_dispatcher_start(muse_module_h module)
        }
 
        /* privilege check */
-       client_fd = muse_core_client_get_msg_fd(module);
-       if (!muse_core_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
+       client_fd = muse_server_module_get_msg_fd(module);
+       if (!muse_server_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
                LOGE("security check failed");
                ret = RECORDER_ERROR_PERMISSION_DENIED;
                muse_recorder_msg_return(api, class, ret, module);
@@ -821,7 +819,7 @@ int recorder_dispatcher_pause(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -843,7 +841,7 @@ int recorder_dispatcher_commit(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -865,7 +863,7 @@ int recorder_dispatcher_cancel(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -889,7 +887,7 @@ int recorder_dispatcher_set_video_resolution(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -897,8 +895,8 @@ int recorder_dispatcher_set_video_resolution(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(width, muse_core_client_get_msg(module));
-       muse_recorder_msg_get(height, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(width, muse_server_module_get_msg(module));
+       muse_recorder_msg_get(height, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_video_resolution(muse_recorder->recorder_handle, width, height);
 
@@ -916,7 +914,7 @@ int recorder_dispatcher_get_video_resolution(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -940,7 +938,7 @@ int recorder_dispatcher_foreach_supported_video_resolution(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -965,7 +963,7 @@ int recorder_dispatcher_get_audio_level(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -988,7 +986,7 @@ int recorder_dispatcher_set_filename(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -996,7 +994,7 @@ int recorder_dispatcher_set_filename(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get_string(set_filename, muse_core_client_get_msg(module));
+       muse_recorder_msg_get_string(set_filename, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_filename(muse_recorder->recorder_handle, set_filename);
 
@@ -1013,7 +1011,7 @@ int recorder_dispatcher_get_filename(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1043,7 +1041,7 @@ int recorder_dispatcher_set_file_format(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1051,7 +1049,7 @@ int recorder_dispatcher_set_file_format(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_format, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_format, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_file_format(muse_recorder->recorder_handle, set_format);
 
@@ -1068,7 +1066,7 @@ int recorder_dispatcher_get_file_format(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1116,7 +1114,7 @@ int recorder_dispatcher_set_interrupted_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1140,7 +1138,7 @@ int recorder_dispatcher_unset_interrupted_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1162,7 +1160,7 @@ int recorder_dispatcher_set_interrupt_started_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1186,7 +1184,7 @@ int recorder_dispatcher_unset_interrupt_started_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1208,7 +1206,7 @@ int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1229,7 +1227,7 @@ int recorder_dispatcher_unset_audio_stream_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1249,7 +1247,7 @@ int recorder_dispatcher_set_error_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1273,7 +1271,7 @@ int recorder_dispatcher_unset_error_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1295,7 +1293,7 @@ int recorder_dispatcher_set_recording_status_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1319,7 +1317,7 @@ int recorder_dispatcher_unset_recording_status_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1341,7 +1339,7 @@ int recorder_dispatcher_set_recording_limit_reached_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1365,7 +1363,7 @@ int recorder_dispatcher_unset_recording_limit_reached_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1387,7 +1385,7 @@ int recorder_dispatcher_foreach_supported_file_format(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1414,7 +1412,7 @@ int recorder_dispatcher_foreach_supported_file_format_by_audio_encoder(muse_modu
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1422,7 +1420,7 @@ int recorder_dispatcher_foreach_supported_file_format_by_audio_encoder(muse_modu
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(audio_codec, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(audio_codec, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
                (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
@@ -1443,7 +1441,7 @@ int recorder_dispatcher_foreach_supported_file_format_by_video_encoder(muse_modu
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1451,7 +1449,7 @@ int recorder_dispatcher_foreach_supported_file_format_by_video_encoder(muse_modu
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(video_codec, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(video_codec, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
                (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
@@ -1472,7 +1470,7 @@ int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1480,7 +1478,7 @@ int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(kbyte, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(kbyte, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_size_limit(muse_recorder->recorder_handle, kbyte);
 
@@ -1497,7 +1495,7 @@ int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1505,7 +1503,7 @@ int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(second, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(second, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_time_limit(muse_recorder->recorder_handle, second);
 
@@ -1522,7 +1520,7 @@ int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1530,7 +1528,7 @@ int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_device, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_device, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_audio_device(muse_recorder->recorder_handle, set_device);
 
@@ -1547,7 +1545,7 @@ int recorder_dispatcher_set_audio_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1555,7 +1553,7 @@ int recorder_dispatcher_set_audio_encoder(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_codec, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_audio_encoder(muse_recorder->recorder_handle, set_codec);
 
@@ -1572,7 +1570,7 @@ int recorder_dispatcher_get_audio_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1595,7 +1593,7 @@ int recorder_dispatcher_set_video_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1603,7 +1601,7 @@ int recorder_dispatcher_set_video_encoder(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_codec, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_video_encoder(muse_recorder->recorder_handle, set_codec);
 
@@ -1620,7 +1618,7 @@ int recorder_dispatcher_get_video_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1643,7 +1641,7 @@ int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1651,7 +1649,7 @@ int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(samplerate, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(samplerate, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_audio_samplerate(muse_recorder->recorder_handle, samplerate);
 
@@ -1668,7 +1666,7 @@ int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1676,7 +1674,7 @@ int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(bitrate, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_audio_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
 
@@ -1693,7 +1691,7 @@ int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1701,7 +1699,7 @@ int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(bitrate, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_video_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
 
@@ -1718,7 +1716,7 @@ int recorder_dispatcher_attr_get_size_limit(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1741,7 +1739,7 @@ int recorder_dispatcher_attr_get_time_limit(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1764,7 +1762,7 @@ int recorder_dispatcher_attr_get_audio_device(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1787,7 +1785,7 @@ int recorder_dispatcher_attr_get_audio_samplerate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1810,7 +1808,7 @@ int recorder_dispatcher_attr_get_audio_encoder_bitrate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1833,7 +1831,7 @@ int recorder_dispatcher_attr_get_video_encoder_bitrate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1855,7 +1853,7 @@ int recorder_dispatcher_foreach_supported_audio_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1882,7 +1880,7 @@ int recorder_dispatcher_foreach_supported_audio_encoder_by_file_format(muse_modu
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1890,7 +1888,7 @@ int recorder_dispatcher_foreach_supported_audio_encoder_by_file_format(muse_modu
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(file_format, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_foreach_supported_audio_encoder(muse_recorder->recorder_handle,
                (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
@@ -1910,7 +1908,7 @@ int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1937,7 +1935,7 @@ int recorder_dispatcher_foreach_supported_video_encoder_by_file_format(muse_modu
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1945,7 +1943,7 @@ int recorder_dispatcher_foreach_supported_video_encoder_by_file_format(muse_modu
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(file_format, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_foreach_supported_video_encoder(muse_recorder->recorder_handle,
                (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
@@ -1966,7 +1964,7 @@ int recorder_dispatcher_attr_set_mute(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -1974,7 +1972,7 @@ int recorder_dispatcher_attr_set_mute(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_enable, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_enable, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_mute(muse_recorder->recorder_handle, (bool)set_enable);
 
@@ -1990,7 +1988,7 @@ int recorder_dispatcher_attr_is_muted(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2013,7 +2011,7 @@ int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2021,7 +2019,7 @@ int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get_double(rate, muse_core_client_get_msg(module));
+       muse_recorder_msg_get_double(rate, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_recording_motion_rate(muse_recorder->recorder_handle, rate);
 
@@ -2038,7 +2036,7 @@ int recorder_dispatcher_attr_get_recording_motion_rate(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2063,7 +2061,7 @@ int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2071,7 +2069,7 @@ int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(channel_count, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(channel_count, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_audio_channel(muse_recorder->recorder_handle, channel_count);
 
@@ -2088,7 +2086,7 @@ int recorder_dispatcher_attr_get_audio_channel(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2111,7 +2109,7 @@ int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2119,7 +2117,7 @@ int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(set_orientation, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(set_orientation, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_orientation_tag(muse_recorder->recorder_handle, set_orientation);
 
@@ -2136,7 +2134,7 @@ int recorder_dispatcher_attr_get_orientation_tag(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2159,7 +2157,7 @@ int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2167,7 +2165,7 @@ int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get_string(root_directory, muse_core_client_get_msg(module));
+       muse_recorder_msg_get_string(root_directory, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_attr_set_root_directory(muse_recorder->recorder_handle, root_directory);
 
@@ -2181,13 +2179,13 @@ int recorder_dispatcher_return_buffer(muse_module_h module)
        int tbm_key = 0;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get(tbm_key, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(tbm_key, muse_server_module_get_msg(module));
 
        /*LOGD("handle : %p, key : %d", muse_recorder, tbm_key);*/
 
@@ -2207,7 +2205,7 @@ int recorder_dispatcher_set_sound_stream_info(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2215,8 +2213,8 @@ int recorder_dispatcher_set_sound_stream_info(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       muse_recorder_msg_get_string(stream_type, muse_core_client_get_msg(module));
-       muse_recorder_msg_get(stream_index, muse_core_client_get_msg(module));
+       muse_recorder_msg_get_string(stream_type, muse_server_module_get_msg(module));
+       muse_recorder_msg_get(stream_index, muse_server_module_get_msg(module));
 
        ret = legacy_recorder_set_sound_stream_info(muse_recorder->recorder_handle, stream_type, stream_index);
 
@@ -2240,7 +2238,7 @@ int recorder_dispatcher_get_device_state(muse_module_h module)
        muse_recorder_api_e api = MUSE_RECORDER_API_GET_DEVICE_STATE;
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 
-       muse_recorder_msg_get(recorder_type, muse_core_client_get_msg(module));
+       muse_recorder_msg_get(recorder_type, muse_server_module_get_msg(module));
 
        if (recorder_type > RECORDER_TYPE_VIDEO) {
                LOGE("invalid type %d", recorder_type);
@@ -2262,9 +2260,9 @@ int recorder_dispatcher_get_device_state(muse_module_h module)
 #endif /* _MMSVC_CHECK_SUPPORT_ */
 
        if (recorder_type == RECORDER_TYPE_AUDIO)
-               muse_core_client_get_value(module, RECORDER_DEVICE_STATE_KEY_AUDIO, &device_state);
+               muse_server_module_get_value(module, RECORDER_DEVICE_STATE_KEY_AUDIO, &device_state);
        else
-               muse_core_client_get_value(module, RECORDER_DEVICE_STATE_KEY_VIDEO, &device_state);
+               muse_server_module_get_value(module, RECORDER_DEVICE_STATE_KEY_VIDEO, &device_state);
 
        device_recording = device_state >> 16;
        device_paused = 0x0000ffff & device_state;
@@ -2291,7 +2289,7 @@ int recorder_dispatcher_set_muxed_stream_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (!muse_recorder) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2313,7 +2311,7 @@ int recorder_dispatcher_unset_muxed_stream_cb(muse_module_h module)
        muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (!muse_recorder) {
                LOGE("NULL handle");
                ret = RECORDER_ERROR_INVALID_OPERATION;
@@ -2439,7 +2437,7 @@ static int recorder_cmd_dispatcher_shutdown(muse_module_h module)
        recorder_state_e state = RECORDER_STATE_NONE;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                return MUSE_RECORDER_ERROR_NONE;
@@ -2493,13 +2491,13 @@ static int recorder_cmd_external_storage_state_changed(muse_module_h module)
        int storage_state = 0;
        muse_recorder_handle_s *muse_recorder = NULL;
 
-       muse_recorder = (muse_recorder_handle_s *)muse_core_ipc_get_handle(module);
+       muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
        if (muse_recorder == NULL) {
                LOGE("NULL handle");
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       storage_state = (int)(long)muse_core_client_get_cust_data(module);
+       storage_state = (int)(long)muse_server_get_cust_data(module);
 
        LOGW("storage state %d", storage_state);
 

diff --git a/packaging/mmsvc-recorder.spec b/packaging/mmsvc-recorder.spec
index ea6fb16..ca23c1e 100644 (file)
--- a/packaging/mmsvc-recorder.spec
+++ b/packaging/mmsvc-recorder.spec
@@ -1,6 +1,6 @@
 Name:       mmsvc-recorder
 Summary:    A Recorder module for muse server
-Version:    0.3.3
+Version:    0.3.4
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
@@ -14,7 +14,7 @@ BuildRequires:  pkgconfig(mmsvc-camera)
 BuildRequires:  pkgconfig(legacy-camera)
 BuildRequires:  pkgconfig(mm-common)
 BuildRequires:  pkgconfig(glib-2.0)
-BuildRequires:  pkgconfig(mused)
+BuildRequires:  pkgconfig(muse-server)
 
 
 %description