diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/CMakeLists.txt | 6 | ||||
| -rw-r--r-- | src/volume-warning.vala | 1165 |
2 files changed, 1171 insertions, 0 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 73a270c..51f474b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -44,6 +44,7 @@ vala_add(indicator-sound-service sound-menu volume-control volume-control-pulse + volume-warning media-player media-player-list mpris2-interfaces @@ -58,6 +59,11 @@ vala_add(indicator-sound-service volume-control ) vala_add(indicator-sound-service + volume-warning.vala + DEPENDS + volume-control +) +vala_add(indicator-sound-service media-player.vala ) vala_add(indicator-sound-service diff --git a/src/volume-warning.vala b/src/volume-warning.vala new file mode 100644 index 0000000..c24f808 --- /dev/null +++ b/src/volume-warning.vala @@ -0,0 +1,1165 @@ +/* + * -*- Mode:Vala; indent-tabs-mode:t; tab-width:4; encoding:utf8 -*- + * Copyright 2013 Canonical Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Authors: + * Alberto Ruiz <alberto.ruiz@canonical.com> + */ + +using PulseAudio; +using Notify; +using Gee; + +[CCode(cname="pa_cvolume_set", cheader_filename = "pulse/volume.h")] +extern unowned PulseAudio.CVolume? vol_set (PulseAudio.CVolume? cv, uint channels, PulseAudio.Volume v); + +[DBus (name="com.canonical.UnityGreeter.List")] +interface GreeterListInterface : Object +{ + public abstract async string get_active_entry () throws IOError; + public signal void entry_selected (string entry_name); +} + +public class VolumeWarning : VolumeControl +{ + /* this is static to ensure it being freed after @context (loop does not have ref counting) */ + private static PulseAudio.GLibMainLoop loop; + + private uint _reconnect_timer = 0; + + private PulseAudio.Context context; + private bool _mute = true; + private bool _is_playing = false; + private bool _ignore_warning_this_time = false; + private VolumeControl.Volume _volume = new VolumeControl.Volume(); + private double _mic_volume = 0.0; + private Settings _settings = new Settings ("com.canonical.indicator.sound"); + private Settings _shared_settings = new Settings ("com.ubuntu.sound"); + + /* Used by the pulseaudio stream restore extension */ + private DBusConnection _pconn; + /* Need both the list and hash so we can retrieve the last known sink-input after + * releasing the current active one (restoring back to the previous known role) */ + private Gee.ArrayList<uint32> _sink_input_list = new Gee.ArrayList<uint32> (); + private HashMap<uint32, string> _sink_input_hash = new HashMap<uint32, string> (); + private bool _pulse_use_stream_restore = false; + private int32 _active_sink_input = -1; + private string[] _valid_roles = {"multimedia", "alert", "alarm", "phone"}; + public override string stream { + get { + if (_active_sink_input == -1) + return "alert"; + var path = _sink_input_hash[_active_sink_input]; + if (path == _objp_role_multimedia) + return "multimedia"; + if (path == _objp_role_alert) + return "alert"; + if (path == _objp_role_alarm) + return "alarm"; + if (path == _objp_role_phone) + return "phone"; + return "alert"; + } + } + private string? _objp_role_multimedia = null; + private string? _objp_role_alert = null; + private string? _objp_role_alarm = null; + private string? _objp_role_phone = null; + private uint _pa_volume_sig_count = 0; + + private DBusProxy _user_proxy; + private GreeterListInterface _greeter_proxy; + private Cancellable _mute_cancellable; + private Cancellable _volume_cancellable; + private uint _local_volume_timer = 0; + private uint _accountservice_volume_timer = 0; + private bool _send_next_local_volume = false; + private double _account_service_volume = 0.0; + private bool _active_port_headphone = false; + private VolumeControl.ActiveOutput _active_output = VolumeControl.ActiveOutput.SPEAKERS; + + /** true when connected to the pulse server */ + public override bool ready { get; private set; } + + /** true when a microphone is active **/ + public override bool active_mic { get; private set; default = false; } + + public VolumeWarning () + { + _volume.volume = 0.0; + _volume.reason = VolumeControl.VolumeReasons.PULSE_CHANGE; + + if (loop == null) + loop = new PulseAudio.GLibMainLoop (); + + _mute_cancellable = new Cancellable (); + _volume_cancellable = new Cancellable (); + + init_all_properties(); + + setup_accountsservice.begin (); + + this.reconnect_to_pulse (); + } + + private void init_all_properties() + { + init_max_volume(); + init_high_volume(); + init_high_volume_approved(); + } + + ~VolumeWarning () + { + stop_all_timers(); + } + + private void stop_all_timers() + { + if (_reconnect_timer != 0) { + Source.remove (_reconnect_timer); + _reconnect_timer = 0; + } + stop_local_volume_timer(); + stop_account_service_volume_timer(); + stop_high_volume_approved_timer(); + } + + private VolumeControl.ActiveOutput calculate_active_output (SinkInfo? sink) { + + VolumeControl.ActiveOutput ret_output = VolumeControl.ActiveOutput.SPEAKERS; + /* Check if the current active port is headset/headphone */ + /* There is not easy way to check if the port is a headset/headphone besides + * checking for the port name. On touch (with the pulseaudio droid element) + * the headset/headphone port is called 'output-headset' and 'output-headphone'. + * On the desktop this is usually called 'analog-output-headphones' */ + + // first of all check if we are in call mode + if (sink.active_port != null && sink.active_port.name == "output-speaker+wired_headphone") { + return VolumeControl.ActiveOutput.CALL_MODE; + } + // look if it's a headset/headphones + if (sink.name == "indicator_sound_test_headphones" || + (sink.active_port != null && + (sink.active_port.name.contains("headset") || + sink.active_port.name.contains("headphone")))) { + _active_port_headphone = true; + // check if it's a bluetooth device + var device_bus = sink.proplist.gets ("device.bus"); + if (device_bus != null && device_bus == "bluetooth") { + ret_output = VolumeControl.ActiveOutput.BLUETOOTH_HEADPHONES; + } else if (device_bus != null && device_bus == "usb") { + ret_output = VolumeControl.ActiveOutput.USB_HEADPHONES; + } else if (device_bus != null && device_bus == "hdmi") { + ret_output = VolumeControl.ActiveOutput.HDMI_HEADPHONES; + } else { + ret_output = VolumeControl.ActiveOutput.HEADPHONES; + } + } else { + // speaker + _active_port_headphone = false; + var device_bus = sink.proplist.gets ("device.bus"); + if (device_bus != null && device_bus == "bluetooth") { + ret_output = VolumeControl.ActiveOutput.BLUETOOTH_SPEAKER; + } else if (device_bus != null && device_bus == "usb") { + ret_output = VolumeControl.ActiveOutput.USB_SPEAKER; + } else if (device_bus != null && device_bus == "hdmi") { + ret_output = VolumeControl.ActiveOutput.HDMI_SPEAKER; + } else { + ret_output = VolumeControl.ActiveOutput.SPEAKERS; + } + } + + return ret_output; + } + + /* PulseAudio logic*/ + private void context_events_cb (Context c, Context.SubscriptionEventType t, uint32 index) + { + switch (t & Context.SubscriptionEventType.FACILITY_MASK) + { + case Context.SubscriptionEventType.SINK: + update_sink (); + break; + + case Context.SubscriptionEventType.SINK_INPUT: + switch (t & Context.SubscriptionEventType.TYPE_MASK) + { + case Context.SubscriptionEventType.NEW: + c.get_sink_input_info (index, handle_new_sink_input_cb); + break; + + case Context.SubscriptionEventType.CHANGE: + c.get_sink_input_info (index, handle_changed_sink_input_cb); + break; + + case Context.SubscriptionEventType.REMOVE: + remove_sink_input_from_list (index); + break; + default: + debug ("Sink input event not known."); + break; + } + break; + + case Context.SubscriptionEventType.SOURCE: + update_source (); + break; + + case Context.SubscriptionEventType.SOURCE_OUTPUT: + switch (t & Context.SubscriptionEventType.TYPE_MASK) + { + case Context.SubscriptionEventType.NEW: + c.get_source_output_info (index, source_output_info_cb); + break; + + case Context.SubscriptionEventType.REMOVE: + this.active_mic = false; + break; + } + break; + } + } + + private void sink_info_cb_for_props (Context c, SinkInfo? i, int eol) + { + if (i == null) + return; + + if (_mute != (bool)i.mute) + { + _mute = (bool)i.mute; + this.notify_property ("mute"); + } + + var playing = (i.state == PulseAudio.SinkState.RUNNING); + if (_is_playing != playing) + { + _is_playing = playing; + this.notify_property ("is-playing"); + } + + // store the current status of the active output + VolumeControl.ActiveOutput active_output_before = active_output; + + // calculate the output + _active_output = calculate_active_output (i); + + // check if the output has changed, if so... emit a signal + VolumeControl.ActiveOutput active_output_now = active_output; + if (active_output_now != active_output_before && + (active_output_now != VolumeControl.ActiveOutput.CALL_MODE && + active_output_before != VolumeControl.ActiveOutput.CALL_MODE)) { + this.active_output_changed (active_output_now); + if (active_output_now == VolumeControl.ActiveOutput.SPEAKERS) { + _high_volume_approved = false; + } + update_high_volume(); + } + + if (_pulse_use_stream_restore == false && + _volume.volume != volume_to_double (i.volume.max ())) + { + var vol = new VolumeControl.Volume(); + vol.volume = volume_to_double (i.volume.max ()); + vol.reason = VolumeControl.VolumeReasons.PULSE_CHANGE; + this.volume = vol; + } + } + + private void source_info_cb (Context c, SourceInfo? i, int eol) + { + if (i == null) + return; + + if (_mic_volume != volume_to_double (i.volume.values[0])) + { + _mic_volume = volume_to_double (i.volume.values[0]); + this.notify_property ("mic-volume"); + } + } + + private void server_info_cb_for_props (Context c, ServerInfo? i) + { + if (i == null) + return; + context.get_sink_info_by_name (i.default_sink_name, sink_info_cb_for_props); + } + + private void update_sink () + { + context.get_server_info (server_info_cb_for_props); + } + + private void update_source_get_server_info_cb (PulseAudio.Context c, PulseAudio.ServerInfo? i) { + if (i != null) + context.get_source_info_by_name (i.default_source_name, source_info_cb); + } + + private void update_source () + { + context.get_server_info (update_source_get_server_info_cb); + } + + private DBusMessage pulse_dbus_filter (DBusConnection connection, owned DBusMessage message, bool incoming) + { + if (message.get_message_type () == DBusMessageType.SIGNAL) { + string active_role_objp = _objp_role_alert; + if (_active_sink_input != -1) + active_role_objp = _sink_input_hash.get (_active_sink_input); + + if (message.get_path () == active_role_objp && message.get_member () == "VolumeUpdated") { + uint sig_count = 0; + lock (_pa_volume_sig_count) { + sig_count = _pa_volume_sig_count; + if (_pa_volume_sig_count > 0) + _pa_volume_sig_count--; + } + + /* We only care about signals if our internal count is zero */ + if (sig_count == 0) { + /* Extract volume and make sure it's not a side effect of us setting it */ + Variant body = message.get_body (); + Variant varray = body.get_child_value (0); + + uint32 type = 0, lvolume = 0; + VariantIter iter = varray.iterator (); + iter.next ("(uu)", &type, &lvolume); + /* Here we need to compare integer values to avoid rounding issues, so just + * using the volume values used by pulseaudio */ + PulseAudio.Volume cvolume = double_to_volume (_volume.volume); + if (lvolume != cvolume) { + /* Someone else changed the volume for this role, reflect on the indicator */ + var vol = new VolumeControl.Volume(); + vol.volume = volume_to_double (lvolume); + vol.reason = VolumeControl.VolumeReasons.PULSE_CHANGE; + // Ignore changes from PULSE to avoid issues with + // some apps that change the volume in the sink + // We only take into account volume changes from the user + this._ignore_warning_this_time = true; + this.volume = vol; + } + } + } + } + + return message; + } + + private async void update_active_sink_input (int32 index) + { + if ((index == -1) || (index != _active_sink_input && index in _sink_input_list)) { + string sink_input_objp = _objp_role_alert; + if (index != -1) + sink_input_objp = _sink_input_hash.get (index); + _active_sink_input = index; + + /* Listen for role volume changes from pulse itself (external clients) */ + try { + var builder = new VariantBuilder (new VariantType ("ao")); + builder.add ("o", sink_input_objp); + + yield _pconn.call ("org.PulseAudio.Core1", "/org/pulseaudio/core1", + "org.PulseAudio.Core1", "ListenForSignal", + new Variant ("(sao)", "org.PulseAudio.Ext.StreamRestore1.RestoreEntry.VolumeUpdated", builder), + null, DBusCallFlags.NONE, -1); + } catch (GLib.Error e) { + warning ("unable to listen for pulseaudio dbus signals (%s)", e.message); + } + + try { + var props_variant = yield _pconn.call ("org.PulseAudio.Ext.StreamRestore1.RestoreEntry", + sink_input_objp, "org.freedesktop.DBus.Properties", "Get", + new Variant ("(ss)", "org.PulseAudio.Ext.StreamRestore1.RestoreEntry", "Volume"), + null, DBusCallFlags.NONE, -1); + Variant tmp; + props_variant.get ("(v)", out tmp); + uint32 type = 0, volume = 0; + VariantIter iter = tmp.iterator (); + iter.next ("(uu)", &type, &volume); + + var vol = new VolumeControl.Volume(); + vol.volume = volume_to_double (volume); + vol.reason = VolumeControl.VolumeReasons.VOLUME_STREAM_CHANGE; + // Ignore changes from PULSE to avoid issues with + // some apps that change the volume in the sink + // We only take into account volume changes from the user + this._ignore_warning_this_time = true; + this.volume = vol; + } catch (GLib.Error e) { + warning ("unable to get volume for active role %s (%s)", sink_input_objp, e.message); + } + } + } + + private void add_sink_input_into_list (SinkInputInfo sink_input) + { + /* We're only adding ones that are not corked and with a valid role */ + var role = sink_input.proplist.gets (PulseAudio.Proplist.PROP_MEDIA_ROLE); + + if (role != null && role in _valid_roles) { + if (sink_input.corked == 0 || role == "phone") { + _sink_input_list.insert (0, sink_input.index); + switch (role) + { + case "multimedia": + _sink_input_hash.set (sink_input.index, _objp_role_multimedia); + break; + case "alert": + _sink_input_hash.set (sink_input.index, _objp_role_alert); + break; + case "alarm": + _sink_input_hash.set (sink_input.index, _objp_role_alarm); + break; + case "phone": + _sink_input_hash.set (sink_input.index, _objp_role_phone); + break; + } + /* Only switch the active sink input in case a phone one is not active */ + if (_active_sink_input == -1 || + _sink_input_hash.get (_active_sink_input) != _objp_role_phone) + update_active_sink_input.begin ((int32)sink_input.index); + } + } + } + + private void remove_sink_input_from_list (uint32 index) + { + if (index in _sink_input_list) { + _sink_input_list.remove (index); + _sink_input_hash.unset (index); + if (index == _active_sink_input) { + if (_sink_input_list.size != 0) + update_active_sink_input.begin ((int32)_sink_input_list.get (0)); + else + update_active_sink_input.begin (-1); + } + } + } + + private void handle_new_sink_input_cb (Context c, SinkInputInfo? i, int eol) + { + if (i == null) + return; + + add_sink_input_into_list (i); + } + + private void handle_changed_sink_input_cb (Context c, SinkInputInfo? i, int eol) + { + if (i == null) + return; + + if (i.index in _sink_input_list) { + /* Phone stream is always corked, so handle it differently */ + if (i.corked == 1 && _sink_input_hash.get (i.index) != _objp_role_phone) + remove_sink_input_from_list (i.index); + } else { + if (i.corked == 0) + add_sink_input_into_list (i); + } + } + + private void source_output_info_cb (Context c, SourceOutputInfo? i, int eol) + { + if (i == null) + return; + + var role = i.proplist.gets (PulseAudio.Proplist.PROP_MEDIA_ROLE); + if (role == "phone" || role == "production") + this.active_mic = true; + } + + private void context_state_callback (Context c) + { + switch (c.get_state ()) { + case Context.State.READY: + if (_pulse_use_stream_restore) { + c.subscribe (PulseAudio.Context.SubscriptionMask.SINK | + PulseAudio.Context.SubscriptionMask.SINK_INPUT | + PulseAudio.Context.SubscriptionMask.SOURCE | + PulseAudio.Context.SubscriptionMask.SOURCE_OUTPUT); + } else { + c.subscribe (PulseAudio.Context.SubscriptionMask.SINK | + PulseAudio.Context.SubscriptionMask.SOURCE | + PulseAudio.Context.SubscriptionMask.SOURCE_OUTPUT); + } + c.set_subscribe_callback (context_events_cb); + update_sink (); + update_source (); + this.ready = true; + break; + + case Context.State.FAILED: + case Context.State.TERMINATED: + if (_reconnect_timer == 0) + _reconnect_timer = Timeout.add_seconds (2, reconnect_timeout); + break; + + default: + this.ready = false; + break; + } + } + + bool reconnect_timeout () + { + _reconnect_timer = 0; + reconnect_to_pulse (); + return false; // G_SOURCE_REMOVE + } + + void reconnect_to_pulse () + { + if (this.ready) { + this.context.disconnect (); + this.context = null; + this.ready = false; + } + + var props = new Proplist (); + props.sets (Proplist.PROP_APPLICATION_NAME, "Ubuntu Audio Settings"); + props.sets (Proplist.PROP_APPLICATION_ID, "com.canonical.settings.sound"); + props.sets (Proplist.PROP_APPLICATION_ICON_NAME, "multimedia-volume-control"); + props.sets (Proplist.PROP_APPLICATION_VERSION, "0.1"); + + reconnect_pulse_dbus (); + + this.context = new PulseAudio.Context (loop.get_api(), null, props); + this.context.set_state_callback (context_state_callback); + + var server_string = Environment.get_variable("PULSE_SERVER"); + if (context.connect(server_string, Context.Flags.NOFAIL, null) < 0) + warning( "pa_context_connect() failed: %s\n", PulseAudio.strerror(context.errno())); + } + + void sink_info_list_callback_set_mute (PulseAudio.Context context, PulseAudio.SinkInfo? sink, int eol) { + if (sink != null) + context.set_sink_mute_by_index (sink.index, true, null); + } + + void sink_info_list_callback_unset_mute (PulseAudio.Context context, PulseAudio.SinkInfo? sink, int eol) { + if (sink != null) + context.set_sink_mute_by_index (sink.index, false, null); + } + + /* Mute operations */ + bool set_mute_internal (bool mute) + { + return_val_if_fail (context.get_state () == Context.State.READY, false); + + if (_mute != mute) { + if (mute) + context.get_sink_info_list (sink_info_list_callback_set_mute); + else + context.get_sink_info_list (sink_info_list_callback_unset_mute); + return true; + } else { + return false; + } + } + + public override void set_mute (bool mute) + { + if (set_mute_internal (mute)) + sync_mute_to_accountsservice.begin (mute); + } + + public void toggle_mute () + { + this.set_mute (!this._mute); + } + + public override bool mute + { + get + { + return this._mute; + } + } + + public override bool is_playing + { + get + { + return this._is_playing; + } + } + + public override VolumeControl.ActiveOutput active_output + { + get + { + return _active_output; + } + } + + /* Volume operations */ + private static PulseAudio.Volume double_to_volume (double vol) + { + double tmp = (double)(PulseAudio.Volume.NORM - PulseAudio.Volume.MUTED) * vol; + return (PulseAudio.Volume)tmp + PulseAudio.Volume.MUTED; + } + + private static double volume_to_double (PulseAudio.Volume vol) + { + double tmp = (double)(vol - PulseAudio.Volume.MUTED); + return tmp / (double)(PulseAudio.Volume.NORM - PulseAudio.Volume.MUTED); + } + + private void set_volume_success_cb (Context c, int success) + { + if ((bool)success) + this.notify_property("volume"); + } + + private void sink_info_set_volume_cb (Context c, SinkInfo? i, int eol) + { + if (i == null) + return; + + unowned CVolume cvol = i.volume; + cvol.scale (double_to_volume (_volume.volume)); + c.set_sink_volume_by_index (i.index, cvol, set_volume_success_cb); + } + + private void server_info_cb_for_set_volume (Context c, ServerInfo? i) + { + if (i == null) + { + warning ("Could not get PulseAudio server info"); + return; + } + + context.get_sink_info_by_name (i.default_sink_name, sink_info_set_volume_cb); + } + + private async void set_volume_active_role () + { + string active_role_objp = _objp_role_alert; + + if (_active_sink_input != -1 && _active_sink_input in _sink_input_list) + active_role_objp = _sink_input_hash.get (_active_sink_input); + + try { + double vol = _volume.volume; + var builder = new VariantBuilder (new VariantType ("a(uu)")); + builder.add ("(uu)", 0, double_to_volume (vol)); + Variant volume = builder.end (); + + /* Increase the signal counter so we can handle the callback */ + lock (_pa_volume_sig_count) { + _pa_volume_sig_count++; + } + + yield _pconn.call ("org.PulseAudio.Ext.StreamRestore1.RestoreEntry", + active_role_objp, "org.freedesktop.DBus.Properties", "Set", + new Variant ("(ssv)", "org.PulseAudio.Ext.StreamRestore1.RestoreEntry", "Volume", volume), + null, DBusCallFlags.NONE, -1); + + debug ("Set volume to %f on path %s", vol, active_role_objp); + } catch (GLib.Error e) { + lock (_pa_volume_sig_count) { + _pa_volume_sig_count--; + } + warning ("unable to set volume for stream obj path %s (%s)", active_role_objp, e.message); + } + } + + void set_mic_volume_success_cb (Context c, int success) + { + if ((bool)success) + this.notify_property ("mic-volume"); + } + + void set_mic_volume_get_server_info_cb (PulseAudio.Context c, PulseAudio.ServerInfo? i) { + if (i != null) { + unowned CVolume cvol = CVolume (); + cvol = vol_set (cvol, 1, double_to_volume (_mic_volume)); + c.set_source_volume_by_name (i.default_source_name, cvol, set_mic_volume_success_cb); + } + } + + public override VolumeControl.Volume volume { + get { + return _volume; + } + set { + var volume_changed = (value.volume != _volume.volume); + debug("Setting volume to %f for profile %d because %d", value.volume, _active_sink_input, value.reason); + + _volume = value; + + /* Make sure we're connected to Pulse and pulse didn't give us the change */ + if (context.get_state () == Context.State.READY && + _volume.reason != VolumeControl.VolumeReasons.PULSE_CHANGE && + volume_changed) + if (_pulse_use_stream_restore) + set_volume_active_role.begin (); + else + context.get_server_info (server_info_cb_for_set_volume); + + + if (volume.reason != VolumeControl.VolumeReasons.ACCOUNTS_SERVICE_SET + && volume_changed) { + start_local_volume_timer(); + } + + update_high_volume(); + } + } + + /** MAX VOLUME PROPERTY **/ + + private void init_max_volume() { + _settings.changed["normal-volume-decibels"].connect(() => update_max_volume()); + _settings.changed["amplified-volume-decibels"].connect(() => update_max_volume()); + _shared_settings.changed["allow-amplified-volume"].connect(() => update_max_volume()); + update_max_volume(); + } + private void update_max_volume () { + var new_max_volume = calculate_max_volume(); + if (max_volume != new_max_volume) { + debug("changing max_volume from %f to %f", this.max_volume, new_max_volume); + max_volume = calculate_max_volume(); + } + } + private double calculate_max_volume () { + unowned string decibel_key = _shared_settings.get_boolean("allow-amplified-volume") + ? "amplified-volume-decibels" + : "normal-volume-decibels"; + var volume_dB = _settings.get_double(decibel_key); + var volume_sw = PulseAudio.Volume.sw_from_dB (volume_dB); + return volume_to_double (volume_sw); + } + + /** HIGH VOLUME PROPERTY **/ + + private bool _warning_volume_enabled; + private double _warning_volume_norms; /* 1.0 == PA_VOLUME_NORM */ + private bool _high_volume = false; + public override bool ignore_high_volume { + get { + if (_ignore_warning_this_time) { + warning("Ignore"); + _ignore_warning_this_time = false; + return true; + } + return false; + } + set { } + } + public override bool high_volume { + get { return this._high_volume; } + private set { this._high_volume = value; } + } + public override bool below_warning_volume { + get { return this._volume.volume < this._warning_volume_norms; } + private set { } + } + private void init_high_volume() { + _settings.changed["warning-volume-enabled"].connect(() => update_high_volume_cache()); + _settings.changed["warning-volume-decibels"].connect(() => update_high_volume_cache()); + update_high_volume_cache(); + } + private void update_high_volume_cache() { + var volume_dB = _settings.get_double ("warning-volume-decibels"); + var volume_sw = PulseAudio.Volume.sw_from_dB (volume_dB); + var volume_norms = volume_to_double (volume_sw); + _warning_volume_norms = volume_norms; + _warning_volume_enabled = _settings.get_boolean("warning-volume-enabled"); + debug("updating high volume cache... enabled %d dB %f sw %lu norm %f", (int)_warning_volume_enabled, volume_dB, volume_sw, volume_norms); + update_high_volume(); + } + private void update_high_volume() { + var new_high_volume = calculate_high_volume(); + if (high_volume != new_high_volume) { + debug("changing high_volume from %d to %d", (int)high_volume, (int)new_high_volume); + high_volume = new_high_volume; + } + } + private bool calculate_high_volume() { + return calculate_high_volume_from_volume(_volume.volume); + } + private bool calculate_high_volume_from_volume(double volume) { + return _active_port_headphone + && _warning_volume_enabled + && volume > _warning_volume_norms + && (stream == "multimedia"); + } + + public override void clamp_to_high_volume() { + if (_high_volume && (_volume.volume > _warning_volume_norms)) { + var vol = new VolumeControl.Volume(); + vol.volume = _volume.volume.clamp(0, _warning_volume_norms); + vol.reason = _volume.reason; + debug("Clamping from %f down to %f", _volume.volume, vol.volume); + volume = vol; + } + } + + public override void set_warning_volume() { + var vol = new VolumeControl.Volume(); + vol.volume = _warning_volume_norms; + vol.reason = _volume.reason; + debug("Setting warning level volume from %f down to %f", _volume.volume, vol.volume); + volume = vol; + } + + /** HIGH VOLUME APPROVED PROPERTY **/ + + private bool _high_volume_approved = false; + private uint _high_volume_approved_timer = 0; + private int64 _high_volume_approved_at = 0; + private int64 _high_volume_approved_ttl_usec = 0; + public override bool high_volume_approved { + get { return this._high_volume_approved; } + private set { this._high_volume_approved = value; } + } + private void init_high_volume_approved() { + _settings.changed["warning-volume-confirmation-ttl"].connect(() => update_high_volume_approved_cache()); + update_high_volume_approved_cache(); + } + private void update_high_volume_approved_cache() { + _high_volume_approved_ttl_usec = _settings.get_int("warning-volume-confirmation-ttl"); + _high_volume_approved_ttl_usec *= 1000000; + + update_high_volume_approved(); + update_high_volume_approved_timer(); + } + private void update_high_volume_approved_timer() { + stop_high_volume_approved_timer(); + if (_high_volume_approved_at != 0) { + int64 expires_at = _high_volume_approved_at + _high_volume_approved_ttl_usec; + int64 now = GLib.get_monotonic_time(); + if (expires_at > now) { + var seconds_left = 1 + ((expires_at - now) / 1000000); + _high_volume_approved_timer = Timeout.add_seconds((uint)seconds_left, on_high_volume_approved_timer); + } + } + } + private void stop_high_volume_approved_timer() { + if (_high_volume_approved_timer != 0) { + Source.remove (_high_volume_approved_timer); + _high_volume_approved_timer = 0; + } + } + private bool on_high_volume_approved_timer() { + _high_volume_approved_timer = 0; + update_high_volume_approved(); + return false; /* Source.REMOVE */ + } + private void update_high_volume_approved() { + var new_high_volume_approved = calculate_high_volume_approved(); + if (high_volume_approved != new_high_volume_approved) { + debug("changing high_volume_approved from %d to %d", (int)high_volume_approved, (int)new_high_volume_approved); + high_volume_approved = new_high_volume_approved; + } + } + private bool calculate_high_volume_approved() { + int64 now = GLib.get_monotonic_time(); + return (_high_volume_approved_at != 0) + && (_high_volume_approved_at + _high_volume_approved_ttl_usec >= now); + } + public override void approve_high_volume() { + _high_volume_approved_at = GLib.get_monotonic_time(); + update_high_volume_approved(); + update_high_volume_approved_timer(); + } + + + /** MIC VOLUME PROPERTY */ + + public override double mic_volume { + get { + return _mic_volume; + } + set { + return_if_fail (context.get_state () == Context.State.READY); + + _mic_volume = value; + + context.get_server_info (set_mic_volume_get_server_info_cb); + } + } + + /* PulseAudio Dbus (Stream Restore) logic */ + private void reconnect_pulse_dbus () + { + unowned string pulse_dbus_server_env = Environment.get_variable ("PULSE_DBUS_SERVER"); + string address; + + /* In case of a reconnect */ + _pulse_use_stream_restore = false; + _pa_volume_sig_count = 0; + + if (pulse_dbus_server_env != null) { + address = pulse_dbus_server_env; + } else { + DBusConnection conn; + Variant props; + + try { + conn = Bus.get_sync (BusType.SESSION); + } catch (GLib.IOError e) { + warning ("unable to get the dbus session bus: %s", e.message); + return; + } + + try { + var props_variant = conn.call_sync ("org.PulseAudio1", + "/org/pulseaudio/server_lookup1", "org.freedesktop.DBus.Properties", + "Get", new Variant ("(ss)", "org.PulseAudio.ServerLookup1", "Address"), + null, DBusCallFlags.NONE, -1); + props_variant.get ("(v)", out props); + address = props.get_string (); + } catch (GLib.Error e) { + warning ("unable to get pulse unix socket: %s", e.message); + return; + } + } + + debug ("PulseAudio dbus unix socket: %s", address); + try { + _pconn = new DBusConnection.for_address_sync (address, DBusConnectionFlags.AUTHENTICATION_CLIENT); + } catch (GLib.Error e) { + /* If it fails, it means the dbus pulse extension is not available */ + return; + } + + /* For pulse dbus related events */ + _pconn.add_filter (pulse_dbus_filter); + + /* Check if the 4 currently supported media roles are already available in StreamRestore + * Roles: multimedia, alert, alarm and phone */ + _objp_role_multimedia = stream_restore_get_object_path ("sink-input-by-media-role:multimedia"); + _objp_role_alert = stream_restore_get_object_path ("sink-input-by-media-role:alert"); + _objp_role_alarm = stream_restore_get_object_path ("sink-input-by-media-role:alarm"); + _objp_role_phone = stream_restore_get_object_path ("sink-input-by-media-role:phone"); + + /* Only use stream restore if every used role is available */ + if (_objp_role_multimedia != null && _objp_role_alert != null && _objp_role_alarm != null && _objp_role_phone != null) { + debug ("Using PulseAudio DBUS Stream Restore module"); + /* Restore volume and update default entry */ + update_active_sink_input.begin (-1); + _pulse_use_stream_restore = true; + } + } + + private string? stream_restore_get_object_path (string name) { + string? objp = null; + try { + Variant props_variant = _pconn.call_sync ("org.PulseAudio.Ext.StreamRestore1", + "/org/pulseaudio/stream_restore1", "org.PulseAudio.Ext.StreamRestore1", + "GetEntryByName", new Variant ("(s)", name), null, DBusCallFlags.NONE, -1); + /* Workaround for older versions of vala that don't provide get_objv */ + VariantIter iter = props_variant.iterator (); + iter.next ("o", &objp); + debug ("Found obj path %s for restore data named %s\n", objp, name); + } catch (GLib.Error e) { + warning ("unable to find stream restore data for: %s", name); + } + return objp; + } + + /* AccountsService operations */ + private void accountsservice_props_changed_cb (DBusProxy proxy, Variant changed_properties, string[]? invalidated_properties) + { + Variant volume_variant = changed_properties.lookup_value ("Volume", new VariantType ("d")); + if (volume_variant != null) { + var volume = volume_variant.get_double (); + if (volume >= 0) { + _account_service_volume = volume; + // we need to wait for this to settle. + start_account_service_volume_timer(); + } + } + + Variant mute_variant = changed_properties.lookup_value ("Muted", new VariantType ("b")); + if (mute_variant != null) { + var mute = mute_variant.get_boolean (); + set_mute_internal (mute); + } + } + + private async void setup_user_proxy (string? username_in = null) + { + var username = username_in; + _user_proxy = null; + + // Look up currently selected greeter user, if asked + if (username == null) { + try { + username = yield _greeter_proxy.get_active_entry (); + if (username == "" || username == null) + return; + } catch (GLib.Error e) { + warning ("unable to find Accounts path for user %s: %s", username, e.message); + return; + } + } + + // Get master AccountsService object + DBusProxy accounts_proxy; + try { + accounts_proxy = yield DBusProxy.create_for_bus (BusType.SYSTEM, DBusProxyFlags.DO_NOT_LOAD_PROPERTIES | DBusProxyFlags.DO_NOT_CONNECT_SIGNALS, null, "org.freedesktop.Accounts", "/org/freedesktop/Accounts", "org.freedesktop.Accounts"); + } catch (GLib.Error e) { + warning ("unable to get greeter proxy: %s", e.message); + return; + } + + // Find user's AccountsService object + try { + var user_path_variant = yield accounts_proxy.call ("FindUserByName", new Variant ("(s)", username), DBusCallFlags.NONE, -1); + string user_path; + user_path_variant.get ("(o)", out user_path); + _user_proxy = yield DBusProxy.create_for_bus (BusType.SYSTEM, DBusProxyFlags.GET_INVALIDATED_PROPERTIES, null, "org.freedesktop.Accounts", user_path, "com.ubuntu.AccountsService.Sound"); + } catch (GLib.Error e) { + warning ("unable to find Accounts path for user %s: %s", username, e.message); + return; + } + + // Get current values and listen for changes + _user_proxy.g_properties_changed.connect (accountsservice_props_changed_cb); + try { + var props_variant = yield _user_proxy.get_connection ().call (_user_proxy.get_name (), _user_proxy.get_object_path (), "org.freedesktop.DBus.Properties", "GetAll", new Variant ("(s)", _user_proxy.get_interface_name ()), null, DBusCallFlags.NONE, -1); + Variant props; + props_variant.get ("(@a{sv})", out props); + accountsservice_props_changed_cb(_user_proxy, props, null); + } catch (GLib.Error e) { + debug("Unable to get properties for user %s at first try: %s", username, e.message); + } + } + + private void greeter_user_changed (string username) + { + setup_user_proxy.begin (username); + } + + private async void setup_accountsservice () + { + if (Environment.get_variable ("XDG_SESSION_CLASS") == "greeter") { + try { + _greeter_proxy = yield Bus.get_proxy (BusType.SESSION, "com.canonical.UnityGreeter", "/list"); + } catch (GLib.Error e) { + warning ("unable to get greeter proxy: %s", e.message); + return; + } + _greeter_proxy.entry_selected.connect (greeter_user_changed); + yield setup_user_proxy (); + } else { + // We are in a user session. We just need our own proxy + var username = Environment.get_variable ("USER"); + if (username != "" && username != null) { + yield setup_user_proxy (username); + } + } + } + + private async void sync_mute_to_accountsservice (bool mute) + { + if (_user_proxy == null) + return; + + _mute_cancellable.cancel (); + _mute_cancellable.reset (); + + try { + yield _user_proxy.get_connection ().call (_user_proxy.get_name (), _user_proxy.get_object_path (), "org.freedesktop.DBus.Properties", "Set", new Variant ("(ssv)", _user_proxy.get_interface_name (), "Muted", new Variant ("b", mute)), null, DBusCallFlags.NONE, -1, _mute_cancellable); + } catch (GLib.Error e) { + warning ("unable to sync mute to AccountsService: %s", e.message); + } + } + + private async void sync_volume_to_accountsservice (VolumeControl.Volume volume) + { + if (_user_proxy == null) + return; + + _volume_cancellable.cancel (); + _volume_cancellable.reset (); + + try { + yield _user_proxy.get_connection ().call (_user_proxy.get_name (), _user_proxy.get_object_path (), "org.freedesktop.DBus.Properties", "Set", new Variant ("(ssv)", _user_proxy.get_interface_name (), "Volume", new Variant ("d", volume.volume)), null, DBusCallFlags.NONE, -1, _volume_cancellable); + } catch (GLib.Error e) { + warning ("unable to sync volume to AccountsService: %s", e.message); + } + } + + private void start_local_volume_timer() + { + // perform a slow sync with the accounts service. max at 1 per second. + + // stop the AS update timer, as since we're going to be setting the volume. + stop_account_service_volume_timer(); + + if (_local_volume_timer == 0) { + sync_volume_to_accountsservice.begin (_volume); + _local_volume_timer = Timeout.add_seconds (1, local_volume_changed_timeout); + } else { + _send_next_local_volume = true; + } + } + + private void stop_local_volume_timer() + { + if (_local_volume_timer != 0) { + Source.remove (_local_volume_timer); + _local_volume_timer = 0; + } + } + + bool local_volume_changed_timeout() + { + _local_volume_timer = 0; + if (_send_next_local_volume) { + _send_next_local_volume = false; + start_local_volume_timer (); + } + return false; // G_SOURCE_REMOVE + } + + private void start_account_service_volume_timer() + { + if (_accountservice_volume_timer == 0) { + // If we haven't been messing with local volume recently, apply immediately. + if (_local_volume_timer == 0) { + var vol = new VolumeControl.Volume(); + vol.volume = _account_service_volume; + vol.reason = VolumeControl.VolumeReasons.ACCOUNTS_SERVICE_SET; + this.volume = vol; + return; + } + // Else check again in another second if needed. + // (if AS is throwing us lots of notifications, we update at most once a second) + _accountservice_volume_timer = Timeout.add_seconds (1, accountservice_volume_changed_timeout); + } + } + + private void stop_account_service_volume_timer() + { + if (_accountservice_volume_timer != 0) { + Source.remove (_accountservice_volume_timer); + _accountservice_volume_timer = 0; + } + } + + bool accountservice_volume_changed_timeout () + { + _accountservice_volume_timer = 0; + start_account_service_volume_timer (); + return false; // G_SOURCE_REMOVE + } +} |