Merge lp:~rsalveti/indicator-sound/adding-support-for-sound-per-roles into lp:indicator-sound/14.10

[Ricardo Salveti]

Adding support to change volumes per active audio role.

Adding support to change volumes per active audio role.

Some comments regarding the changeset:
* Ideally this would also be the default code path for the Desktop, but for that to happen we first need to revisit every media role used, and force one by default on pulse itself. As this requires some intrusive changes, and we're past over feature freeze for Utopic, this needs to be discussed again once the next cycle starts, as this would also be the desired behaviour when looking from the convergence point of view.
* The additional pulseaudio dbus module is not loaded by default on the desktop, but is on touch (touch got a different pulseaudio config). So in order to test this you need to make sure to load the dbus module (check https://code.launchpad.net/~rsalveti/ubuntu-touch-session/changing-config-allow-volume-per-role/+merge/235563).
* To avoid clashes with the desktop mode (that still wants to change the master volume), I decided to create a flag that basically controls which behaviour to use. If it finds the dbus module, and if it finds all the required roles in the stream/restore database, then the default behaviour is changed for the indicator to react and control volume per audio roles. If the dbus module is not available, or the user got one missing role, it gets back to work controlling only master.
* When testing with Ubuntu touch, make sure you're also using silo 18 for the other dependencies (https://launchpad.net/~ci-train-ppa-service/+archive/ubuntu/landing-018).
* We still need to see what should be exported for accountservice, as atm the volume from the current active role will propagate to accountservice. This is not yet an issue for Touch, but once we get back to have a separated greeter, we need to revisit this.
* I had to manually call the dbus methods because I can't easily abstract them with Vala, because not everything required is implemented from the other side. This pulse dbus module would need to be improved, but something to work with upstream later on.
* I can see the design also requiring us to notify the user about which volume role is active and changed when the user press volume up/down. Not yet sure how we can abstract that, but we can sync and see the details later on.
* For this MR to build it also needs latest pulseaudio that is available in the same landing silo (this is required because the vapi files from pulse were not exporting everything needed). Didn't yet bump debian/control pulseaudio build-dep because I first want to test everything to avoid extra version bump in pulse.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:448
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/142/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-armhf-ci/9/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-sound-ci/142/rebuild

review: Needs Fixing (continuous-integration)

[lp:~rsalveti/indicator-sound/adding-support-for-sound-per-roles]

449. By Ricardo Salveti on 2014-09-23

Adding TODO entry

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:449
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/143/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-amd64-ci/10/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-armhf-ci/10/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-sound-ci/143/rebuild

review: Needs Fixing (continuous-integration)

[lp:~rsalveti/indicator-sound/adding-support-for-sound-per-roles]

450. By Ricardo Salveti on 2014-09-25

volume-role: making sure we reflect changes done by pulse (via signals)

451. By Ricardo Salveti on 2014-09-25

volume-role: removing TODO

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:451
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/144/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-armhf-ci/11/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-sound-ci/144/rebuild

review: Needs Fixing (continuous-integration)

[Ted Gould (ted)]

I think that adding a dep on gee-1.0 will need to be added to the packaging as well. Some clean up and other changes included inline.

review: Needs Fixing

[Ricardo Salveti (rsalveti)]

libgee-dev is already part of debian/control (as build-deps), so that should be fine.

[Ricardo Salveti (rsalveti)]

Reply in-line, will push the changes in a few.

[lp:~rsalveti/indicator-sound/adding-support-for-sound-per-roles]

452. By Ricardo Salveti on 2014-09-29

Review changes

[Ricardo Salveti (rsalveti)]

I decided to keep set_volume_active_role as sync, to avoid a huge number of callbacks and signals when the user is scrolling the volume indicator bar.

I believe the ideal fix here is changing the indicator (or probably unity8 in this case), to create steps that could be used when setting up the volume (to avoid a huge number of events, and we also don't care if the user wants to change the sound 0.10% higher or lower, we should probably instead just support 5% or 10% volume changes as steps). Want me to open a bug against Unity8 for that?

Added the following comment to the function:
/* This call can be async once we are sure we are not allowing multiple set volume calls
 * in sequence (with a minimal volume delta, not with steps), as this can cause issues
 * when handling the volume updated signal from PulseAudio (_volume can get set before
 * the signal from a previous set gets handled at pulse_dbus_filter, generating an extra
 * volume_updated signal) */
 private void set_volume_active_role ()

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:452
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/146/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-armhf-ci/13/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-sound-ci/146/rebuild

review: Needs Fixing (continuous-integration)

[Ted Gould (ted)]

What's happening isn't that we're getting a value for every little change, we're getting periodic updates, but QML blocks on the call. So we end up creating a "jumpy" slider if we take too long to respond to it. This was happening with the AS support earlier. So it needs to be async not because we're getting every little change but more because we need to respond to the message as fast as possible to avoid the UI from blocking. (which it shouldn't, but apparently that's a difficult problem to tackle on the QML side)

[Ricardo Salveti (rsalveti)]

As there's no way to know from pulse who triggered the volume changed signal, making it async makes it harder to track down if the signal should or shouldn't be handled by our code (in order to avoid an extra round of signals).

The UI feedback with async is indeed a bit better, but didn't have any issue when using it with sync (still fine from a user perspective).

We can try suggesting a different way to track the volume changes, but as we talked over IRC, that would be ugly and probably not so efficient.

I still think the right way is to make unity8 to only give us step changes, and not minimal ones (so we can also reduce the amount of cpu/messages/signals used).

[Ted Gould (ted)]

So, the problem is that we keep discussing this as tracking the changes and whether or not they're coming from indicator-sound or from somewhere else. That makes the problem hard as we don't know that information. But instead I think we should look at it as trying to determine which values we care about and which data we can discard. If we send a value to PA we don't care about any values that it sends back until we get the echo about our setting back because we know that they're all old values at that point.

For the solution we can make a FIFO of values that we send to PA, and then when we get signaled about values we pop an item off of the FIFO when it matches. If the FIFO is not empty, we ignore the value coming back from PA. If the FIFO is empty we assume someone else changed it and we care about the value.

This handles the case of someone else setting the value and us not, as we'll not have any entries in the FIFO and respond immediately. If we're competing with someone we know that there'll be a bunch of races, so we remain stable until the last value is sent, whether it be ours (and that just empties the FIFO) or there's that comes when the FIFO is empty. For most cases it'll just result in an entry being put into the FIFO and then being removed on the echo so it's not very expensive.

[lp:~rsalveti/indicator-sound/adding-support-for-sound-per-roles]

453. By Ricardo Salveti on 2014-10-01

Using a signal counter so we can set the volume asynchronously

[Ricardo Salveti (rsalveti)]

We indeed don't need to care about every single signal we get (specially when we're still waiting for replies from pulse), so we can coordinate that with a simple counter.

We could think about handling this in a list, but I think a simple counter is more than enough.

I decided to just assume that if the counter is not 0, we shouldn't need to care if an external entity ended up changing the volume, as that is not necessarily relevant anyway (due this sort of races that we can't avoid). Let me know if that is enough for you as well.

[Ricardo Salveti (rsalveti)]

Tested with the other packages and the UI is indeed a bit faster, and everything else working as expected.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:453
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/147/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-amd64-ci/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-sound-utopic-armhf-ci/14/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-sound-ci/147/rebuild

review: Needs Fixing (continuous-integration)

[Ted Gould (ted)]

Cool, I think that works for now. It doesn't handle the case of someone constantly changing the volume, but that should never really happen -- or the device needs to be restarted anyway. Volume is the least of our problems ;-)

review: Approve

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-03-04 21:40:28 +0000
+++ src/CMakeLists.txt	2014-10-01 03:41:32 +0000
@@ -21,6 +21,7 @@
     accounts-service
   PACKAGES
     config
+    gee-1.0
     gio-2.0
     gio-unix-2.0
     libxml-2.0

=== modified file 'src/volume-control.vala'
--- src/volume-control.vala	2014-04-18 17:41:44 +0000
+++ src/volume-control.vala	2014-10-01 03:41:32 +0000
@@ -19,6 +19,7 @@
  */
 
 using PulseAudio;
+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);
@@ -43,6 +44,21 @@
 	private double _volume = 0.0;
 	private double _mic_volume = 0.0;
 
+	/* 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 uint32 _active_sink_input = -1;
+	private string[] _valid_roles = {"multimedia", "alert", "alarm", "phone"};
+	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;
@@ -92,6 +108,26 @@
 				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;
@@ -129,7 +165,8 @@
 			this.notify_property ("is-playing");
 		}
 
-		if (_volume != volume_to_double (i.volume.values[0]))
+		if (_pulse_use_stream_restore == false &&
+				_volume != volume_to_double (i.volume.values[0]))
 		{
 			_volume = volume_to_double (i.volume.values[0]);
 			volume_changed (_volume);
@@ -170,6 +207,153 @@
 		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, volume = 0;
+					VariantIter iter = varray.iterator ();
+					iter.next ("(uu)", &type, &volume);
+					/* 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);
+					if (volume != cvolume) {
+						/* Someone else changed the volume for this role, reflect on the indicator */
+						_volume = volume_to_double (volume);
+						volume_changed (_volume);
+					}
+				}
+			}
+		}
+
+		return message;
+	}
+
+	private async void update_active_sink_input (uint32 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);
+
+				_volume = volume_to_double (volume);
+				volume_changed (_volume);
+			} 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 (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 (_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)
@@ -184,9 +368,16 @@
 	{
 		switch (c.get_state ()) {
 			case Context.State.READY:
-				c.subscribe (PulseAudio.Context.SubscriptionMask.SINK |
-							 PulseAudio.Context.SubscriptionMask.SOURCE |
-							 PulseAudio.Context.SubscriptionMask.SOURCE_OUTPUT);
+				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 ();
@@ -226,6 +417,8 @@
 		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);
 
@@ -325,13 +518,47 @@
 		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 {
+			var builder = new VariantBuilder (new VariantType ("a(uu)"));
+			builder.add ("(uu)", 0, double_to_volume (_volume));
+			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);
+
+			volume_changed (_volume);
+		} 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);
+		}
+	}
+
 	bool set_volume_internal (double volume)
 	{
 		return_val_if_fail (context.get_state () == Context.State.READY, false);
 
 		if (_volume != volume) {
 			_volume = volume;
-			context.get_server_info (server_info_cb_for_set_volume);
+			if (_pulse_use_stream_restore)
+				set_volume_active_role.begin ();
+			else
+				context.get_server_info (server_info_cb_for_set_volume);
 			return true;
 		} else {
 			return false;
@@ -377,6 +604,85 @@
 		return _mic_volume;
 	}
 
+	/* 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;
+			}
+		}
+
+		stdout.printf ("PulseAudio dbus unix socket: %s\n", 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) {
+			stdout.printf ("Using PulseAudio DBUS Stream Restore module\n");
+			/* 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);
+			stdout.printf ("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)
 	{