Add new legacy APIs and dispatcher functions for new APIs

The user has no way to know when the interrupt is started.
This commit provides the interface for it.

[Version] 0.3.1
[Profile] Common
[Issue Type] Update
[Dependency module] N/A
[Test] [M(T) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-unified_20170608.1]

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

diff --git a/legacy/include/legacy_recorder.h b/legacy/include/legacy_recorder.h
index efa2b07..1be06e3 100644 (file)
--- a/legacy/include/legacy_recorder.h
+++ b/legacy/include/legacy_recorder.h
@@ -244,6 +244,16 @@ typedef void (*recorder_state_changed_cb)(recorder_state_e previous, recorder_st
 typedef void (*recorder_interrupted_cb)(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *user_data);
 
 /**
+ * @brief Called when the recorder interrupt is started by a policy.
+ * @since_tizen 4.0
+ * @param[in] policy        The policy that is interrupting the recorder
+ * @param[in] state         The current state of the recorder
+ * @param[in] user_data     The user data passed from the callback registration function
+ * @see        legacy_recorder_set_interrupt_started_cb()
+ */
+typedef void (*recorder_interrupt_started_cb)(recorder_policy_e policy, recorder_state_e state, void *user_data);
+
+/**
  * @brief Called when audio stream data was being delivered just before storing in the recorded file.
  * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
  * @remarks The callback function holds the same buffer that will be recorded. \n
@@ -1024,6 +1034,31 @@ int legacy_recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted
 int legacy_recorder_unset_interrupted_cb(recorder_h recorder);
 
 /**
+ * @brief Registers a callback function to be called when the media recorder interrupt is started according to a policy.
+ * @since_tizen 4.0
+ * @param[in] recorder The handle to the media recorder
+ * @param[in] callback   The callback function to register
+ * @param[in] user_data   The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see        legacy_recorder_unset_interrupt_started_cb()
+ * @see        legacy_recorder_interrupt_started_cb()
+ */
+int legacy_recorder_set_interrupt_started_cb(recorder_h recorder, recorder_interrupt_started_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 4.0
+ * @param[in]  recorder        The handle to the media recorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see        legacy_recorder_set_interrupt_started_cb()
+ */
+int legacy_recorder_unset_interrupt_started_cb(recorder_h recorder);
+
+/**
  * @brief Registers a callback function to be called when audio stream data is being delivered.
  * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
  * @remarks This callback function holds the same buffer that will be recorded. \n

diff --git a/legacy/include/legacy_recorder_private.h b/legacy/include/legacy_recorder_private.h
index cc1ca8e..0c930e8 100644 (file)
--- a/legacy/include/legacy_recorder_private.h
+++ b/legacy/include/legacy_recorder_private.h
@@ -38,6 +38,7 @@ typedef enum {
        _RECORDER_EVENT_TYPE_AUDIO_STREAM,
        _RECORDER_EVENT_TYPE_MUXED_STREAM,
        _RECORDER_EVENT_TYPE_ERROR,
+       _RECORDER_EVENT_TYPE_INTERRUPT_STARTED,
        _RECORDER_EVENT_TYPE_NUM
 } _recorder_event_e;
 

diff --git a/legacy/src/legacy_recorder.c b/legacy/src/legacy_recorder.c
index e7c1721..a16edfe 100644 (file)
--- a/legacy/src/legacy_recorder.c
+++ b/legacy/src/legacy_recorder.c
@@ -235,10 +235,11 @@ static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state,
 
 static int __mm_recorder_msg_cb(int message, void *param, void *user_data)
 {
-       recorder_s * handle = (recorder_s *)user_data;
+       recorder_s *handle = (recorder_s *)user_data;
        MMMessageParamType *m = (MMMessageParamType *)param;
        recorder_state_e previous_state;
        recorder_recording_limit_type_e type;
+       recorder_policy_e policy = RECORDER_POLICY_NONE;
        int recorder_error = 0;
 
        switch (message) {
@@ -254,7 +255,7 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data)
 
                previous_state = handle->state;
                handle->state = __recorder_state_convert(m->state.current, m->state.previous);
-               recorder_policy_e policy = RECORDER_POLICY_NONE;
+
                if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM) {
                        switch (m->state.code) {
                        case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
@@ -306,6 +307,25 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data)
                }
                break;
        }
+       case MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_ASM:
+       case MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_SECURITY:
+       case MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_RM:
+               if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]) {
+                       if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_ASM)
+                               policy = RECORDER_POLICY_SOUND;
+                       else if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_SECURITY)
+                               policy = RECORDER_POLICY_SECURITY;
+                       else if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGE_STARTED_BY_RM)
+                               policy = RECORDER_POLICY_RESOURCE_CONFLICT;
+
+                       LOGW("message 0x%x -> policy %d", message, policy);
+
+                       if (policy != RECORDER_POLICY_NONE) {
+                               ((recorder_interrupt_started_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED])(policy,
+                                       handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]);
+                       }
+               }
+               break;
        case MM_MESSAGE_CAMCORDER_MAX_SIZE:
        case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
        case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
@@ -1225,6 +1245,42 @@ int legacy_recorder_unset_interrupted_cb(recorder_h recorder)
 }
 
 
+int legacy_recorder_set_interrupt_started_cb(recorder_h recorder, recorder_interrupt_started_cb callback, void *user_data)
+{
+       recorder_s *handle = (recorder_s *)recorder;
+
+       if (recorder == NULL) {
+               LOGE("NULL pointer handle");
+               return RECORDER_ERROR_INVALID_PARAMETER;
+       }
+       if (callback == NULL) {
+               LOGE("NULL pointer callback");
+               return RECORDER_ERROR_INVALID_PARAMETER;
+       }
+
+       handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = callback;
+       handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = user_data;
+
+       return RECORDER_ERROR_NONE;
+}
+
+
+int legacy_recorder_unset_interrupt_started_cb(recorder_h recorder)
+{
+       recorder_s *handle = (recorder_s *)recorder;
+
+       if (recorder == NULL) {
+               LOGE("NULL pointer handle");
+               return RECORDER_ERROR_INVALID_PARAMETER;
+       }
+
+       handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
+       handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
+
+       return RECORDER_ERROR_NONE;
+}
+
+
 int legacy_recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data)
 {
        int ret = MM_ERROR_NONE;

diff --git a/muse/include/muse_recorder.h b/muse/include/muse_recorder.h
index 21271bf..7920111 100644 (file)
--- a/muse/include/muse_recorder.h
+++ b/muse/include/muse_recorder.h
@@ -100,6 +100,8 @@ typedef enum {
        MUSE_RECORDER_API_GET_DEVICE_STATE,
        MUSE_RECORDER_API_SET_MUXED_STREAM_CB,
        MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB, /* 65 */
+       MUSE_RECORDER_API_SET_INTERRUPT_STARTED_CB,
+       MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_CB,
        MUSE_RECORDER_API_MAX
 } muse_recorder_api_e;
 
@@ -127,6 +129,7 @@ typedef enum {
        MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
        MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
        MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
+       MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED,
        MUSE_RECORDER_EVENT_TYPE_NUM
 } muse_recorder_event_e;
 

diff --git a/muse/src/muse_recorder_dispatcher.c b/muse/src/muse_recorder_dispatcher.c
index 9305dbc..6c5b31f 100644 (file)
--- a/muse/src/muse_recorder_dispatcher.c
+++ b/muse/src/muse_recorder_dispatcher.c
@@ -223,6 +223,25 @@ void _recorder_disp_interrupted_cb(recorder_policy_e policy, recorder_state_e pr
        return;
 }
 
+void _recorder_disp_interrupt_started_cb(recorder_policy_e policy, recorder_state_e state, void *user_data)
+{
+       muse_module_h module = (muse_module_h)user_data;
+
+       if (module == NULL) {
+               LOGE("NULL module");
+               return;
+       }
+
+       muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
+               MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED,
+               MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+               module,
+               INT, policy,
+               INT, state);
+
+       return;
+}
+
 void _recorder_disp_error_cb(recorder_error_e error, recorder_state_e current_state, void *user_data)
 {
        muse_module_h module = (muse_module_h)user_data;
@@ -1136,6 +1155,52 @@ int recorder_dispatcher_unset_interrupted_cb(muse_module_h module)
        return MUSE_RECORDER_ERROR_NONE;
 }
 
+int recorder_dispatcher_set_interrupt_started_cb(muse_module_h module)
+{
+       int ret = RECORDER_ERROR_NONE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPT_STARTED_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_interrupt_started_cb(muse_recorder->recorder_handle,
+               (recorder_interrupt_started_cb)_recorder_disp_interrupt_started_cb,
+               (void *)module);
+
+       muse_recorder_msg_return(api, class, ret, module);
+
+       return MUSE_RECORDER_ERROR_NONE;
+}
+
+int recorder_dispatcher_unset_interrupt_started_cb(muse_module_h module)
+{
+       int ret = RECORDER_ERROR_NONE;
+       muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_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_interrupt_started_cb(muse_recorder->recorder_handle);
+
+       muse_recorder_msg_return(api, class, ret, module);
+
+       return MUSE_RECORDER_ERROR_NONE;
+}
+
 int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
 {
        int ret = RECORDER_ERROR_NONE;
@@ -2328,7 +2393,9 @@ int (*dispatcher[MUSE_RECORDER_API_MAX]) (muse_module_h module) = {
        recorder_dispatcher_set_sound_stream_info, /* MUSE_RECORDER_API_SET_SOUND_STREAM_INFO */
        recorder_dispatcher_get_device_state, /* MUSE_RECORDER_API_GET_DEVICE_STATE */
        recorder_dispatcher_set_muxed_stream_cb, /* MUSE_RECORDER_API_SET_MUXED_STREAM_CB */
-       recorder_dispatcher_unset_muxed_stream_cb /* MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB */
+       recorder_dispatcher_unset_muxed_stream_cb, /* MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB */
+       recorder_dispatcher_set_interrupt_started_cb, /* MUSE_RECORDER_API_SET_INTERRUPT_STARTED_CB */
+       recorder_dispatcher_unset_interrupt_started_cb /* MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_CB */
 };
 
 
@@ -2432,7 +2499,7 @@ static int recorder_cmd_external_storage_state_changed(muse_module_h module)
                return MUSE_RECORDER_ERROR_NONE;
        }
 
-       storage_state = (int)muse_core_client_get_cust_data(module);
+       storage_state = (int)(long)muse_core_client_get_cust_data(module);
 
        LOGW("storage state %d", storage_state);
 

diff --git a/packaging/mmsvc-recorder.spec b/packaging/mmsvc-recorder.spec
index 2c4402a..595264c 100644 (file)
--- a/packaging/mmsvc-recorder.spec
+++ b/packaging/mmsvc-recorder.spec
@@ -1,7 +1,7 @@
 Name:       mmsvc-recorder
 Summary:    A Recorder module for muse server
-Version:    0.3.0
-Release:    2
+Version:    0.3.1
+Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz