Merge lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service into lp:indicator-sound/15.10

[Xavi Garcia]

This branch sets the last running player using accounts service instead of gsettings.
It also includes a new class AccountsServiceAccess, to centralize all accesses to account service properties.

This branch sets the last running player using accounts service instead of gsettings.
It also includes a new class AccountsServiceAccess, to centralize all accesses to account service properties.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:532
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/312/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/87
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/88
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/88/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service]

533. By Xavi Garcia on 2016-02-23

Fixed integration test

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:533
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/313/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/88
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/89
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/89/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service]

534. By Xavi Garcia on 2016-02-24

Removed log statement

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:534
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/314/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/89
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/90
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/90/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service]

535. By Xavi Garcia on 2016-02-29

Accounts service notification fix

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:535
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/315/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/90
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/91
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/91/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Charles Kerr (charlesk)]

A lot of this looks great. I like the improved tests and the refactoring of AccountsServices into its own class.

Several questions inline though, with a couple of serious issues eg the way GCancellable is used and my questions about the use of last_player_added in SoundMenu.

review: Needs Information

[lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service]

536. By Xavi Garcia on 2016-03-02

Changed following Charles's suggestions

[Xavi Garcia (xavi-garcia-mena)]

Thanks for the review, Charles!

I assumed the existing code had passed already a code review in deep and did not refactored it. Big mistake.

I've fixed almost everything you commented. I think there's only one point remaining... please take a look at the inline comments.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:536
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/317/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/92
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/93
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/93/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Charles Kerr (charlesk)]

Ah, I didn't realize that GCancellable issue was a carryover from old code. I'm glad it's fixed.

One last suggestion, I do think AccountsServiceAccess should have a private GCancellable member that gets passed to all these bus calls + a call to cancellable.cancel() in the AccountsServiceAccess destructor. This won't affect general use since the object's lifespan continues for the life of the process, but it's useful to prevent issues when shutting down the bus in unit tests.

Nice fix wrt the cascading signal emission.

[lp:~xavi-garcia-mena/indicator-sound/last-running-player-accounts-service]

537. By Xavi Garcia on 2016-03-03

Added Cancellable to AccountsServiceAccess

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:537
http://jenkins.qa.ubuntu.com/job/indicator-sound-ci/318/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-amd64-ci/93
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/94
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-wily-armhf-ci/94/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Charles Kerr (charlesk)]

Good stuff.

I won't block this patch further because this is a preexisting condition, but if you want to finish making AccountsServiceAccess' DBus calls cancellable there are still a handful of noncancellable calls:

accounts-service-access.vala:133: yield DBusProxy.create_for_bus()
accounts-service-access.vala:141: yield accounts_proxy.call()
accounts-service-access.vala:145: yield DBusProxy.create_for_bus()
accounts-service-access.vala:158: yield _user_proxy.get_connection ().call()
accounts-service-access.vala:181: yield Bus.get_proxy()

In (I think) all of these cases the cancellable is passed in as the invisible last argument, where vala has a C++-like default argument which is null.

review: Approve

=== modified file 'data/com.canonical.indicator.sound.gschema.xml'
--- data/com.canonical.indicator.sound.gschema.xml	2016-02-10 13:08:49 +0000
+++ data/com.canonical.indicator.sound.gschema.xml	2016-03-03 08:59:58 +0000
@@ -59,10 +59,10 @@
       <description>
         How long to remember a user's approval of the confirmation dialog discussed in the
         description of 'warning-volume-enabled'.
-        
+
         The default value (72,000 seconds) corresponds to the 20 hours suggested by
         EU standard EN 60950-1/Al2: “The acknowledgement does not need to be repeated
-        more than once every 20 h of cumulative listening time.”	
+        more than once every 20 h of cumulative listening time.”
       </description>
     </key>
     <key name="warning-volume-decibels" type="d">
@@ -102,16 +102,5 @@
       </description>
     </key>
 
-    <key name="last-running-player" type="s">
-      <default>""</default>
-      <summary>Stores which was the last running music player.</summary>
-      <description>
-        To make the last running player persistent and be able to set its playback controls
-        we store which was the last player running id.
-
-        The default value ("") corresponds to no player.
-      </description>
-    </key>
-
   </schema>
 </schemalist>

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-02-12 19:36:10 +0000
+++ src/CMakeLists.txt	2016-03-03 08:59:58 +0000
@@ -69,29 +69,37 @@
     media-player-list
     mpris2-interfaces
     accounts-service-user
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   options.vala
   DEPENDS
     volume-control
     volume-control-pulse
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   options-gsettings.vala
   DEPENDS
     options
-      volume-control-pulse
+    volume-control-pulse
     volume-control
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   volume-control.vala
   DEPENDS
     options
-      volume-control-pulse
+    volume-control-pulse
+    accounts-service-access
+)
+vala_add(indicator-sound-service
+  accounts-service-access.vala
 )
 vala_add(indicator-sound-service
   volume-control-pulse.vala
   DEPENDS
+    accounts-service-access
     options
     volume-control
 )
@@ -99,20 +107,22 @@
   volume-warning.vala
   DEPENDS
     options
-      volume-control-pulse
+    volume-control-pulse
     volume-control
     warn-notification
-      notification
+    notification
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   volume-warning-pulse.vala
   DEPENDS
     volume-warning
-      options
-        volume-control-pulse
-      volume-control
-      warn-notification
-        notification
+    options
+    volume-control-pulse
+    volume-control
+    warn-notification
+    notification
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   media-player.vala
@@ -161,8 +171,9 @@
   DEPENDS
     media-player
     volume-control
-      options
-          volume-control-pulse
+    options
+    volume-control-pulse
+    accounts-service-access
 )
 vala_add(indicator-sound-service
   accounts-service-user.vala

=== added file 'src/accounts-service-access.vala'
--- src/accounts-service-access.vala	1970-01-01 00:00:00 +0000
+++ src/accounts-service-access.vala	2016-03-03 08:59:58 +0000
@@ -0,0 +1,235 @@
+/*
+ * -*- Mode:Vala; indent-tabs-mode:t; tab-width:4; encoding:utf8 -*-
+ * Copyright 2016 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:
+ *      Xavi Garcia <[e-mail]>
+ */
+
+using PulseAudio;
+using Notify;
+using Gee;
+
+[DBus (name="com.canonical.UnityGreeter.List")]
+interface GreeterListInterfaceAccess : Object
+{
+	public abstract async string get_active_entry () throws IOError;
+	public signal void entry_selected (string entry_name);
+}
+
+public class AccountsServiceAccess : Object
+{
+	private DBusProxy _user_proxy;
+	private GreeterListInterfaceAccess _greeter_proxy;
+	private double _volume = 0.0;
+	private string _last_running_player = "";
+	private bool _mute = false;
+	private Cancellable _dbus_call_cancellable;
+
+	public AccountsServiceAccess ()
+	{
+		_dbus_call_cancellable = new Cancellable ();
+		setup_accountsservice.begin ();
+	}
+
+	~AccountsServiceAccess ()
+	{
+		_dbus_call_cancellable.cancel ();
+	}
+
+	public string last_running_player 
+	{ 
+		get 
+		{ 
+			return _last_running_player; 
+		} 
+		set 
+		{ 
+			sync_last_running_player_to_accountsservice.begin (value);
+		} 
+	}
+
+	public bool mute 
+	{ 
+		get 
+		{ 
+			return _mute; 
+		} 
+		set 
+		{ 
+			sync_mute_to_accountsservice.begin (value);
+		} 
+	}
+
+	public double volume 
+	{ 
+		get 
+		{ 
+			return _volume; 
+		} 
+		set 
+		{ 
+			sync_volume_to_accountsservice.begin (value);
+		} 
+	}
+
+	/* AccountsService operations */
+	private void accountsservice_props_changed_cb (DBusProxy proxy, Variant changed_properties, string[]? invalidated_properties)
+	{
+		Variant volume_variant = changed_properties.lookup_value ("Volume", VariantType.DOUBLE);
+		if (volume_variant != null) {
+			var volume = volume_variant.get_double ();
+			if (volume >= 0 && _volume != volume) {
+				_volume = volume;
+				this.notify_property("volume");
+			}
+		}
+
+		Variant mute_variant = changed_properties.lookup_value ("Muted", VariantType.BOOLEAN);
+		if (mute_variant != null) {
+			_mute = mute_variant.get_boolean ();
+			this.notify_property("mute");
+		}
+
+		Variant last_running_player_variant = changed_properties.lookup_value ("LastRunningPlayer", VariantType.STRING);
+		if (last_running_player_variant != null) {
+			_last_running_player = last_running_player_variant.get_string ();
+			this.notify_property("last-running-player");
+		}
+	}
+
+	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 == null ? "null" : 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;
+			if (user_path_variant.check_format_string ("(o)", true)) {
+				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");
+			} else {
+				warning ("Unable to find user name after calling FindUserByName. Expected type: %s and obtained %s", "(o)", user_path_variant.get_type_string () );
+				return;
+			}
+		} 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);
+			if (props_variant.check_format_string ("(@a{sv})", true)) {
+				Variant props;
+				props_variant.get ("(@a{sv})", out props);
+				accountsservice_props_changed_cb(_user_proxy, props, null);
+			} else {
+				warning ("Unable to get accounts service properties after calling GetAll. Expected type: %s and obtained %s", "(@a{sv})", props_variant.get_type_string () );
+				return;
+			}
+		} 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
+			unowned string username = Environment.get_variable ("USER");
+			if (username != null && username != "") {
+				yield setup_user_proxy (username);
+			}
+		}
+	}
+
+	private async void sync_last_running_player_to_accountsservice (string last_running_player)
+	{
+		if (_user_proxy == null)
+			return;
+
+		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 (), "LastRunningPlayer", new Variant ("s", last_running_player)), null, DBusCallFlags.NONE, -1, _dbus_call_cancellable);
+		} catch (GLib.Error e) {
+			warning ("unable to sync last running player %s to AccountsService: %s",last_running_player, e.message);
+		}
+		_last_running_player = last_running_player;
+	}
+
+	private async void sync_volume_to_accountsservice (double volume)
+	{
+		if (_user_proxy == null)
+			return;
+
+		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)), null, DBusCallFlags.NONE, -1, _dbus_call_cancellable);
+		} catch (GLib.Error e) {
+			warning ("unable to sync volume %f to AccountsService: %s", volume, e.message);
+		}
+	}
+
+	private async void sync_mute_to_accountsservice (bool mute)
+	{
+		if (_user_proxy == null)
+			return;
+
+		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, _dbus_call_cancellable);
+		} catch (GLib.Error e) {
+			warning ("unable to sync mute %s to AccountsService: %s", mute ? "true" : "false", e.message);
+		}
+	}
+}
+
+

=== modified file 'src/main.c'
--- src/main.c	2015-12-29 17:03:41 +0000
+++ src/main.c	2016-03-03 08:59:58 +0000
@@ -27,9 +27,9 @@
 static gboolean
 sigterm_handler (gpointer data)
 {
-	g_debug("Got SIGTERM");
-	g_main_loop_quit((GMainLoop *)data);
-	return G_SOURCE_REMOVE;
+    g_debug("Got SIGTERM");
+    g_main_loop_quit((GMainLoop *)data);
+    return G_SOURCE_REMOVE;
 }
 
 static void
@@ -37,8 +37,8 @@
              const gchar * name,
              gpointer user_data)
 {
-	g_warning("Name lost or unable to acquire bus: %s", name);
-	g_main_loop_quit((GMainLoop *)user_data);
+    g_warning("Name lost or unable to acquire bus: %s", name);
+    g_main_loop_quit((GMainLoop *)user_data);
 }
 
 static void
@@ -46,66 +46,68 @@
                 const gchar *name,
                 gpointer user_data)
 {
-	MediaPlayerList * playerlist = NULL;
-	IndicatorSoundOptions * options = NULL;
-	VolumeControlPulse * volume = NULL;
-	AccountsServiceUser * accounts = NULL;
-	VolumeWarning * warning = NULL;
-   
-
-	if (g_strcmp0("lightdm", g_get_user_name()) == 0) {
-		playerlist = MEDIA_PLAYER_LIST(media_player_list_greeter_new());
-	} else {
-		playerlist = MEDIA_PLAYER_LIST(media_player_list_mpris_new());
-		accounts = accounts_service_user_new();
-	}
-
-	pgloop = pa_glib_mainloop_new(NULL);
-	options = indicator_sound_options_gsettings_new();
-	volume = volume_control_pulse_new(options, pgloop);
-	warning = volume_warning_pulse_new(options, pgloop);
-
-	service = indicator_sound_service_new (playerlist, volume, accounts, options, warning);
-
-	g_clear_object(&playerlist);
-	g_clear_object(&options);
-	g_clear_object(&volume);
-	g_clear_object(&accounts);
-	g_clear_object(&warning);
+    MediaPlayerList * playerlist = NULL;
+    IndicatorSoundOptions * options = NULL;
+    VolumeControlPulse * volume = NULL;
+    AccountsServiceUser * accounts = NULL;
+    VolumeWarning * warning = NULL;
+    AccountsServiceAccess * accounts_service_access = NULL;
+
+
+    if (g_strcmp0("lightdm", g_get_user_name()) == 0) {
+        playerlist = MEDIA_PLAYER_LIST(media_player_list_greeter_new());
+    } else {
+        playerlist = MEDIA_PLAYER_LIST(media_player_list_mpris_new());
+        accounts = accounts_service_user_new();
+    }
+
+    pgloop = pa_glib_mainloop_new(NULL);
+    options = indicator_sound_options_gsettings_new();
+    accounts_service_access = accounts_service_access_new();
+    volume = volume_control_pulse_new(options, pgloop, accounts_service_access);
+    warning = volume_warning_pulse_new(options, pgloop);
+
+    service = indicator_sound_service_new (playerlist, volume, accounts, options, warning, accounts_service_access);
+
+    g_clear_object(&playerlist);
+    g_clear_object(&options);
+    g_clear_object(&volume);
+    g_clear_object(&accounts);
+    g_clear_object(&warning);
 }
 
 int
 main (int argc, char ** argv)
 {
-	GMainLoop * loop = NULL;
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
-	setlocale (LC_ALL, "");
-	bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
-
-	/* Build Mainloop */
-	loop = g_main_loop_new(NULL, FALSE);
-
-	g_unix_signal_add(SIGTERM, sigterm_handler, loop); 
-
-	/* Initialize libnotify */
-	notify_init ("indicator-sound");
-
-	g_bus_own_name(G_BUS_TYPE_SESSION,
-		"com.canonical.indicator.sound",
-		G_BUS_NAME_OWNER_FLAGS_NONE,
-		on_bus_acquired,
-		NULL, /* name acquired */
-		on_name_lost,
-		loop,
-		NULL);
-
-	g_main_loop_run(loop);
-
-	g_clear_object(&service);
-	g_clear_pointer(&pgloop, pa_glib_mainloop_free);
-
-	notify_uninit();
-
-	return 0;
+    GMainLoop * loop = NULL;
+    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+    setlocale (LC_ALL, "");
+    bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
+
+    /* Build Mainloop */
+    loop = g_main_loop_new(NULL, FALSE);
+
+    g_unix_signal_add(SIGTERM, sigterm_handler, loop);
+
+    /* Initialize libnotify */
+    notify_init ("indicator-sound");
+
+    g_bus_own_name(G_BUS_TYPE_SESSION,
+        "com.canonical.indicator.sound",
+        G_BUS_NAME_OWNER_FLAGS_NONE,
+        on_bus_acquired,
+        NULL, /* name acquired */
+        on_name_lost,
+        loop,
+        NULL);
+
+    g_main_loop_run(loop);
+
+    g_clear_object(&service);
+    g_clear_pointer(&pgloop, pa_glib_mainloop_free);
+
+    notify_uninit();
+
+    return 0;
 }
 

=== modified file 'src/service.vala'
--- src/service.vala	2016-02-10 13:08:49 +0000
+++ src/service.vala	2016-03-03 08:59:58 +0000
@@ -20,7 +20,9 @@
 public class IndicatorSound.Service: Object {
 	DBusConnection bus;
 
-	public Service (MediaPlayerList playerlist, VolumeControl volume, AccountsServiceUser? accounts, Options options, VolumeWarning volume_warning) {
+	public Service (MediaPlayerList playerlist, VolumeControl volume, AccountsServiceUser? accounts, Options options, VolumeWarning volume_warning, AccountsServiceAccess? accounts_service_access) {
+
+		_accounts_service_access = accounts_service_access;
 
 		try {
 			bus = Bus.get_sync(GLib.BusType.SESSION);
@@ -60,7 +62,6 @@
 					headphones = false;
 					break;
 			}
-			message("setting _volume_warning.headphones_active to %d", (int)headphones);
 			_volume_warning.headphones_active = headphones;
 
 			update_root_icon();
@@ -91,12 +92,11 @@
 		this.actions.add_action (this.create_high_volume_action ());
 		this.actions.add_action (this.create_volume_sync_action ());
 
-		string last_player = this.settings.get_string ("last-running-player");
 		this.menus = new HashTable<string, SoundMenu> (str_hash, str_equal);
-		this.menus.insert ("desktop_greeter", new SoundMenu (null, SoundMenu.DisplayFlags.SHOW_MUTE | SoundMenu.DisplayFlags.HIDE_PLAYERS | SoundMenu.DisplayFlags.GREETER_PLAYERS, last_player));
-		this.menus.insert ("phone_greeter", new SoundMenu (null, SoundMenu.DisplayFlags.SHOW_SILENT_MODE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS | SoundMenu.DisplayFlags.GREETER_PLAYERS, last_player));
-		this.menus.insert ("desktop", new SoundMenu ("indicator.desktop-settings", SoundMenu.DisplayFlags.SHOW_MUTE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS_PLAY_CONTROLS | SoundMenu.DisplayFlags.ADD_PLAY_CONTROL_INACTIVE_PLAYER, last_player));
-		this.menus.insert ("phone", new SoundMenu ("indicator.phone-settings", SoundMenu.DisplayFlags.SHOW_SILENT_MODE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS, last_player));
+		this.menus.insert ("desktop_greeter", new SoundMenu (null, SoundMenu.DisplayFlags.SHOW_MUTE | SoundMenu.DisplayFlags.HIDE_PLAYERS | SoundMenu.DisplayFlags.GREETER_PLAYERS));
+		this.menus.insert ("phone_greeter", new SoundMenu (null, SoundMenu.DisplayFlags.SHOW_SILENT_MODE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS | SoundMenu.DisplayFlags.GREETER_PLAYERS));
+		this.menus.insert ("desktop", new SoundMenu ("indicator.desktop-settings", SoundMenu.DisplayFlags.SHOW_MUTE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS_PLAY_CONTROLS | SoundMenu.DisplayFlags.ADD_PLAY_CONTROL_INACTIVE_PLAYER));
+		this.menus.insert ("phone", new SoundMenu ("indicator.phone-settings", SoundMenu.DisplayFlags.SHOW_SILENT_MODE | SoundMenu.DisplayFlags.HIDE_INACTIVE_PLAYERS));
 
 		this.menus.@foreach ( (profile, menu) => {
 			this.volume_control.bind_property ("active-mic", menu, "show-mic-volume", BindingFlags.SYNC_CREATE);
@@ -112,7 +112,13 @@
 
 		this.menus.@foreach ( (profile, menu) => {
 			menu.last_player_updated.connect ((player_id) => { 
-				this.settings.set_value ("last-running-player", player_id);
+				this._accounts_service_access.last_running_player = player_id;
+			});
+		});
+
+		this._accounts_service_access.notify["last-running-player"].connect(() => {
+			this.menus.@foreach ( (profile, menu) => {
+				menu.set_default_player (this._accounts_service_access.last_running_player);
 			});
 		});
 
@@ -199,6 +205,7 @@
 	private Options _options;
 	private VolumeWarning _volume_warning;
 	private IndicatorSound.InfoNotification _info_notification = new IndicatorSound.InfoNotification();
+	private AccountsServiceAccess _accounts_service_access;
 
 	const double volume_step_percentage = 0.06;
 

=== modified file 'src/sound-menu.vala'
--- src/sound-menu.vala	2016-02-10 13:08:49 +0000
+++ src/sound-menu.vala	2016-03-03 08:59:58 +0000
@@ -38,7 +38,7 @@
 
 	const string PLAYBACK_ITEM_TYPE = "com.canonical.unity.playback-item";
 
-	public SoundMenu (string? settings_action, DisplayFlags flags, string default_player_id) {
+	public SoundMenu (string? settings_action, DisplayFlags flags) {
 		/* A sound menu always has at least two sections: the volume section (this.volume_section)
 		 * at the start of the menu, and the settings section at the end. Between those two,
 		 * it has a dynamic amount of player sections, one for each registered player.
@@ -83,9 +83,6 @@
 		this.notify_handlers = new HashTable<MediaPlayer, ulong> (direct_hash, direct_equal);
 
 		this.greeter_players = (flags & DisplayFlags.GREETER_PLAYERS) != 0;
-
-		this.default_player = default_player_id;
-
 	}
 
 	~SoundMenu () {
@@ -95,6 +92,16 @@
 		}
 	}
 
+	public void set_default_player (string default_player_id) {
+		this.default_player = default_player_id;
+		foreach (var player_stored in notify_handlers.get_keys ()) {
+			int index = this.find_player_section(player_stored);
+			if (index != -1 && player_stored.id == this.default_player) {
+				add_player_playback_controls (player_stored, index, true);
+			}
+		}
+	}
+
 	DBusConnection? bus = null;
 	uint export_id = 0;
 
@@ -171,7 +178,17 @@
 			}
 		}
 	}
-
+ 
+	private void check_last_running_player () {
+		foreach (var player in notify_handlers.get_keys ()) {
+			if (player.is_running && number_of_running_players == 1) {
+				// this is the first or the last player running...
+				// store its id
+				this.last_player_updated (player.id);
+			}
+		}
+	}
+	
 	public void add_player (MediaPlayer player) {
 		if (this.notify_handlers.contains (player))
 			return;
@@ -198,11 +215,15 @@
 			// we need to update the rest of players, because we might have
 			// a non running player still showing the playback controls
 			update_all_players_play_section();
+
+			check_last_running_player ();
 		});
 		this.notify_handlers.insert (player, handler_id);
 
 		player.playlists_changed.connect (this.update_playlists);
 		player.playbackstatus_changed.connect (this.update_playbackstatus);
+
+		check_last_running_player ();
 	}
 
 	public void remove_player (MediaPlayer player) {
@@ -217,6 +238,8 @@
 
 		/* this'll drop our ref to it */
 		this.notify_handlers.remove (player);
+
+		check_last_running_player ();
 	}
 
 	public void update_volume_slider (VolumeControl.ActiveOutput active_output) {
@@ -368,16 +391,11 @@
 			this.menu.remove (index);
 	}
 
-	void update_player_section (MediaPlayer player, int index) {
+	void add_player_playback_controls (MediaPlayer player, int index, bool adding_default_player) {
 		var player_section = this.menu.get_item_link(index, Menu.LINK_SECTION) as Menu;
 
 		int play_control_index = find_player_playback_controls_section (player_section);
-		if (player.is_running && number_of_running_players == 1) {
-			// this is the first or the last player running...
-			// store its id
-			this.last_player_updated (player.id);
-		}
-		if (player.is_running || !this.hide_inactive_player_controls) {
+		if (player.is_running || !this.hide_inactive_player_controls || (number_of_running_players == 0 && adding_default_player) ) {
 			MenuItem playback_item = create_playback_menu_item (player);
 			if (play_control_index != -1) {
 				player_section.remove (PlayerSectionPosition.PLAYER_CONTROLS);	
@@ -389,7 +407,11 @@
 				player_section.remove (PlayerSectionPosition.PLAYLIST);
 				player_section.remove (PlayerSectionPosition.PLAYER_CONTROLS);	
 			}
-		}
+		}	
+	}
+
+	void update_player_section (MediaPlayer player, int index) {
+		add_player_playback_controls (player, index, false);
 	}
 
 	void update_playlists (MediaPlayer player) {

=== modified file 'src/volume-control-pulse.vala'
--- src/volume-control-pulse.vala	2016-01-07 05:28:51 +0000
+++ src/volume-control-pulse.vala	2016-03-03 08:59:58 +0000
@@ -22,13 +22,6 @@
 using Notify;
 using Gee;
 
-[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 VolumeControlPulse : VolumeControl
 {
 	private unowned PulseAudio.GLibMainLoop loop = null;
@@ -55,20 +48,17 @@
 	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 VolumeControl.ActiveOutput _active_output = VolumeControl.ActiveOutput.SPEAKERS;
+	private AccountsServiceAccess _accounts_service_access;
 
 	/** true when a microphone is active **/
 	public override bool active_mic { get; private set; default = false; }
 
-	public VolumeControlPulse (IndicatorSound.Options options, PulseAudio.GLibMainLoop loop)
+	public VolumeControlPulse (IndicatorSound.Options options, PulseAudio.GLibMainLoop loop, AccountsServiceAccess? accounts_service_access)
 	{
 		base(options);
 
@@ -77,11 +67,14 @@
 
 		this.loop = loop;
 
-		_mute_cancellable = new Cancellable ();
-		_volume_cancellable = new Cancellable ();
-
-		setup_accountsservice.begin ();
-
+		_accounts_service_access = accounts_service_access;
+		this._accounts_service_access.notify["volume"].connect(() => {
+			if (this._accounts_service_access.volume >= 0 && _account_service_volume != this._accounts_service_access.volume) {
+				_account_service_volume = this._accounts_service_access.volume;
+				// we need to wait for this to settle.
+				start_account_service_volume_timer();
+			}
+		});
 		this.reconnect_to_pulse ();
 	}
 
@@ -537,7 +530,7 @@
 	public override void set_mute (bool mute)
 	{
 		if (set_mute_internal (mute))
-			sync_mute_to_accountsservice.begin (mute);
+			_accounts_service_access.mute = mute;
 	}
 
 	public void toggle_mute ()
@@ -773,128 +766,6 @@
 	}
 
 	/* AccountsService operations */
-	private void accountsservice_props_changed_cb (DBusProxy proxy, Variant changed_properties, string[]? invalidated_properties)
-	{
-		Variant volume_variant = changed_properties.lookup_value ("Volume", VariantType.DOUBLE);
-		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", VariantType.BOOLEAN);
-		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
-			unowned string 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()
 	{
@@ -904,7 +775,7 @@
 		stop_account_service_volume_timer();
 
 		if (_local_volume_timer == 0) {
-			sync_volume_to_accountsservice.begin (_volume);
+			_accounts_service_access.volume = _volume.volume;
 			_local_volume_timer = Timeout.add_seconds (1, local_volume_changed_timeout);
 		} else {
 			_send_next_local_volume = true;

=== modified file 'tests/integration/indicator-sound-test-base.cpp'
--- tests/integration/indicator-sound-test-base.cpp	2016-01-29 11:16:34 +0000
+++ tests/integration/indicator-sound-test-base.cpp	2016-03-03 08:59:58 +0000
@@ -448,13 +448,37 @@
     return true;
 }
 
+QVariant IndicatorSoundTestBase::waitPropertyChanged(QSignalSpy *signalSpy, QString property)
+{
+    QVariant ret_val;
+    if (signalSpy)
+    {
+        signalSpy->wait();
+        if (signalSpy->count())
+        {
+            QList<QVariant> arguments = signalSpy->takeLast();
+            if (arguments.size() == 3 && static_cast<QMetaType::Type>(arguments.at(1).type()) == QMetaType::QVariantMap)
+            {
+                QMap<QString, QVariant> map = arguments.at(1).toMap();
+                QMap<QString, QVariant>::iterator iter = map.find(property);
+                if (iter != map.end())
+                {
+                    return iter.value();
+                }
+            }
+        }
+    }
+    return ret_val;
+}
 bool IndicatorSoundTestBase::waitVolumeChangedInIndicator()
 {
-    if (signal_spy_volume_changed_)
-    {
-        return signal_spy_volume_changed_->wait();
-    }
-    return false;
+    QVariant val = waitPropertyChanged(signal_spy_volume_changed_.get(), "Volume");
+    return !val.isNull();
+}
+
+QVariant IndicatorSoundTestBase::waitLastRunningPlayerChanged()
+{
+    return waitPropertyChanged(signal_spy_volume_changed_.get(), "LastRunningPlayer");
 }
 
 void IndicatorSoundTestBase::initializeAccountsInterface()

=== modified file 'tests/integration/indicator-sound-test-base.h'
--- tests/integration/indicator-sound-test-base.h	2016-01-29 11:16:34 +0000
+++ tests/integration/indicator-sound-test-base.h	2016-03-03 08:59:58 +0000
@@ -144,6 +144,10 @@
 
     float getVolumeValue(bool *isValid = nullptr);
 
+    static QVariant waitPropertyChanged(QSignalSpy * signalSpy, QString property);
+
+    QVariant waitLastRunningPlayerChanged();
+
     QtDBusTest::DBusTestRunner dbusTestRunner;
 
     QtDBusMock::DBusMock dbusMock;

=== modified file 'tests/integration/test-indicator.cpp'
--- tests/integration/test-indicator.cpp	2016-02-10 13:08:49 +0000
+++ tests/integration/test-indicator.cpp	2016-03-03 08:59:58 +0000
@@ -394,9 +394,7 @@
                         .string_attribute("x-canonical-type", "com.canonical.unity.media-player")
                     )
                     .item(mh::MenuItemMatcher()
-                        .string_attribute("x-canonical-previous-action","indicator.previous.testplayer1.desktop")
                         .string_attribute("x-canonical-play-action","indicator.play.testplayer1.desktop")
-                        .string_attribute("x-canonical-next-action","indicator.next.testplayer1.desktop")
                         .string_attribute("x-canonical-type","com.canonical.unity.playback-item")
                     )
                 )
@@ -925,16 +923,75 @@
                         .string_attribute("x-canonical-type", "com.canonical.unity.media-player")
                     )
                     .item(mh::MenuItemMatcher()
-                        .string_attribute("x-canonical-previous-action","indicator.previous.testplayer3.desktop")
-                        .string_attribute("x-canonical-play-action","indicator.play.testplayer3.desktop")
-                        .string_attribute("x-canonical-next-action","indicator.next.testplayer3.desktop")
-                        .string_attribute("x-canonical-type","com.canonical.unity.playback-item")
-                    )
-                )
-            .item(mh::MenuItemMatcher()
-                            .label("Sound Settings…")
-             )
-        ).match());
+                        .string_attribute("x-canonical-play-action","indicator.play.testplayer3.desktop")
+                        .string_attribute("x-canonical-type","com.canonical.unity.playback-item")
+                    )
+                )
+            .item(mh::MenuItemMatcher()
+                            .label("Sound Settings…")
+             )
+        ).match());
+
+    // check that the last running player is the one we expect
+    QVariant lastPlayerRunning = waitLastRunningPlayerChanged();
+    EXPECT_TRUE(lastPlayerRunning.type() == QVariant::String);
+    EXPECT_EQ(lastPlayerRunning.toString(), "testplayer3.desktop");
+
+    // restart the indicator to simulate a new user session
+    ASSERT_NO_THROW(startIndicator());
+
+    // check that player 3 is the only one with playback controls
+    // as it was the last one being stopped
+    EXPECT_MATCHRESULT(mh::MenuMatcher(desktopParameters())
+        .item(mh::MenuItemMatcher()
+            .action("indicator.root")
+            .string_attribute("x-canonical-type", "com.canonical.indicator.root")
+            .string_attribute("x-canonical-secondary-action", "indicator.mute")
+            .mode(mh::MenuItemMatcher::Mode::all)
+            .submenu()
+            .item(mh::MenuItemMatcher()
+                .section()
+                .item(mh::MenuItemMatcher().checkbox()
+                    .label("Mute")
+                )
+                .item(volumeSlider(INITIAL_VOLUME, "Volume"))
+            )
+            .item(mh::MenuItemMatcher()
+                    .section()
+                    .item(mh::MenuItemMatcher()
+                        .action("indicator.testplayer3.desktop")
+                        .label("TestPlayer3")
+                        .themed_icon("icon", {"testplayer"})
+                        .string_attribute("x-canonical-type", "com.canonical.unity.media-player")
+                    )
+                    .item(mh::MenuItemMatcher()
+                        .string_attribute("x-canonical-play-action","indicator.play.testplayer3.desktop")
+                        .string_attribute("x-canonical-type","com.canonical.unity.playback-item")
+                    )
+                )
+            .item(mh::MenuItemMatcher()
+                    .section()
+                    .item(mh::MenuItemMatcher()
+                        .action("indicator.testplayer1.desktop")
+                        .label("TestPlayer1")
+                        .themed_icon("icon", {"testplayer"})
+                        .string_attribute("x-canonical-type", "com.canonical.unity.media-player")
+                    )
+            )
+            .item(mh::MenuItemMatcher()
+                    .section()
+                    .item(mh::MenuItemMatcher()
+                        .action("indicator.testplayer2.desktop")
+                        .label("TestPlayer2")
+                        .themed_icon("icon", {"testplayer"})
+                        .string_attribute("x-canonical-type", "com.canonical.unity.media-player")
+                    )
+                )
+            .item(mh::MenuItemMatcher()
+                            .label("Sound Settings…")
+             )
+        ).match());
+
 }
 
 TEST_F(TestIndicator, DesktopMprisPlayerButtonsState)

=== modified file 'tests/notifications-test.cc'
--- tests/notifications-test.cc	2016-01-05 19:15:46 +0000
+++ tests/notifications-test.cc	2016-03-03 08:59:58 +0000
@@ -36,592 +36,602 @@
 
 class NotificationsTest : public ::testing::Test
 {
-	protected:
-		DbusTestService * service = NULL;
-
-		GDBusConnection * session = NULL;
-		std::shared_ptr<NotificationsMock> notifications;
-
-		virtual void SetUp() {
-			g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
-			g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
-
-			service = dbus_test_service_new(NULL);
-			dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SESSION);
-
-			/* Useful for debugging test failures, not needed all the time (until it fails) */
-			#if 0
-			auto bustle = std::shared_ptr<DbusTestTask>([]() {
-				DbusTestTask * bustle = DBUS_TEST_TASK(dbus_test_bustle_new("notifications-test.bustle"));
-				dbus_test_task_set_name(bustle, "Bustle");
-				dbus_test_task_set_bus(bustle, DBUS_TEST_SERVICE_BUS_SESSION);
-				return bustle;
-			}(), [](DbusTestTask * bustle) {
-				g_clear_object(&bustle);
-			});
-			dbus_test_service_add_task(service, bustle.get());
-			#endif
-
-			notifications = std::make_shared<NotificationsMock>();
-
-			dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
-			dbus_test_service_start_tasks(service);
-
-			session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-			ASSERT_NE(nullptr, session);
-			g_dbus_connection_set_exit_on_close(session, FALSE);
-			g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
-
-			/* This is done in main.c */
-			notify_init("indicator-sound");
-		}
-
-		virtual void TearDown() {
-			if (notify_is_initted())
-				notify_uninit();
-
-			notifications.reset();
-			g_clear_object(&service);
-
-			g_object_unref(session);
-
-			unsigned int cleartry = 0;
-			while (session != NULL && cleartry < 100) {
-				loop(100);
-				cleartry++;
-			}
-
-			ASSERT_EQ(nullptr, session);
-		}
-
-		static gboolean timeout_cb (gpointer user_data) {
-			GMainLoop * loop = static_cast<GMainLoop *>(user_data);
-			g_main_loop_quit(loop);
-			return G_SOURCE_REMOVE;
-		}
-
-		void loop (unsigned int ms) {
-			GMainLoop * loop = g_main_loop_new(NULL, FALSE);
-			g_timeout_add(ms, timeout_cb, loop);
-			g_main_loop_run(loop);
-			g_main_loop_unref(loop);
-		}
-
-		void loop_until(const std::function<bool()>& test, unsigned int max_ms=50, unsigned int test_interval_ms=10) {
-
-			// g_timeout's callback only allows a single pointer,
-			// so use a temporary stack struct to wedge everything into one pointer
-			struct CallbackData {
-				const std::function<bool()>& test;
-				const gint64 deadline;
-				GMainLoop* loop = g_main_loop_new(nullptr, false);
-				CallbackData (const std::function<bool()>& f, unsigned int max_ms):
-					test{f},
-					deadline{g_get_monotonic_time() + (max_ms*1000)} {}
-				~CallbackData() {g_main_loop_unref(loop);}
-			} data(test, max_ms);
-
-			// tell the timer to stop looping on success or deadline
-			auto timerfunc = [](gpointer gdata) -> gboolean {
-				auto& data = *static_cast<CallbackData*>(gdata);
-				if (!data.test() && (g_get_monotonic_time() < data.deadline))
-					return G_SOURCE_CONTINUE;
-				g_main_loop_quit(data.loop);
-				return G_SOURCE_REMOVE;
-			};
-
-			// start looping
-			g_timeout_add (std::min(max_ms, test_interval_ms), timerfunc, &data);
-			g_main_loop_run(data.loop);
-		}
-
-		void loop_until_notifications(unsigned int max_seconds=1) {
-			auto test = [this]{ return !notifications->getNotifications().empty(); };
-			loop_until(test, max_seconds);
-		}
-
-		static int unref_idle (gpointer user_data) {
-			g_variant_unref(static_cast<GVariant *>(user_data));
-			return G_SOURCE_REMOVE;
-		}
-
-		std::shared_ptr<MediaPlayerList> playerListMock () {
-			auto playerList = std::shared_ptr<MediaPlayerList>(
-				MEDIA_PLAYER_LIST(media_player_list_mock_new()),
-				[](MediaPlayerList * list) {
-					g_clear_object(&list);
-				});
-			return playerList;
-		}
-
-		std::shared_ptr<IndicatorSoundOptions> optionsMock () {
-			auto options = std::shared_ptr<IndicatorSoundOptions>(
-				INDICATOR_SOUND_OPTIONS(options_mock_new()),
-				[](IndicatorSoundOptions * options){
-					g_clear_object(&options);
-				});
-			return options;
-		}
-
-		std::shared_ptr<VolumeControl> volumeControlMock (const std::shared_ptr<IndicatorSoundOptions>& optionsMock) {
-			auto volumeControl = std::shared_ptr<VolumeControl>(
-				VOLUME_CONTROL(volume_control_mock_new(optionsMock.get())),
-				[](VolumeControl * control){
-					g_clear_object(&control);
-				});
-			return volumeControl;
-		}
-
-		std::shared_ptr<VolumeWarning> volumeWarningMock (const std::shared_ptr<IndicatorSoundOptions>& optionsMock) {
-			auto volumeWarning = std::shared_ptr<VolumeWarning>(
-				VOLUME_WARNING(volume_warning_mock_new(optionsMock.get())),
-				[](VolumeWarning * warning){
-					g_clear_object(&warning);
-				});
-			return volumeWarning;
-		}
-
-		std::shared_ptr<IndicatorSoundService> standardService (
-				const std::shared_ptr<VolumeControl>& volumeControl,
-				const std::shared_ptr<MediaPlayerList>& playerList,
-				const std::shared_ptr<IndicatorSoundOptions>& options,
-				const std::shared_ptr<VolumeWarning>& warning) {
-			auto soundService = std::shared_ptr<IndicatorSoundService>(
-				indicator_sound_service_new(playerList.get(), volumeControl.get(), nullptr, options.get(), warning.get()),
-				[](IndicatorSoundService * service){
-					g_clear_object(&service);
-				});
-
-			return soundService;
-		}
-
-		void setMockVolume (std::shared_ptr<VolumeControl> volumeControl, double volume, VolumeControlVolumeReasons reason = VOLUME_CONTROL_VOLUME_REASONS_USER_KEYPRESS) {
-			VolumeControlVolume * vol = volume_control_volume_new();
-			vol->volume = volume;
-			vol->reason = reason;
-
-			volume_control_set_volume(volumeControl.get(), vol);
-			g_object_unref(vol);
-		}
-
-		void setIndicatorShown (bool shown) {
-			auto bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
-
-			g_dbus_connection_call(bus,
-				g_dbus_connection_get_unique_name(bus),
-				"/com/canonical/indicator/sound",
-				"org.gtk.Actions",
-				"SetState",
-				g_variant_new("(sva{sv})", "indicator-shown", g_variant_new_boolean(shown), nullptr),
-				nullptr,
-				G_DBUS_CALL_FLAGS_NONE,
-				-1,
-				nullptr,
-				nullptr,
-				nullptr);
-
-			g_clear_object(&bus);
-		}
+    protected:
+        DbusTestService * service = NULL;
+
+        GDBusConnection * session = NULL;
+        std::shared_ptr<NotificationsMock> notifications;
+
+        virtual void SetUp() {
+            g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
+            g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
+
+            service = dbus_test_service_new(NULL);
+            dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SESSION);
+
+            /* Useful for debugging test failures, not needed all the time (until it fails) */
+            #if 0
+            auto bustle = std::shared_ptr<DbusTestTask>([]() {
+                DbusTestTask * bustle = DBUS_TEST_TASK(dbus_test_bustle_new("notifications-test.bustle"));
+                dbus_test_task_set_name(bustle, "Bustle");
+                dbus_test_task_set_bus(bustle, DBUS_TEST_SERVICE_BUS_SESSION);
+                return bustle;
+            }(), [](DbusTestTask * bustle) {
+                g_clear_object(&bustle);
+            });
+            dbus_test_service_add_task(service, bustle.get());
+            #endif
+
+            notifications = std::make_shared<NotificationsMock>();
+
+            dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+            dbus_test_service_start_tasks(service);
+
+            session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+            ASSERT_NE(nullptr, session);
+            g_dbus_connection_set_exit_on_close(session, FALSE);
+            g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
+
+            /* This is done in main.c */
+            notify_init("indicator-sound");
+        }
+
+        virtual void TearDown() {
+            if (notify_is_initted())
+                notify_uninit();
+
+            notifications.reset();
+            g_clear_object(&service);
+
+            g_object_unref(session);
+
+            unsigned int cleartry = 0;
+            while (session != NULL && cleartry < 100) {
+                loop(100);
+                cleartry++;
+            }
+
+            ASSERT_EQ(nullptr, session);
+        }
+
+        static gboolean timeout_cb (gpointer user_data) {
+            GMainLoop * loop = static_cast<GMainLoop *>(user_data);
+            g_main_loop_quit(loop);
+            return G_SOURCE_REMOVE;
+        }
+
+        void loop (unsigned int ms) {
+            GMainLoop * loop = g_main_loop_new(NULL, FALSE);
+            g_timeout_add(ms, timeout_cb, loop);
+            g_main_loop_run(loop);
+            g_main_loop_unref(loop);
+        }
+
+        void loop_until(const std::function<bool()>& test, unsigned int max_ms=50, unsigned int test_interval_ms=10) {
+
+            // g_timeout's callback only allows a single pointer,
+            // so use a temporary stack struct to wedge everything into one pointer
+            struct CallbackData {
+                const std::function<bool()>& test;
+                const gint64 deadline;
+                GMainLoop* loop = g_main_loop_new(nullptr, false);
+                CallbackData (const std::function<bool()>& f, unsigned int max_ms):
+                    test{f},
+                    deadline{g_get_monotonic_time() + (max_ms*1000)} {}
+                ~CallbackData() {g_main_loop_unref(loop);}
+            } data(test, max_ms);
+
+            // tell the timer to stop looping on success or deadline
+            auto timerfunc = [](gpointer gdata) -> gboolean {
+                auto& data = *static_cast<CallbackData*>(gdata);
+                if (!data.test() && (g_get_monotonic_time() < data.deadline))
+                    return G_SOURCE_CONTINUE;
+                g_main_loop_quit(data.loop);
+                return G_SOURCE_REMOVE;
+            };
+
+            // start looping
+            g_timeout_add (std::min(max_ms, test_interval_ms), timerfunc, &data);
+            g_main_loop_run(data.loop);
+        }
+
+        void loop_until_notifications(unsigned int max_seconds=1) {
+            auto test = [this]{ return !notifications->getNotifications().empty(); };
+            loop_until(test, max_seconds);
+        }
+
+        static int unref_idle (gpointer user_data) {
+            g_variant_unref(static_cast<GVariant *>(user_data));
+            return G_SOURCE_REMOVE;
+        }
+
+        std::shared_ptr<MediaPlayerList> playerListMock () {
+            auto playerList = std::shared_ptr<MediaPlayerList>(
+                MEDIA_PLAYER_LIST(media_player_list_mock_new()),
+                [](MediaPlayerList * list) {
+                    g_clear_object(&list);
+                });
+            return playerList;
+        }
+
+        std::shared_ptr<IndicatorSoundOptions> optionsMock () {
+            auto options = std::shared_ptr<IndicatorSoundOptions>(
+                INDICATOR_SOUND_OPTIONS(options_mock_new()),
+                [](IndicatorSoundOptions * options){
+                    g_clear_object(&options);
+                });
+            return options;
+        }
+
+        std::shared_ptr<VolumeControl> volumeControlMock (const std::shared_ptr<IndicatorSoundOptions>& optionsMock) {
+            auto volumeControl = std::shared_ptr<VolumeControl>(
+                VOLUME_CONTROL(volume_control_mock_new(optionsMock.get())),
+                [](VolumeControl * control){
+                    g_clear_object(&control);
+                });
+            return volumeControl;
+        }
+
+        std::shared_ptr<VolumeWarning> volumeWarningMock (const std::shared_ptr<IndicatorSoundOptions>& optionsMock) {
+            auto volumeWarning = std::shared_ptr<VolumeWarning>(
+                VOLUME_WARNING(volume_warning_mock_new(optionsMock.get())),
+                [](VolumeWarning * warning){
+                    g_clear_object(&warning);
+                });
+            return volumeWarning;
+        }
+
+        std::shared_ptr<IndicatorSoundService> standardService (
+                const std::shared_ptr<VolumeControl>& volumeControl,
+                const std::shared_ptr<MediaPlayerList>& playerList,
+                const std::shared_ptr<IndicatorSoundOptions>& options,
+                const std::shared_ptr<VolumeWarning>& warning,
+                const std::shared_ptr<AccountsServiceAccess>& accounts_service_access) {
+            auto soundService = std::shared_ptr<IndicatorSoundService>(
+                indicator_sound_service_new(playerList.get(), volumeControl.get(), nullptr, options.get(), warning.get(), accounts_service_access.get()),
+                [](IndicatorSoundService * service){
+                    g_clear_object(&service);
+                });
+
+            return soundService;
+        }
+
+        void setMockVolume (std::shared_ptr<VolumeControl> volumeControl, double volume, VolumeControlVolumeReasons reason = VOLUME_CONTROL_VOLUME_REASONS_USER_KEYPRESS) {
+            VolumeControlVolume * vol = volume_control_volume_new();
+            vol->volume = volume;
+            vol->reason = reason;
+
+            volume_control_set_volume(volumeControl.get(), vol);
+            g_object_unref(vol);
+        }
+
+        void setIndicatorShown (bool shown) {
+            auto bus = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, nullptr);
+
+            g_dbus_connection_call(bus,
+                g_dbus_connection_get_unique_name(bus),
+                "/com/canonical/indicator/sound",
+                "org.gtk.Actions",
+                "SetState",
+                g_variant_new("(sva{sv})", "indicator-shown", g_variant_new_boolean(shown), nullptr),
+                nullptr,
+                G_DBUS_CALL_FLAGS_NONE,
+                -1,
+                nullptr,
+                nullptr,
+                nullptr);
+
+            g_clear_object(&bus);
+        }
 
 };
 
 TEST_F(NotificationsTest, BasicObject) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Give some time settle */
-	loop(50);
-
-	/* Auto free */
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Give some time settle */
+    loop(50);
+
+    /* Auto free */
 }
 
 TEST_F(NotificationsTest, VolumeChanges) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_EQ("indicator-sound", notev[0].app_name);
-	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ(0, notev[0].actions.size());
-	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
-	EXPECT_GVARIANT_EQ("@i 50", notev[0].hints["value"]);
-
-	/* Set a different volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.60);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_GVARIANT_EQ("@i 60", notev[0].hints["value"]);
-
-	/* Have pulse set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.70, VOLUME_CONTROL_VOLUME_REASONS_PULSE_CHANGE);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(0, notev.size());
-
-	/* Have AS set the volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.80, VOLUME_CONTROL_VOLUME_REASONS_ACCOUNTS_SERVICE_SET);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(0, notev.size());
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_EQ("indicator-sound", notev[0].app_name);
+    EXPECT_EQ("Volume", notev[0].summary);
+    EXPECT_EQ(0, notev[0].actions.size());
+    EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
+    EXPECT_GVARIANT_EQ("@i 50", notev[0].hints["value"]);
+
+    /* Set a different volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.60);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_GVARIANT_EQ("@i 60", notev[0].hints["value"]);
+
+    /* Have pulse set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.70, VOLUME_CONTROL_VOLUME_REASONS_PULSE_CHANGE);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(0, notev.size());
+
+    /* Have AS set the volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.80, VOLUME_CONTROL_VOLUME_REASONS_ACCOUNTS_SERVICE_SET);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(0, notev.size());
 }
 
 TEST_F(NotificationsTest, StreamChanges) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.5);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-
-	/* Change Streams, no volume change */
-	notifications->clearNotifications();
-	volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALARM);
-	setMockVolume(volumeControl, 0.5, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
-	loop(50);
-	notev = notifications->getNotifications();
-	EXPECT_EQ(0, notev.size());
-
-	/* Change Streams, volume change */
-	notifications->clearNotifications();
-	volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALERT);
-	setMockVolume(volumeControl, 0.6, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
-	loop(50);
-	notev = notifications->getNotifications();
-	EXPECT_EQ(0, notev.size());
-
-	/* Change Streams, no volume change, volume up */
-	notifications->clearNotifications();
-	volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_MULTIMEDIA);
-	setMockVolume(volumeControl, 0.6, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
-	loop(50);
-	setMockVolume(volumeControl, 0.65);
-	notev = notifications->getNotifications();
-	EXPECT_EQ(1, notev.size());
-	EXPECT_GVARIANT_EQ("@i 65", notev[0].hints["value"]);
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.5);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+
+    /* Change Streams, no volume change */
+    notifications->clearNotifications();
+    volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALARM);
+    setMockVolume(volumeControl, 0.5, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
+    loop(50);
+    notev = notifications->getNotifications();
+    EXPECT_EQ(0, notev.size());
+
+    /* Change Streams, volume change */
+    notifications->clearNotifications();
+    volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALERT);
+    setMockVolume(volumeControl, 0.6, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
+    loop(50);
+    notev = notifications->getNotifications();
+    EXPECT_EQ(0, notev.size());
+
+    /* Change Streams, no volume change, volume up */
+    notifications->clearNotifications();
+    volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_MULTIMEDIA);
+    setMockVolume(volumeControl, 0.6, VOLUME_CONTROL_VOLUME_REASONS_VOLUME_STREAM_CHANGE);
+    loop(50);
+    setMockVolume(volumeControl, 0.65);
+    notev = notifications->getNotifications();
+    EXPECT_EQ(1, notev.size());
+    EXPECT_GVARIANT_EQ("@i 65", notev[0].hints["value"]);
 }
 
 TEST_F(NotificationsTest, IconTesting) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set an initial volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.5);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-
-	/* Generate a set of notifications */
-	notifications->clearNotifications();
-	for (float i = 0.0; i < 1.01; i += 0.1) {
-		setMockVolume(volumeControl, i);
-	}
-
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(11, notev.size());
-
-	EXPECT_EQ("audio-volume-muted",  notev[0].app_icon);
-	EXPECT_EQ("audio-volume-low",    notev[1].app_icon);
-	EXPECT_EQ("audio-volume-low",    notev[2].app_icon);
-	EXPECT_EQ("audio-volume-medium", notev[3].app_icon);
-	EXPECT_EQ("audio-volume-medium", notev[4].app_icon);
-	EXPECT_EQ("audio-volume-medium", notev[5].app_icon);
-	EXPECT_EQ("audio-volume-medium", notev[6].app_icon);
-	EXPECT_EQ("audio-volume-high",   notev[7].app_icon);
-	EXPECT_EQ("audio-volume-high",   notev[8].app_icon);
-	EXPECT_EQ("audio-volume-high",   notev[9].app_icon);
-	EXPECT_EQ("audio-volume-high",   notev[10].app_icon);
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set an initial volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.5);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+
+    /* Generate a set of notifications */
+    notifications->clearNotifications();
+    for (float i = 0.0; i < 1.01; i += 0.1) {
+        setMockVolume(volumeControl, i);
+    }
+
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(11, notev.size());
+
+    EXPECT_EQ("audio-volume-muted",  notev[0].app_icon);
+    EXPECT_EQ("audio-volume-low",    notev[1].app_icon);
+    EXPECT_EQ("audio-volume-low",    notev[2].app_icon);
+    EXPECT_EQ("audio-volume-medium", notev[3].app_icon);
+    EXPECT_EQ("audio-volume-medium", notev[4].app_icon);
+    EXPECT_EQ("audio-volume-medium", notev[5].app_icon);
+    EXPECT_EQ("audio-volume-medium", notev[6].app_icon);
+    EXPECT_EQ("audio-volume-high",   notev[7].app_icon);
+    EXPECT_EQ("audio-volume-high",   notev[8].app_icon);
+    EXPECT_EQ("audio-volume-high",   notev[9].app_icon);
+    EXPECT_EQ("audio-volume-high",   notev[10].app_icon);
 }
 
 TEST_F(NotificationsTest, ServerRestart) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-
-	/* Restart server without sync notifications */
-	notifications->clearNotifications();
-	dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
-	notifications.reset();
-
-	loop(50);
-
-	notifications = std::make_shared<NotificationsMock>(std::vector<std::string>({"body", "body-markup", "icon-static"}));
-	dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
-	dbus_test_task_run((DbusTestTask*)*notifications);
-
-	/* Change the volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.60);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(0, notev.size());
-
-	/* Put a good server back */
-	dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
-	notifications.reset();
-
-	loop(50);
-
-	notifications = std::make_shared<NotificationsMock>();
-	dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
-	dbus_test_task_run((DbusTestTask*)*notifications);
-
-	/* Change the volume again */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.70);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+
+    /* Restart server without sync notifications */
+    notifications->clearNotifications();
+    dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
+    notifications.reset();
+
+    loop(50);
+
+    notifications = std::make_shared<NotificationsMock>(std::vector<std::string>({"body", "body-markup", "icon-static"}));
+    dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+    dbus_test_task_run((DbusTestTask*)*notifications);
+
+    /* Change the volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.60);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(0, notev.size());
+
+    /* Put a good server back */
+    dbus_test_service_remove_task(service, (DbusTestTask*)*notifications);
+    notifications.reset();
+
+    loop(50);
+
+    notifications = std::make_shared<NotificationsMock>();
+    dbus_test_service_add_task(service, (DbusTestTask*)*notifications);
+    dbus_test_task_run((DbusTestTask*)*notifications);
+
+    /* Change the volume again */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.70);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
 }
 
 TEST_F(NotificationsTest, HighVolume) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ("Speakers", notev[0].body);
-	EXPECT_GVARIANT_EQ("@s 'false'", notev[0].hints["x-canonical-value-bar-tint"]);
-
-	/* Set high volume with volume change */
-	notifications->clearNotifications();
-	volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), true);
-	setMockVolume(volumeControl, 0.90);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_LT(0, notev.size()); /* This passes with one or two since it would just be an update to the first if a second was sent */
-	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ("Speakers", notev[0].body);
-	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
-
-	/* Move it back */
-	volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), false);
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-
-	/* Set high volume without level change */
-	/* NOTE: This can happen if headphones are plugged in */
-	notifications->clearNotifications();
-	volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), true);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ("Speakers", notev[0].body);
-	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_EQ("Volume", notev[0].summary);
+    EXPECT_EQ("Speakers", notev[0].body);
+    EXPECT_GVARIANT_EQ("@s 'false'", notev[0].hints["x-canonical-value-bar-tint"]);
+
+    /* Set high volume with volume change */
+    notifications->clearNotifications();
+    volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), true);
+    setMockVolume(volumeControl, 0.90);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_LT(0, notev.size()); /* This passes with one or two since it would just be an update to the first if a second was sent */
+    EXPECT_EQ("Volume", notev[0].summary);
+    EXPECT_EQ("Speakers", notev[0].body);
+    EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
+
+    /* Move it back */
+    volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), false);
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+
+    /* Set high volume without level change */
+    /* NOTE: This can happen if headphones are plugged in */
+    notifications->clearNotifications();
+    volume_warning_mock_set_high_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), true);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_EQ("Volume", notev[0].summary);
+    EXPECT_EQ("Speakers", notev[0].body);
+    EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
 }
 
 TEST_F(NotificationsTest, MenuHide) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	EXPECT_EQ(1, notev.size());
-
-	/* Set the indicator to shown, and set a new volume */
-	notifications->clearNotifications();
-	setIndicatorShown(true);
-	loop(50);
-	setMockVolume(volumeControl, 0.60);
-	loop(50);
-	notev = notifications->getNotifications();
-	EXPECT_EQ(0, notev.size());
-
-	/* Set the indicator to hidden, and set a new volume */
-	notifications->clearNotifications();
-	setIndicatorShown(false);
-	loop(50);
-	setMockVolume(volumeControl, 0.70);
-	loop(50);
-	notev = notifications->getNotifications();
-	EXPECT_EQ(1, notev.size());
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    EXPECT_EQ(1, notev.size());
+
+    /* Set the indicator to shown, and set a new volume */
+    notifications->clearNotifications();
+    setIndicatorShown(true);
+    loop(50);
+    setMockVolume(volumeControl, 0.60);
+    loop(50);
+    notev = notifications->getNotifications();
+    EXPECT_EQ(0, notev.size());
+
+    /* Set the indicator to hidden, and set a new volume */
+    notifications->clearNotifications();
+    setIndicatorShown(false);
+    loop(50);
+    setMockVolume(volumeControl, 0.70);
+    loop(50);
+    notev = notifications->getNotifications();
+    EXPECT_EQ(1, notev.size());
 }
 
 TEST_F(NotificationsTest, ExtendendVolumeNotification) {
-	auto options = optionsMock();
-	auto volumeControl = volumeControlMock(options);
-	auto volumeWarning = volumeWarningMock(options);
-	auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-	/* Set a volume */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 0.50);
-	loop(50);
-	auto notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_EQ("indicator-sound", notev[0].app_name);
-	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ(0, notev[0].actions.size());
-	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
-	EXPECT_GVARIANT_EQ("@i 50", notev[0].hints["value"]);
-
-	/* Allow an amplified volume */
-	notifications->clearNotifications();
-	volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALARM);
-	options_mock_mock_set_max_volume(OPTIONS_MOCK(options.get()), 1.5);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_GVARIANT_EQ("@i 33", notev[0].hints["value"]);
-
-	/* Set to 'over max' */
-	notifications->clearNotifications();
-	setMockVolume(volumeControl, 1.525);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_GVARIANT_EQ("@i 100", notev[0].hints["value"]);
-
-	/* Put back */
-	notifications->clearNotifications();
-	options_mock_mock_set_max_volume(OPTIONS_MOCK(options.get()), 1.0);
-	loop(50);
-	notev = notifications->getNotifications();
-	ASSERT_EQ(1, notev.size());
-	EXPECT_GVARIANT_EQ("@i 100", notev[0].hints["value"]);
+    auto options = optionsMock();
+    auto volumeControl = volumeControlMock(options);
+    auto volumeWarning = volumeWarningMock(options);
+    auto accountsService = std::make_shared<AccountsServiceAccess>();
+    auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+    /* Set a volume */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 0.50);
+    loop(50);
+    auto notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_EQ("indicator-sound", notev[0].app_name);
+    EXPECT_EQ("Volume", notev[0].summary);
+    EXPECT_EQ(0, notev[0].actions.size());
+    EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
+    EXPECT_GVARIANT_EQ("@i 50", notev[0].hints["value"]);
+
+    /* Allow an amplified volume */
+    notifications->clearNotifications();
+    volume_control_mock_mock_set_active_stream(VOLUME_CONTROL_MOCK(volumeControl.get()), VOLUME_CONTROL_STREAM_ALARM);
+    options_mock_mock_set_max_volume(OPTIONS_MOCK(options.get()), 1.5);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_GVARIANT_EQ("@i 33", notev[0].hints["value"]);
+
+    /* Set to 'over max' */
+    notifications->clearNotifications();
+    setMockVolume(volumeControl, 1.525);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_GVARIANT_EQ("@i 100", notev[0].hints["value"]);
+
+    /* Put back */
+    notifications->clearNotifications();
+    options_mock_mock_set_max_volume(OPTIONS_MOCK(options.get()), 1.0);
+    loop(50);
+    notev = notifications->getNotifications();
+    ASSERT_EQ(1, notev.size());
+    EXPECT_GVARIANT_EQ("@i 100", notev[0].hints["value"]);
 }
 
 TEST_F(NotificationsTest, TriggerWarning) {
 
-	// Tests all the conditions needed to trigger a volume warning.
-	// There are many possible combinations, so this test is slow. :P
-
-	const struct {
-		bool expected;
-		VolumeControlActiveOutput output;
-	} test_outputs[] = {
-		{ false, VOLUME_CONTROL_ACTIVE_OUTPUT_SPEAKERS },
-		{ true,  VOLUME_CONTROL_ACTIVE_OUTPUT_HEADPHONES },
-		{ true,  VOLUME_CONTROL_ACTIVE_OUTPUT_BLUETOOTH_HEADPHONES },
-		{ false, VOLUME_CONTROL_ACTIVE_OUTPUT_BLUETOOTH_SPEAKER },
-		{ false, VOLUME_CONTROL_ACTIVE_OUTPUT_USB_SPEAKER },
-		{ true,  VOLUME_CONTROL_ACTIVE_OUTPUT_USB_HEADPHONES },
-		{ false, VOLUME_CONTROL_ACTIVE_OUTPUT_HDMI_SPEAKER },
-		{ true,  VOLUME_CONTROL_ACTIVE_OUTPUT_HDMI_HEADPHONES },
-		{ false, VOLUME_CONTROL_ACTIVE_OUTPUT_CALL_MODE }
-	};
-
-	const struct {
-		bool expected;
-		pa_volume_t volume;
-		pa_volume_t loud_volume;
-	} test_volumes[] = {
-		{ false,   50, 100 },
-		{ false,   99, 100 },
-		{ true,   100, 100 },
-		{ true,   101, 100 }
-	};
-
-	const struct {
-		bool expected;
-		bool approved;
-	} test_approved[] = {
-		{ true,  false },
-		{ false, true }
-	};
-
-	const struct {
-		bool expected;
-		bool warnings_enabled;
-	} test_warnings_enabled[] = {
-		{ true,  true },
-		{ false, false }
-	};
-
-	const struct {
-		bool expected;
-		bool multimedia_active;
-	} test_multimedia_active[] = {
-		{ true,  true },
-		{ false, false }
-	};
-
-	for (const auto& outputs : test_outputs) {
-	for (const auto& volumes : test_volumes) {
-	for (const auto& approved : test_approved) {
-	for (const auto& warnings_enabled : test_warnings_enabled) {
-	for (const auto& multimedia_active : test_multimedia_active) {
-
-		notifications->clearNotifications();
-
-		// instantiate the test subjects
-		auto options = optionsMock();
-		auto volumeControl = volumeControlMock(options);
-		auto volumeWarning = volumeWarningMock(options);
-		auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning);
-
-		// run the test
-		options_mock_mock_set_loud_volume(OPTIONS_MOCK(options.get()), volumes.loud_volume);
-		options_mock_mock_set_loud_warning_enabled(OPTIONS_MOCK(options.get()), warnings_enabled.warnings_enabled);
-		volume_warning_mock_set_approved(VOLUME_WARNING_MOCK(volumeWarning.get()), approved.approved);
-		volume_warning_mock_set_multimedia_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), volumes.volume);
-		volume_warning_mock_set_multimedia_active(VOLUME_WARNING_MOCK(volumeWarning.get()), multimedia_active.multimedia_active);
-		volume_control_mock_mock_set_active_output(VOLUME_CONTROL_MOCK(volumeControl.get()), outputs.output);
-
-		loop_until_notifications();
-
-		// check the result
-		auto notev = notifications->getNotifications();
-		const bool warning_expected = outputs.expected && volumes.expected && approved.expected && warnings_enabled.expected && multimedia_active.expected;
-		if (warning_expected) {
-			EXPECT_TRUE(volume_warning_get_active(volumeWarning.get()));
-			ASSERT_EQ(1, notev.size());
-			EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-snap-decisions"]);
-			EXPECT_GVARIANT_EQ(nullptr, notev[0].hints["x-canonical-private-synchronous"]);
-		}
-		else {
-			EXPECT_FALSE(volume_warning_get_active(volumeWarning.get()));
-			ASSERT_EQ(1, notev.size());
-			EXPECT_GVARIANT_EQ(nullptr, notev[0].hints["x-canonical-snap-decisions"]);
-			EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
-		}
-
-	} // multimedia_active
-	} // warnings_enabled
-	} // approved
-	} // volumes
-	} // outputs
+    // Tests all the conditions needed to trigger a volume warning.
+    // There are many possible combinations, so this test is slow. :P
+
+    const struct {
+        bool expected;
+        VolumeControlActiveOutput output;
+    } test_outputs[] = {
+        { false, VOLUME_CONTROL_ACTIVE_OUTPUT_SPEAKERS },
+        { true,  VOLUME_CONTROL_ACTIVE_OUTPUT_HEADPHONES },
+        { true,  VOLUME_CONTROL_ACTIVE_OUTPUT_BLUETOOTH_HEADPHONES },
+        { false, VOLUME_CONTROL_ACTIVE_OUTPUT_BLUETOOTH_SPEAKER },
+        { false, VOLUME_CONTROL_ACTIVE_OUTPUT_USB_SPEAKER },
+        { true,  VOLUME_CONTROL_ACTIVE_OUTPUT_USB_HEADPHONES },
+        { false, VOLUME_CONTROL_ACTIVE_OUTPUT_HDMI_SPEAKER },
+        { true,  VOLUME_CONTROL_ACTIVE_OUTPUT_HDMI_HEADPHONES },
+        { false, VOLUME_CONTROL_ACTIVE_OUTPUT_CALL_MODE }
+    };
+
+    const struct {
+        bool expected;
+        pa_volume_t volume;
+        pa_volume_t loud_volume;
+    } test_volumes[] = {
+        { false,   50, 100 },
+        { false,   99, 100 },
+        { true,   100, 100 },
+        { true,   101, 100 }
+    };
+
+    const struct {
+        bool expected;
+        bool approved;
+    } test_approved[] = {
+        { true,  false },
+        { false, true }
+    };
+
+    const struct {
+        bool expected;
+        bool warnings_enabled;
+    } test_warnings_enabled[] = {
+        { true,  true },
+        { false, false }
+    };
+
+    const struct {
+        bool expected;
+        bool multimedia_active;
+    } test_multimedia_active[] = {
+        { true,  true },
+        { false, false }
+    };
+
+    for (const auto& outputs : test_outputs) {
+    for (const auto& volumes : test_volumes) {
+    for (const auto& approved : test_approved) {
+    for (const auto& warnings_enabled : test_warnings_enabled) {
+    for (const auto& multimedia_active : test_multimedia_active) {
+
+        notifications->clearNotifications();
+
+        // instantiate the test subjects
+        auto options = optionsMock();
+        auto volumeControl = volumeControlMock(options);
+        auto volumeWarning = volumeWarningMock(options);
+        auto accountsService = std::make_shared<AccountsServiceAccess>();
+        auto soundService = standardService(volumeControl, playerListMock(), options, volumeWarning, accountsService);
+
+        // run the test
+        options_mock_mock_set_loud_volume(OPTIONS_MOCK(options.get()), volumes.loud_volume);
+        options_mock_mock_set_loud_warning_enabled(OPTIONS_MOCK(options.get()), warnings_enabled.warnings_enabled);
+        volume_warning_mock_set_approved(VOLUME_WARNING_MOCK(volumeWarning.get()), approved.approved);
+        volume_warning_mock_set_multimedia_volume(VOLUME_WARNING_MOCK(volumeWarning.get()), volumes.volume);
+        volume_warning_mock_set_multimedia_active(VOLUME_WARNING_MOCK(volumeWarning.get()), multimedia_active.multimedia_active);
+        volume_control_mock_mock_set_active_output(VOLUME_CONTROL_MOCK(volumeControl.get()), outputs.output);
+
+        loop_until_notifications();
+
+        // check the result
+        auto notev = notifications->getNotifications();
+        const bool warning_expected = outputs.expected && volumes.expected && approved.expected && warnings_enabled.expected && multimedia_active.expected;
+        if (warning_expected) {
+            EXPECT_TRUE(volume_warning_get_active(volumeWarning.get()));
+            ASSERT_EQ(1, notev.size());
+            EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-snap-decisions"]);
+            EXPECT_GVARIANT_EQ(nullptr, notev[0].hints["x-canonical-private-synchronous"]);
+        }
+        else {
+            EXPECT_FALSE(volume_warning_get_active(volumeWarning.get()));
+            ASSERT_EQ(1, notev.size());
+            EXPECT_GVARIANT_EQ(nullptr, notev[0].hints["x-canonical-snap-decisions"]);
+            EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-private-synchronous"]);
+        }
+
+    } // multimedia_active
+    } // warnings_enabled
+    } // approved
+    } // volumes
+    } // outputs
 }
 

=== modified file 'tests/service-mocks/accounts-mock/AccountsServiceSoundMock.cpp'
--- tests/service-mocks/accounts-mock/AccountsServiceSoundMock.cpp	2015-12-23 13:35:46 +0000
+++ tests/service-mocks/accounts-mock/AccountsServiceSoundMock.cpp	2016-03-03 08:59:58 +0000
@@ -46,3 +46,18 @@
                                     "Volume",
                                     property("Volume"));
 }
+
+QString AccountsServiceSoundMock::lastRunningPlayer() const
+{
+    return lastRunningPlayer_;
+}
+
+void AccountsServiceSoundMock::setLastRunningPlayer(QString const & lastRunningPlayer)
+{
+    lastRunningPlayer_ = lastRunningPlayer;
+    notifier_.notifyPropertyChanged(QDBusConnection::systemBus(),
+                                    ACCOUNTS_SOUND_INTERFACE,
+                                    USER_PATH,
+                                    "LastRunningPlayer",
+                                    property("LastRunningPlayer"));
+}

=== modified file 'tests/service-mocks/accounts-mock/AccountsServiceSoundMock.h'
--- tests/service-mocks/accounts-mock/AccountsServiceSoundMock.h	2015-12-23 13:35:46 +0000
+++ tests/service-mocks/accounts-mock/AccountsServiceSoundMock.h	2016-03-03 08:59:58 +0000
@@ -37,10 +37,13 @@
 {
     Q_OBJECT
     Q_PROPERTY(double Volume READ volume WRITE setVolume)
+    Q_PROPERTY(QString LastRunningPlayer READ lastRunningPlayer WRITE setLastRunningPlayer)
 
 public Q_SLOTS:
     double volume() const;
     void setVolume(double volume);
+    QString lastRunningPlayer() const;
+    void setLastRunningPlayer(QString const & lastRunningPlayer);
 
 public:
     AccountsServiceSoundMock(QObject* parent = 0);
@@ -48,6 +51,7 @@
 
 private:
     double volume_;
+    QString lastRunningPlayer_;
     DBusPropertiesNotifier notifier_;
 };
 

=== modified file 'tests/service-mocks/accounts-mock/com.ubuntu.AccountsService.Sound.Mock.xml'
--- tests/service-mocks/accounts-mock/com.ubuntu.AccountsService.Sound.Mock.xml	2015-12-23 13:35:46 +0000
+++ tests/service-mocks/accounts-mock/com.ubuntu.AccountsService.Sound.Mock.xml	2016-03-03 08:59:58 +0000
@@ -2,5 +2,6 @@
 <node>
   <interface name="com.ubuntu.AccountsService.Sound">
     <property name="Volume" type="d" access="readwrite"/>
+    <property name="LastRunningPlayer" type="s" access="readwrite"/>
   </interface>
 </node>
\ No newline at end of file

=== modified file 'tests/sound-menu.cc'
--- tests/sound-menu.cc	2016-02-10 13:08:49 +0000
+++ tests/sound-menu.cc	2016-03-03 08:59:58 +0000
@@ -62,7 +62,7 @@
 
         void check_player_control_buttons(bool canPlay, bool canNext, bool canPrev)
         {
-            SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE, "");
+            SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE);
 
             MediaPlayerTrack * track = media_player_track_new("Artist", "Title", "Album", "http://art.url");
 
@@ -96,22 +96,22 @@
 
             /* Player control */
             verify_item_attribute(section, 1, "x-canonical-type", g_variant_new_string("com.canonical.unity.playback-item"));
-	    //verify_item_attribute(section, 1, "x-canonical-play-action", g_variant_new_string(""));
-	    if (!canPlay) {
+        //verify_item_attribute(section, 1, "x-canonical-play-action", g_variant_new_string(""));
+        if (!canPlay) {
                 verify_item_attribute_is_not_set(section, 1, "x-canonical-play-action", G_VARIANT_TYPE_STRING);
-	    } else {
-	        verify_item_attribute(section, 1, "x-canonical-play-action", g_variant_new_string("indicator.play.player-id"));
-	    }
-	    if (!canNext) {
+        } else {
+            verify_item_attribute(section, 1, "x-canonical-play-action", g_variant_new_string("indicator.play.player-id"));
+        }
+        if (!canNext) {
                 verify_item_attribute_is_not_set(section, 1, "x-canonical-next-action", G_VARIANT_TYPE_STRING);
-	    } else {
-	        verify_item_attribute(section, 1, "x-canonical-next-action", g_variant_new_string("indicator.next.player-id"));
-	    }
-	    if (!canPrev) {
+        } else {
+            verify_item_attribute(section, 1, "x-canonical-next-action", g_variant_new_string("indicator.next.player-id"));
+        }
+        if (!canPrev) {
                 verify_item_attribute_is_not_set(section, 1, "x-canonical-previous-action", G_VARIANT_TYPE_STRING);
-	    } else {
-	        verify_item_attribute(section, 1, "x-canonical-previous-action", g_variant_new_string("indicator.previous.player-id"));
-	    }
+        } else {
+            verify_item_attribute(section, 1, "x-canonical-previous-action", g_variant_new_string("indicator.previous.player-id"));
+        }
 
             g_clear_object(&section);
 
@@ -125,7 +125,7 @@
 };
 
 TEST_F(SoundMenuTest, BasicObject) {
-    SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE, "");
+    SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE);
 
     ASSERT_NE(nullptr, menu);
 
@@ -134,7 +134,7 @@
 }
 
 TEST_F(SoundMenuTest, AddRemovePlayer) {
-    SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE, "");
+    SoundMenu * menu = sound_menu_new (nullptr, SOUND_MENU_DISPLAY_FLAGS_NONE);
 
     MediaPlayerTrack * track = media_player_track_new("Artist", "Title", "Album", "http://art.url");
 

=== modified file 'tests/volume-control-test.cc'
--- tests/volume-control-test.cc	2015-12-29 17:03:41 +0000
+++ tests/volume-control-test.cc	2016-03-03 08:59:58 +0000
@@ -29,64 +29,65 @@
 class VolumeControlTest : public ::testing::Test
 {
 
-	protected:
-		DbusTestService * service = NULL;
-		GDBusConnection * session = NULL;
-
-		virtual void SetUp() override {
-
-			g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
-			g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
-
-			service = dbus_test_service_new(NULL);
-			dbus_test_service_start_tasks(service);
-
-			session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-			ASSERT_NE(nullptr, session);
-			g_dbus_connection_set_exit_on_close(session, FALSE);
-			g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
-		}
-
-		virtual void TearDown() {
-			g_clear_object(&service);
-
-			g_object_unref(session);
-
-			unsigned int cleartry = 0;
-			while (session != NULL && cleartry < 100) {
-				loop(100);
-				cleartry++;
-			}
-
-			ASSERT_EQ(nullptr, session);
-		}
-
-		static gboolean timeout_cb (gpointer user_data) {
-			GMainLoop * loop = static_cast<GMainLoop *>(user_data);
-			g_main_loop_quit(loop);
-			return G_SOURCE_REMOVE;
-		}
-
-		void loop (unsigned int ms) {
-			GMainLoop * loop = g_main_loop_new(NULL, FALSE);
-			g_timeout_add(ms, timeout_cb, loop);
-			g_main_loop_run(loop);
-			g_main_loop_unref(loop);
-		}
+    protected:
+        DbusTestService * service = NULL;
+        GDBusConnection * session = NULL;
+
+        virtual void SetUp() override {
+
+            g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, TRUE);
+            g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
+
+            service = dbus_test_service_new(NULL);
+            dbus_test_service_start_tasks(service);
+
+            session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+            ASSERT_NE(nullptr, session);
+            g_dbus_connection_set_exit_on_close(session, FALSE);
+            g_object_add_weak_pointer(G_OBJECT(session), (gpointer *)&session);
+        }
+
+        virtual void TearDown() {
+            g_clear_object(&service);
+
+            g_object_unref(session);
+
+            unsigned int cleartry = 0;
+            while (session != NULL && cleartry < 100) {
+                loop(100);
+                cleartry++;
+            }
+
+            ASSERT_EQ(nullptr, session);
+        }
+
+        static gboolean timeout_cb (gpointer user_data) {
+            GMainLoop * loop = static_cast<GMainLoop *>(user_data);
+            g_main_loop_quit(loop);
+            return G_SOURCE_REMOVE;
+        }
+
+        void loop (unsigned int ms) {
+            GMainLoop * loop = g_main_loop_new(NULL, FALSE);
+            g_timeout_add(ms, timeout_cb, loop);
+            g_main_loop_run(loop);
+            g_main_loop_unref(loop);
+        }
 };
 
 TEST_F(VolumeControlTest, BasicObject) {
-	auto options = options_mock_new();
-	auto pgloop = pa_glib_mainloop_new(NULL);
-	auto control = volume_control_pulse_new(INDICATOR_SOUND_OPTIONS(options), pgloop);
-
-	/* Setup the PA backend */
-	loop(100);
-
-	/* Ready */
-	EXPECT_TRUE(volume_control_get_ready(VOLUME_CONTROL(control)));
-
-	g_clear_object(&control);
-	g_clear_object(&options);
-	g_clear_pointer(&pgloop, pa_glib_mainloop_free);
+    auto options = options_mock_new();
+    auto pgloop = pa_glib_mainloop_new(NULL);
+    auto accounts_service_access = accounts_service_access_new();
+    auto control = volume_control_pulse_new(INDICATOR_SOUND_OPTIONS(options), pgloop, accounts_service_access);
+
+    /* Setup the PA backend */
+    loop(100);
+
+    /* Ready */
+    EXPECT_TRUE(volume_control_get_ready(VOLUME_CONTROL(control)));
+
+    g_clear_object(&control);
+    g_clear_object(&options);
+    g_clear_pointer(&pgloop, pa_glib_mainloop_free);
 }