Add new functions to support new Native APIs

Recorder device state related APIs will be added.
This commit supports them.

[Version] 0.2.26
[Profile] Common
[Issue Type] New function
[Dependency module] N/A
[Dependency commit] N/A
[Test] [M(T) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-mobile_20160913.1]

Change-Id: I9c42c44286d0726f47b45214ef157bf0a46f1ca7
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/legacy/include/legacy_recorder.h b/legacy/include/legacy_recorder.h
index 07bc3cf8a4547ef611b217955640351fa6e7bb69..574750d776097c566ab3066eb53b1d9327e45ec2 100644 (file)
--- a/legacy/include/legacy_recorder.h
+++ b/legacy/include/legacy_recorder.h
@@ -157,6 +157,25 @@ typedef enum {
        RECORDER_POLICY_RESOURCE_CONFLICT       /**< Resource conflict (Since 3.0) */
 } recorder_policy_e;
 
+/**
+ * @brief Enumeration for the recorder type.
+ * @since_tizen 3.0
+ */
+typedef enum {
+       RECORDER_TYPE_AUDIO = 0,    /**< Audio only recorder */
+       RECORDER_TYPE_VIDEO         /**< Video recorder (audio is optional) */
+} recorder_type_e;
+
+/**
+ * @brief Enumeration for the recorder device state.
+ * @since_tizen 3.0
+ */
+typedef enum {
+       RECORDER_DEVICE_STATE_NULL = 0,     /**< No recorder is working */
+       RECORDER_DEVICE_STATE_RECORDING,    /**< Now recording */
+       RECORDER_DEVICE_STATE_PAUSED        /**< All recordings are paused */
+} recorder_device_state_e;
+
 /**
  * @}
 */

diff --git a/muse/include/muse_recorder.h b/muse/include/muse_recorder.h
index 81c11d7d02160a9db09e7e7a9223841125c913aa..b73f3ab397587d333ac9ed3427fffbc80269f050 100644 (file)
--- a/muse/include/muse_recorder.h
+++ b/muse/include/muse_recorder.h
@@ -93,6 +93,7 @@ typedef enum {
        MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY,
        MUSE_RECORDER_API_RETURN_BUFFER,
        MUSE_RECORDER_API_SET_SOUND_STREAM_INFO,
+       MUSE_RECORDER_API_GET_DEVICE_STATE,
        MUSE_RECORDER_API_MAX
 } muse_recorder_api_e;
 
@@ -166,6 +167,13 @@ typedef enum {
  */
 #define MUSE_RECORDER_MSG_MAX_LENGTH           512
 
+/**
+ * @brief Definition for device state change signal
+ */
+#define MM_CAMCORDER_DBUS_OBJECT                "/org/tizen/MMCamcorder"
+#define MM_CAMCORDER_DBUS_INTERFACE_RECORDER    "org.tizen.MMCamcorder.Recorder"
+#define MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED  "DeviceStateChanged"
+
 
 #ifdef __cplusplus
 }

diff --git a/muse/src/muse_recorder_dispatcher.c b/muse/src/muse_recorder_dispatcher.c
index 4dc573849f851c9b4fb7a93ed6c67df5348127b6..9f4ed79339a5f49c010c1aebf57da43700a06f23 100644 (file)
--- a/muse/src/muse_recorder_dispatcher.c
+++ b/muse/src/muse_recorder_dispatcher.c
@@ -36,8 +36,13 @@
 #undef LOG_TAG
 #endif
 #define LOG_TAG "MUSED_RECORDER"
+#define KEY_LENGTH 32
 
-#define RECORDER_PRIVILEGE_NAME "http://tizen.org/privilege/recorder"
+#define RECORDER_PRIVILEGE_NAME         "http://tizen.org/privilege/recorder"
+#define RECORDER_DEVICE_STATE_KEY_AUDIO "device_state_recorder_audio"
+#define RECORDER_DEVICE_STATE_KEY_VIDEO "device_state_recorder_video"
+
+static GMutex g_recorder_device_state_lock;
 
 
 /**
@@ -56,6 +61,7 @@ typedef struct {
        tbm_bufmgr bufmgr;
        GList *data_list;
        GMutex list_lock;
+       muse_recorder_type_e type;
 } muse_recorder_handle_s;
 
 
@@ -101,6 +107,12 @@ void _recorder_disp_recording_status_cb(unsigned long long elapsed_time, unsigne
 void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e current, bool by_policy, void *user_data)
 {
        muse_module_h module = (muse_module_h)user_data;
+       muse_recorder_handle_s *muse_recorder = NULL;
+       char value_key[KEY_LENGTH] = {'\0',};
+       int set_value = -1;
+       int get_value = 0;
+       int device_recording = 0;
+       int device_paused = 0;
 
        if (module == NULL) {
                LOGE("NULL module");
@@ -115,6 +127,49 @@ 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);
+       if (!muse_recorder) {
+               LOGW("NULL muse recorder handle");
+               return;
+       }
+
+       g_mutex_lock(&g_recorder_device_state_lock);
+
+       /* define key name */
+       if (muse_recorder->type == MUSE_RECORDER_TYPE_AUDIO)
+               snprintf(value_key, KEY_LENGTH, "%s", RECORDER_DEVICE_STATE_KEY_AUDIO);
+       else
+               snprintf(value_key, KEY_LENGTH, "%s", RECORDER_DEVICE_STATE_KEY_VIDEO);
+
+       /* get current state */
+       muse_core_client_get_value(module, value_key, &get_value);
+       device_recording = get_value >> 16;
+       device_paused = 0x0000ffff & get_value;
+
+       LOGD("previous RECORDING %d, PAUSED %d", device_recording, device_paused);
+
+       /* adjust state */
+       if (current == RECORDER_STATE_RECORDING)
+               device_recording++;
+       else if (current == RECORDER_STATE_PAUSED)
+               device_paused++;
+
+       if (previous == RECORDER_STATE_RECORDING)
+               device_recording--;
+       else if (previous == RECORDER_STATE_PAUSED)
+               device_paused--;
+
+       LOGD("current RECORDING %d, PAUSED %d", device_recording, device_paused);
+
+       /* make set value */
+       set_value = device_recording << 16 | device_paused;
+
+       LOGD("device[%s] state set : 0x%x", value_key, set_value);
+
+       muse_core_client_set_value(module, value_key, set_value);
+
+       g_mutex_unlock(&g_recorder_device_state_lock);
+
        return;
 }
 
@@ -415,33 +470,21 @@ int recorder_dispatcher_create(muse_module_h module)
 
        memset(muse_recorder, 0x0, sizeof(muse_recorder_handle_s));
 
+       muse_recorder->type = recorder_type;
        g_mutex_init(&muse_recorder->list_lock);
 
        if (muse_core_ipc_get_bufmgr(&muse_recorder->bufmgr) != MM_ERROR_NONE) {
                LOGE("muse_core_ipc_get_bufmgr failed");
-
-               g_mutex_clear(&muse_recorder->list_lock);
-               free(muse_recorder);
-               muse_recorder = NULL;
-
                ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, class, ret, module);
-
-               return MUSE_RECORDER_ERROR_NONE;
+               goto _CREATE_ERROR;
        }
 
        if (recorder_type == MUSE_RECORDER_TYPE_VIDEO) {
                muse_recorder_msg_get_pointer(camera_handle, muse_core_client_get_msg(module));
                if (camera_handle == 0) {
                        LOGE("NULL handle");
-
-                       g_mutex_clear(&muse_recorder->list_lock);
-                       free(muse_recorder);
-                       muse_recorder = NULL;
-
                        ret = RECORDER_ERROR_INVALID_PARAMETER;
-                       muse_recorder_msg_return(api, class, ret, module);
-                       return MUSE_RECORDER_ERROR_NONE;
+                       goto _CREATE_ERROR;
                }
 
                muse_camera = (muse_camera_handle_s *)camera_handle;
@@ -453,32 +496,47 @@ int recorder_dispatcher_create(muse_module_h module)
                muse_recorder_msg_get(pid, muse_core_client_get_msg(module));
 
                LOGD("audio type - pid %d", pid);
+
                ret = legacy_recorder_create_audiorecorder(&muse_recorder->recorder_handle);
-               if (ret == RECORDER_ERROR_NONE) {
-                       ret = legacy_recorder_set_client_pid(muse_recorder->recorder_handle, pid);
-                       if (ret != RECORDER_ERROR_NONE) {
-                               LOGE("legacy_recorder_set_client_pid failed 0x%x", ret);
-                               legacy_recorder_destroy(muse_recorder->recorder_handle);
-                               muse_recorder->recorder_handle = NULL;
-                       }
+               if (ret != RECORDER_ERROR_NONE) {
+                       LOGE("create audio recorder failed");
+                       goto _CREATE_ERROR;
                }
+
+               ret = legacy_recorder_set_client_pid(muse_recorder->recorder_handle, pid);
        }
 
-       if (ret == RECORDER_ERROR_NONE) {
-               LOGD("recorder handle : %p, module : %p", muse_recorder, module);
+       if (ret != RECORDER_ERROR_NONE)
+               goto _CREATE_ERROR;
 
-               handle = (intptr_t)muse_recorder->recorder_handle;
-               muse_core_ipc_set_handle(module, (intptr_t)muse_recorder);
-               muse_recorder_msg_return1(api, class, ret, module, POINTER, handle);
-       } else {
-               g_mutex_clear(&muse_recorder->list_lock);
-               free(muse_recorder);
-               muse_recorder = NULL;
+       ret = legacy_recorder_set_state_changed_cb(muse_recorder->recorder_handle,
+               (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
+               (void *)module);
+       if (ret != RECORDER_ERROR_NONE)
+               goto _CREATE_ERROR;
 
-               LOGE("error 0x%d", ret);
-               muse_recorder_msg_return(api, class, ret, 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_recorder_msg_return1(api, class, ret, module, POINTER, handle);
+
+       return MUSE_RECORDER_ERROR_NONE;
+
+_CREATE_ERROR:
+       if (muse_recorder->recorder_handle) {
+               legacy_recorder_destroy(muse_recorder->recorder_handle);
+               muse_recorder->recorder_handle = NULL;
        }
 
+       g_mutex_clear(&muse_recorder->list_lock);
+       free(muse_recorder);
+       muse_recorder = NULL;
+
+       LOGE("error 0x%d", ret);
+
+       muse_recorder_msg_return(api, class, ret, module);
+
        return MUSE_RECORDER_ERROR_NONE;
 }
 
@@ -879,19 +937,8 @@ int recorder_dispatcher_set_state_changed_cb(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
        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);
-       if (muse_recorder == NULL) {
-               LOGE("NULL handle");
-               ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, class, ret, module);
-               return MUSE_RECORDER_ERROR_NONE;
-       }
-
-       ret = legacy_recorder_set_state_changed_cb(muse_recorder->recorder_handle,
-               (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
-               (void *)module);
+       LOGD("Enter");
 
        muse_recorder_msg_return(api, class, ret, module);
 
@@ -903,17 +950,8 @@ int recorder_dispatcher_unset_state_changed_cb(muse_module_h module)
        int ret = RECORDER_ERROR_NONE;
        muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
        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);
-       if (muse_recorder == NULL) {
-               LOGE("NULL handle");
-               ret = RECORDER_ERROR_INVALID_OPERATION;
-               muse_recorder_msg_return(api, class, ret, module);
-               return MUSE_RECORDER_ERROR_NONE;
-       }
 
-       ret = legacy_recorder_unset_state_changed_cb(muse_recorder->recorder_handle);
+       LOGD("Enter");
 
        muse_recorder_msg_return(api, class, ret, module);
 
@@ -1874,6 +1912,60 @@ int recorder_dispatcher_set_sound_stream_info(muse_module_h module)
 }
 
 
+int recorder_dispatcher_get_device_state(muse_module_h module)
+{
+       int ret = RECORDER_ERROR_NONE;
+       int device_state = 0;
+       int device_recording = 0;
+       int device_paused = 0;
+       recorder_h recorder = NULL;
+       recorder_type_e recorder_type = RECORDER_TYPE_AUDIO;
+       recorder_device_state_e get_device_state = RECORDER_DEVICE_STATE_NULL;
+       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));
+
+       if (recorder_type < RECORDER_TYPE_AUDIO || recorder_type > RECORDER_TYPE_VIDEO) {
+               LOGE("invalid type %d", recorder_type);
+               ret = CAMERA_ERROR_INVALID_PARAMETER;
+               muse_recorder_msg_return(api, class, ret, module);
+               return MUSE_CAMERA_ERROR_NONE;
+       }
+
+       ret = legacy_recorder_create_audiorecorder(&recorder);
+       if (ret != RECORDER_ERROR_NONE) {
+               LOGE("failed to create recorder handle 0x%x", ret);
+               muse_recorder_msg_return(api, class, ret, module);
+               return MUSE_CAMERA_ERROR_NONE;
+       }
+
+       legacy_recorder_destroy(recorder);
+       recorder = NULL;
+
+       if (recorder_type == RECORDER_TYPE_AUDIO)
+               muse_core_client_get_value(module, RECORDER_DEVICE_STATE_KEY_AUDIO, &device_state);
+       else
+               muse_core_client_get_value(module, RECORDER_DEVICE_STATE_KEY_VIDEO, &device_state);
+
+       device_recording = device_state >> 16;
+       device_paused = 0x0000ffff & device_state;
+
+       LOGD("device recording %d, paused %d", device_recording, device_paused);
+
+       if (device_recording > 0)
+               get_device_state = RECORDER_DEVICE_STATE_RECORDING;
+       else if (device_paused > 0)
+               get_device_state = RECORDER_DEVICE_STATE_PAUSED;
+
+       LOGD("device[%d] state : %d", recorder_type, get_device_state);
+
+       muse_recorder_msg_return1(api, class, ret, module, INT, get_device_state);
+
+       return MUSE_RECORDER_ERROR_NONE;
+}
+
+
 int (*dispatcher[MUSE_RECORDER_API_MAX]) (muse_module_h module) = {
        recorder_dispatcher_create, /* MUSE_RECORDER_API_CREATE */
        recorder_dispatcher_destroy, /* MUSE_RECORDER_API_DESTROY */
@@ -1933,7 +2025,8 @@ int (*dispatcher[MUSE_RECORDER_API_MAX]) (muse_module_h module) = {
        recorder_dispatcher_attr_get_orientation_tag, /* MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG */
        recorder_dispatcher_attr_set_root_directory, /* MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY */
        recorder_dispatcher_return_buffer, /* MUSE_RECORDER_API_RETURN_BUFFER */
-       recorder_dispatcher_set_sound_stream_info /* MUSE_RECORDER_API_SET_SOUND_STREAM_INFO */
+       recorder_dispatcher_set_sound_stream_info, /* MUSE_RECORDER_API_SET_SOUND_STREAM_INFO */
+       recorder_dispatcher_get_device_state /* MUSE_RECORDER_API_GET_DEVICE_STATE */
 };
 
 

diff --git a/packaging/mmsvc-recorder.spec b/packaging/mmsvc-recorder.spec
index ea3f8c7f50ea3814a5941ed8b766b1be0a3bb044..01ab030c10621a8e94f09a432442415cf0fd4afa 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.2.25
+Version:    0.2.26
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0