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);
}
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;
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);
}
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;
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);
}
#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;
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;
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;
}
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,
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"));
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"));
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;