Get max volume via dbus interface of pulseaudio directly

Change-Id: I91d194cb0475b8023b37919b42954f9b75abcbc5

diff --git a/include/sound_manager_private.h b/include/sound_manager_private.h
index d44a002..09e8ad3 100644 (file)
--- a/include/sound_manager_private.h
+++ b/include/sound_manager_private.h
@@ -190,7 +190,7 @@ int __convert_stream_type_for_internal (sound_stream_type_internal_e stream_type
 
 int __convert_stream_type_to_change_reason (const char *stream_type, sound_stream_focus_change_reason_e *change_reason);
 
-int __convert_device_type (sound_device_type_e device_type_enum, char *device_type);
+int __convert_device_type (sound_device_type_e device_type_enum, char **device_type);
 
 int __convert_device_type_to_enum (char *device_type, sound_device_type_e *device_type_enum);
 
@@ -202,6 +202,10 @@ int __set_manual_route_info (unsigned int index, manual_route_info_s *info);
 
 int __set_route_options (unsigned int index, char **route_options);
 
+int __convert_sound_type (sound_type_e sound_type, const char **volume_type);
+
+int __get_volume_max_level (const char *direction, const char *volume_type, unsigned int *max_level);
+
 void _pa_context_state_cb (pa_context *c, void *userdata);
 
 void _pa_stream_state_cb (pa_stream *s, void * userdata);

diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec
index 9093111..5fa71c0 100755 (executable)
--- a/packaging/capi-media-sound-manager.spec
+++ b/packaging/capi-media-sound-manager.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-sound-manager
 Summary:    Sound Manager library
-Version:    0.3.0
+Version:    0.3.1
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/sound_manager.c b/src/sound_manager.c
index f7126da..90b4052 100644 (file)
--- a/src/sound_manager.c
+++ b/src/sound_manager.c
@@ -28,16 +28,20 @@ _session_mode_e g_cached_session_mode = -1;
 
 int sound_manager_get_max_volume (sound_type_e type, int *max)
 {
-       int volume;
+       const char *volume_type = NULL;
+       unsigned int max_level = 0;
+       int ret = MM_ERROR_NONE;
        if(max == NULL)
                return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
 
        if(type >= SOUND_TYPE_NUM || type < 0)
                return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
-       int ret = mm_sound_volume_get_step(type, &volume);
+       ret = __convert_sound_type (type, &volume_type);
+       if (!ret)
+               ret = __get_volume_max_level("out", volume_type, &max_level);
 
        if(ret == 0)
-               *max = volume -1;       // actual volume step can be max step - 1
+               *max = (int)max_level -1;       // actual volume step can be max step - 1
 
        return __convert_sound_manager_error_code(__func__, ret);
 }
@@ -182,7 +186,7 @@ int sound_manager_add_device_for_stream_routing (sound_stream_info_h stream_info
        int i = 0;
        int j = 0;
        bool added_successfully = false;
-       char device_type_str[SOUND_DEVICE_TYPE_LEN] = {0,};
+       char *device_type_str = NULL;
        mm_sound_device_type_e device_type;
        mm_sound_device_io_direction_e device_direction;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
@@ -197,7 +201,7 @@ int sound_manager_add_device_for_stream_routing (sound_stream_info_h stream_info
                if (ret) {
                        return __convert_sound_manager_error_code(__func__, ret);
                }
-               ret = __convert_device_type(device_type, device_type_str);
+               ret = __convert_device_type(device_type, &device_type_str);
                if (ret) {
                        return __convert_sound_manager_error_code(__func__, ret);
                }
@@ -264,7 +268,7 @@ int sound_manager_remove_device_for_stream_routing (sound_stream_info_h stream_i
        int i = 0;
        int j = 0;
        bool removed_successfully = false;
-       char device_type_str[SOUND_DEVICE_TYPE_LEN] = {0,};
+       char *device_type_str = NULL;
        mm_sound_device_type_e device_type;
        mm_sound_device_io_direction_e device_direction;
        sound_stream_info_s *stream_h = (sound_stream_info_s*)stream_info;
@@ -279,7 +283,7 @@ int sound_manager_remove_device_for_stream_routing (sound_stream_info_h stream_i
                if (ret) {
                        return __convert_sound_manager_error_code(__func__, ret);
                }
-               ret = __convert_device_type(device_type, device_type_str);
+               ret = __convert_device_type(device_type, &device_type_str);
                if (ret) {
                        return __convert_sound_manager_error_code(__func__, ret);
                }

diff --git a/src/sound_manager_private.c b/src/sound_manager_private.c
index 1d7b7da..7dd9bfd 100644 (file)
--- a/src/sound_manager_private.c
+++ b/src/sound_manager_private.c
@@ -24,6 +24,7 @@
 #define PA_STREAM_MANAGER_METHOD_NAME_GET_STREAM_INFO           "GetStreamInfo"
 #define PA_STREAM_MANAGER_METHOD_NAME_SET_STREAM_ROUTE_DEVICES  "SetStreamRouteDevices"
 #define PA_STREAM_MANAGER_METHOD_NAME_SET_STREAM_ROUTE_OPTIONS  "SetStreamRouteOptions"
+#define PA_STREAM_MANAGER_METHOD_NAME_GET_VOLUME_MAX_LEVEL      "GetVolumeMaxLevel"
 
 extern _session_interrupt_info_s g_session_interrupt_cb_table;
 extern _session_mode_e g_cached_session_mode;
@@ -211,7 +212,48 @@ int __convert_stream_type_to_change_reason (const char *stream_type, sound_strea
        return ret;
 }
 
-int __convert_device_type (sound_device_type_e device_type_enum, char *device_type)
+int __convert_sound_type (sound_type_e sound_type, const char **volume_type)
+{
+       int ret = MM_ERROR_NONE;
+
+       SM_NULL_ARG_CHECK(volume_type);
+
+       switch (sound_type) {
+       case SOUND_TYPE_SYSTEM:
+               *volume_type = "system";
+               break;
+       case SOUND_TYPE_NOTIFICATION:
+               *volume_type = "notification";
+               break;
+       case SOUND_TYPE_ALARM:
+               *volume_type = "alarm";
+               break;
+       case SOUND_TYPE_RINGTONE:
+               *volume_type = "ringtone";
+               break;
+       case SOUND_TYPE_MEDIA:
+               *volume_type = "media";
+               break;
+       case SOUND_TYPE_CALL:
+               *volume_type = "call";
+               break;
+       case SOUND_TYPE_VOIP:
+               *volume_type = "voip";
+               break;
+       case SOUND_TYPE_VOICE:
+               *volume_type = "voice";
+               break;
+       }
+       if (!strncmp(*volume_type,"",SOUND_DEVICE_TYPE_LEN)) {
+               LOGE("could not find the sound_type[%d] in this switch case statement", sound_type);
+               ret = MM_ERROR_SOUND_INTERNAL;
+       } else {
+               LOGI("volume_type[%s]", *volume_type);
+       }
+       return ret;
+}
+
+int __convert_device_type (sound_device_type_e device_type_enum, char **device_type)
 {
        int ret = MM_ERROR_NONE;
 
@@ -219,35 +261,35 @@ int __convert_device_type (sound_device_type_e device_type_enum, char *device_ty
 
        switch (device_type_enum) {
        case SOUND_DEVICE_BUILTIN_SPEAKER:
-               SOUND_STRNCPY(device_type,"builtin-speaker",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "builtin-speaker";
                break;
        case SOUND_DEVICE_BUILTIN_RECEIVER:
-               SOUND_STRNCPY(device_type,"builtin-receiver",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "builtin-receiver";
                break;
        case SOUND_DEVICE_BUILTIN_MIC:
-               SOUND_STRNCPY(device_type,"builtin-mic",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "builtin-mic";
                break;
        case SOUND_DEVICE_AUDIO_JACK:
-               SOUND_STRNCPY(device_type,"audio-jack",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "audio-jack";
                break;
        case SOUND_DEVICE_BLUETOOTH:
-               SOUND_STRNCPY(device_type,"bt",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "bt";
                break;
        case SOUND_DEVICE_HDMI:
-               SOUND_STRNCPY(device_type,"hdmi",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "hdmi";
                break;
        case SOUND_DEVICE_USB_AUDIO:
-               SOUND_STRNCPY(device_type,"usb-audio",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "usb-audio";
                break;
        case SOUND_DEVICE_FORWARDING:
-               SOUND_STRNCPY(device_type,"forwarding",SOUND_DEVICE_TYPE_LEN,ret);
+               *device_type = "forwarding";
                break;
        }
-       if (!strncmp(device_type,"",SOUND_DEVICE_TYPE_LEN)) {
+       if (!strncmp(*device_type,"",SOUND_DEVICE_TYPE_LEN)) {
                LOGE("could not find the device_type[%d] in this switch case statement", device_type_enum);
                ret = MM_ERROR_SOUND_INTERNAL;
        } else {
-               LOGI("device_type[%s]", device_type);
+               LOGI("device_type[%s]", *device_type);
        }
        return ret;
 }
@@ -406,12 +448,14 @@ int __get_stream_conf_info (const char *stream_type, stream_conf_info_s *info)
        GDBusConnection *conn = NULL;
        GError *err = NULL;
 
+       assert(stream_type);
+       assert(info);
+
        conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
        if (!conn && err) {
                LOGE("g_bus_get_sync() error (%s)", err->message);
                g_error_free (err);
-               ret = MM_ERROR_SOUND_INTERNAL;
-               return ret;
+               return MM_ERROR_SOUND_INTERNAL;
        }
        result = g_dbus_connection_call_sync (conn,
                                                        PA_BUS_NAME,
@@ -525,12 +569,13 @@ int __set_manual_route_info (unsigned int index, manual_route_info_s *info)
        GDBusConnection *conn = NULL;
        GError *err = NULL;
 
+       assert(info);
+
        conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
        if (!conn && err) {
                LOGE("g_bus_get_sync() error (%s)", err->message);
                g_error_free (err);
-               ret = MM_ERROR_SOUND_INTERNAL;
-               return ret;
+               return MM_ERROR_SOUND_INTERNAL;
        }
 
        builder_for_in_devices = g_variant_builder_new(G_VARIANT_TYPE("as"));
@@ -591,12 +636,13 @@ int __set_route_options (unsigned int index, char **route_options)
        GDBusConnection *conn = NULL;
        GError *err = NULL;
 
+       assert(route_options);
+
        conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
        if (!conn && err) {
                LOGE("g_bus_get_sync() error (%s)", err->message);
                g_error_free (err);
-               ret = MM_ERROR_SOUND_INTERNAL;
-               return ret;
+               return MM_ERROR_SOUND_INTERNAL;
        }
 
        builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
@@ -637,6 +683,52 @@ int __set_route_options (unsigned int index, char **route_options)
        return ret;
 }
 
+int __get_volume_max_level (const char *direction, const char *volume_type, unsigned int *max_level)
+{
+       int ret = MM_ERROR_NONE;
+
+       GVariant *result = NULL;
+       GDBusConnection *conn = NULL;
+       GError *err = NULL;
+
+       assert(direction);
+       assert(volume_type);
+       assert(max_level);
+
+       conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+       if (!conn && err) {
+               LOGE("g_bus_get_sync() error (%s)", err->message);
+               g_error_free (err);
+               return MM_ERROR_SOUND_INTERNAL;
+       }
+
+       result = g_dbus_connection_call_sync (conn,
+                                                       PA_BUS_NAME,
+                                                       PA_STREAM_MANAGER_OBJECT_PATH,
+                                                       PA_STREAM_MANAGER_INTERFACE,
+                                                       PA_STREAM_MANAGER_METHOD_NAME_GET_VOLUME_MAX_LEVEL,
+                                                       g_variant_new ("(ss)", direction, volume_type),
+                                                       G_VARIANT_TYPE("(us)"),
+                                                       G_DBUS_CALL_FLAGS_NONE,
+                                                       2000,
+                                                       NULL,
+                                                       &err);
+       if (!result && err) {
+               LOGE("g_dbus_connection_call_sync() error (%s)", err->message);
+               ret = MM_ERROR_SOUND_INTERNAL;
+       } else {
+               const gchar *dbus_ret = NULL;
+               g_variant_get(result, "(us)", max_level, &dbus_ret);
+               LOGI("g_dbus_connection_call_sync() success, method return value is (%u, %s)", *max_level, dbus_ret);
+               if (strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret))) {
+                       ret = MM_ERROR_SOUND_INTERNAL;
+               }
+               g_variant_unref(result);
+       }
+       g_object_unref(conn);
+       return ret;
+}
+
 void _session_interrupt_cb (session_msg_t msg, session_event_t event, void *user_data){
        if( g_session_interrupt_cb_table.user_cb ){
                sound_session_interrupted_code_e e = SOUND_SESSION_INTERRUPTED_COMPLETED;