Remove unused destructor/constructor block

[platform/core/api/sound-manager.git] / src / sound_manager.c

diff --git a/src/sound_manager.c b/src/sound_manager.c
index 6c74e77..eabfbc5 100644 (file)
--- a/src/sound_manager.c
+++ b/src/sound_manager.c
@@ -273,13 +273,14 @@ int sound_manager_acquire_focus(sound_stream_info_h stream_info, sound_stream_fo
 {
        int ret = MM_ERROR_NONE;
        bool is_focus_cb_thread = false;
+       bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
        LOGI(">> enter");
 
        SM_INSTANCE_CHECK(stream_h);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (stream_h->is_focus_unavailable) {
@@ -296,6 +297,12 @@ int sound_manager_acquire_focus(sound_stream_info_h stream_info, sound_stream_fo
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
                SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(&stream_h->focus_state_mutex, &stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
        } else {
+               /* If it is inside of the watch cb and if the previous request of this process has not been finished yet,
+                * the focus state mutex could be still locked. Therefore, it returns error here. */
+               if (is_focus_watch_cb_thread && stream_h->is_requesting) {
+                       LOGE("It is not allowed in watch cb thread during the previous request has not been finished yet");
+                       return _convert_sound_manager_error_code(__func__, MM_ERROR_SOUND_INVALID_OPERATION);
+               }
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_state_mutex, MM_ERROR_SOUND_INTERNAL);
        }
 
@@ -312,6 +319,8 @@ int sound_manager_acquire_focus(sound_stream_info_h stream_info, sound_stream_fo
                goto LEAVE;
        }
 
+       stream_h->is_requesting = true;
+
        ret = mm_sound_acquire_focus_with_option(stream_h->focus_id, (mm_sound_focus_type_e)focus_mask, sound_behavior, extra_info);
        if (ret == MM_ERROR_NONE) {
                stream_h->acquired_focus |= focus_mask;
@@ -322,6 +331,7 @@ int sound_manager_acquire_focus(sound_stream_info_h stream_info, sound_stream_fo
        LOGI("acquired_focus[0x%x], prev[0x%x]", stream_h->acquired_focus, stream_h->prev_acquired_focus);
 
 LEAVE:
+       stream_h->is_requesting = false;
        SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_state_mutex);
        if (!is_focus_cb_thread)
                SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_cb_mutex);
@@ -333,19 +343,26 @@ int sound_manager_release_focus(sound_stream_info_h stream_info, sound_stream_fo
 {
        int ret = MM_ERROR_NONE;
        bool is_focus_cb_thread = false;
+       bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
        LOGI(">> enter");
 
        SM_INSTANCE_CHECK(stream_h);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (!is_focus_cb_thread) {
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
                SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(&stream_h->focus_state_mutex, &stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
        } else {
+               /* If it is inside of the watch cb and if the previous request of this process has not been finished yet,
+                * the focus state mutex could be still locked. Therefore, it returns error here. */
+               if (is_focus_watch_cb_thread && stream_h->is_requesting) {
+                       LOGE("It is not allowed in watch cb thread during the previous request has not been finished yet");
+                       return _convert_sound_manager_error_code(__func__, MM_ERROR_SOUND_INVALID_OPERATION);
+               }
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_state_mutex, MM_ERROR_SOUND_INTERNAL);
        }
 
@@ -362,6 +379,8 @@ int sound_manager_release_focus(sound_stream_info_h stream_info, sound_stream_fo
                goto LEAVE;
        }
 
+       stream_h->is_requesting = true;
+
        ret = mm_sound_release_focus_with_option(stream_h->focus_id, (mm_sound_focus_type_e)focus_mask, sound_behavior, extra_info);
        if (ret == MM_ERROR_NONE) {
                stream_h->acquired_focus &= ~focus_mask;
@@ -372,6 +391,7 @@ int sound_manager_release_focus(sound_stream_info_h stream_info, sound_stream_fo
        LOGI("acquired_focus[0x%x], prev[0x%x]", stream_h->acquired_focus, stream_h->prev_acquired_focus);
 
 LEAVE:
+       stream_h->is_requesting = false;
        SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_state_mutex);
        if (!is_focus_cb_thread)
                SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_cb_mutex);
@@ -384,13 +404,14 @@ int sound_manager_acquire_focus_all(sound_stream_info_h stream_info, int sound_b
        int ret = MM_ERROR_NONE;
        int focus_mask = SOUND_STREAM_FOCUS_FOR_BOTH;
        bool is_focus_cb_thread = false;
+       bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
        LOGI(">> enter");
 
        SM_INSTANCE_CHECK(stream_h);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (stream_h->is_focus_unavailable) {
@@ -407,6 +428,12 @@ int sound_manager_acquire_focus_all(sound_stream_info_h stream_info, int sound_b
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
                SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(&stream_h->focus_state_mutex, &stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
        } else {
+               /* If it is inside of the watch cb and if the previous request of this process has not been finished yet,
+                * the focus state mutex could be still locked. Therefore, it returns error here. */
+               if (is_focus_watch_cb_thread && stream_h->is_requesting) {
+                       LOGE("It is not allowed in watch cb thread during the previous request has not been finished yet");
+                       return _convert_sound_manager_error_code(__func__, MM_ERROR_SOUND_INVALID_OPERATION);
+               }
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_state_mutex, MM_ERROR_SOUND_INTERNAL);
        }
 
@@ -424,6 +451,8 @@ int sound_manager_acquire_focus_all(sound_stream_info_h stream_info, int sound_b
                goto LEAVE;
        }
 
+       stream_h->is_requesting = true;
+
        ret = mm_sound_acquire_focus_with_option(stream_h->focus_id, (mm_sound_focus_type_e)focus_mask, sound_behavior, extra_info);
        if (ret == MM_ERROR_NONE) {
                stream_h->acquired_focus |= focus_mask;
@@ -432,6 +461,7 @@ int sound_manager_acquire_focus_all(sound_stream_info_h stream_info, int sound_b
        }
 
 LEAVE:
+       stream_h->is_requesting = false;
        SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_state_mutex);
        if (!is_focus_cb_thread)
                SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_cb_mutex);
@@ -443,19 +473,26 @@ int sound_manager_release_focus_all(sound_stream_info_h stream_info, int sound_b
 {
        int ret = MM_ERROR_NONE;
        bool is_focus_cb_thread = false;
+       bool is_focus_watch_cb_thread = false;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
 
        LOGI(">> enter");
 
        SM_INSTANCE_CHECK(stream_h);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, &is_focus_watch_cb_thread)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (!is_focus_cb_thread) {
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
                SM_ENTER_CRITICAL_SECTION_WITH_UNLOCK_AND_RETURN(&stream_h->focus_state_mutex, &stream_h->focus_cb_mutex, MM_ERROR_SOUND_INTERNAL);
        } else {
+               /* If it is inside of the watch cb and if the previous request of this process has not been finished yet,
+                * the focus state mutex could be still locked. Therefore, it returns error here. */
+               if (is_focus_watch_cb_thread && stream_h->is_requesting) {
+                       LOGE("It is not allowed in watch cb thread during the previous request has not been finished yet");
+                       return _convert_sound_manager_error_code(__func__, MM_ERROR_SOUND_INVALID_OPERATION);
+               }
                SM_ENTER_CRITICAL_SECTION_WITH_RETURN(&stream_h->focus_state_mutex, MM_ERROR_SOUND_INTERNAL);
        }
 
@@ -472,6 +509,8 @@ int sound_manager_release_focus_all(sound_stream_info_h stream_info, int sound_b
                goto LEAVE;
        }
 
+       stream_h->is_requesting = true;
+
        ret = mm_sound_release_focus_with_option(stream_h->focus_id, (mm_sound_focus_type_e)stream_h->acquired_focus, sound_behavior, extra_info);
        if (ret == MM_ERROR_NONE) {
                stream_h->acquired_focus = 0;
@@ -480,6 +519,7 @@ int sound_manager_release_focus_all(sound_stream_info_h stream_info, int sound_b
        }
 
 LEAVE:
+       stream_h->is_requesting = false;
        SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_state_mutex);
        if (!is_focus_cb_thread)
                SM_LEAVE_CRITICAL_SECTION(&stream_h->focus_cb_mutex);
@@ -524,7 +564,7 @@ int sound_manager_deliver_focus(sound_stream_info_h source, sound_stream_info_h
        SM_INSTANCE_CHECK(src_stream_h);
        SM_INSTANCE_CHECK(dst_stream_h);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (is_focus_cb_thread) {
@@ -607,7 +647,7 @@ int sound_manager_get_current_playback_focus(sound_stream_focus_change_reason_e
        SM_NULL_ARG_CHECK(acquired_by);
        SM_NULL_ARG_CHECK(flags);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (is_focus_cb_thread) {
@@ -645,7 +685,7 @@ int sound_manager_get_current_recording_focus(sound_stream_focus_change_reason_e
        SM_NULL_ARG_CHECK(acquired_by);
        SM_NULL_ARG_CHECK(flags);
 
-       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread)))
+       if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread, NULL)))
                return _convert_sound_manager_error_code(__func__, ret);
 
        if (is_focus_cb_thread) {
@@ -833,6 +873,174 @@ int sound_manager_get_device_state(sound_device_h device, sound_device_state_e *
        return _convert_sound_manager_error_code(__func__, ret);
 }
 
+int sound_manager_get_supported_sample_formats(sound_device_h device, sound_sample_format_e **formats, unsigned int *num_of_elems)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(formats);
+       SM_NULL_ARG_CHECK(num_of_elems);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_supported_sample_formats(device_id, formats, num_of_elems);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_sample_format(sound_device_h device, sound_sample_format_e format)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _set_sample_format(device_id, format);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_sample_format(sound_device_h device, sound_sample_format_e *format)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(format);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_sample_format(device_id, format);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_supported_sample_rates(sound_device_h device, sound_sample_rate_e **rates, unsigned int *num_of_elems)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(rates);
+       SM_NULL_ARG_CHECK(num_of_elems);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_supported_sample_rates(device_id, rates, num_of_elems);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_sample_rate(sound_device_h device, sound_sample_rate_e rate)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _set_sample_rate(device_id, rate);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_sample_rate(sound_device_h device, sound_sample_rate_e *rate)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(rate);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_sample_rate(device_id, rate);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_avoid_resampling(sound_device_h device, bool enable)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _set_avoid_resampling(device_id, enable);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_avoid_resampling(sound_device_h device, bool *enabled)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(enabled);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_avoid_resampling(device_id, enabled);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_media_stream_only(sound_device_h device, bool enable)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _set_media_stream_only(device_id, enable);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_media_stream_only(sound_device_h device, bool *enabled)
+{
+       int ret = MM_ERROR_NONE;
+       int device_id;
+
+       SM_INSTANCE_CHECK(device);
+       SM_NULL_ARG_CHECK(enabled);
+
+       if ((ret = _return_val_if_not_usb_device(device, SOUND_MANAGER_ERROR_INVALID_OPERATION)))
+               return ret;
+
+       if (!(ret = mm_sound_get_device_id(device, &device_id)))
+               ret = _get_media_stream_only(device_id, enabled);
+
+       return _convert_sound_manager_error_code(__func__, ret);
+}
+
 int sound_manager_add_device_connection_changed_cb(int device_mask, sound_device_connection_changed_cb callback, void *user_data, int *id)
 {
        int ret = MM_ERROR_NONE;
@@ -907,14 +1115,3 @@ int sound_manager_remove_device_state_changed_cb(int id)
        return _convert_sound_manager_error_code(__func__, ret);
 }
 
-__attribute__ ((destructor))
-void __sound_manager_finalize(void)
-{
-
-}
-
-__attribute__ ((constructor))
-void __sound_manager_initialize(void)
-{
-
-}