Merge lp:~xavi-garcia-mena/indicator-sound/sync-vivid-wily into lp:indicator-sound/15.04

[Xavi Garcia]

Sync vivid and wily branches

Sync vivid and wily branches

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:501
http://jenkins.qa.ubuntu.com/job/indicator-sound-15.04-ci/1/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-15.04-vivid-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-sound-15.04-vivid-armhf-ci/1
        deb: http://jenkins.qa.ubuntu.com/job/indicator-sound-15.04-vivid-armhf-ci/1/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Xavi Garcia (xavi-garcia-mena)]

Approving as it is just a merge of commits from wily.
Source code should be in sync now with wily.

review: Approve

[lp:~xavi-garcia-mena/indicator-sound/sync-vivid-wily]

502. By Xavi Garcia on 2015-10-13

fixed version number in changelog

[Charles Kerr (charlesk)]

:)

review: Approve

=== modified file 'data/com.canonical.indicator.sound.gschema.xml'
--- data/com.canonical.indicator.sound.gschema.xml	2014-12-03 15:12:01 +0000
+++ data/com.canonical.indicator.sound.gschema.xml	2015-10-13 13:18:26 +0000
@@ -39,5 +39,68 @@
         Whether or not to show the sound indicator in the menu bar.
       </description>
     </key>
+
+    <!-- VOLUME -->
+
+    <key name="warning-volume-enabled" type="b">
+      <default>true</default>
+      <summary>Whether or not to show high volume warnings.</summary>
+      <description>
+        If enabled on a device, a confirmation dialog will be presented to the user if
+        (a) something is plugged into the headphone jack (ie, no warnings for speaker volumes) AND
+        (b) media is playing (ie, no warnings for ringtone volumes) AND
+        (c) the user attempts to set the volume higher than warning-volume-decibels AND
+        (d) the user has not indicated approval in the last warning-volume-approval-ttl seconds.
+      </description>
+    </key>
+    <key name="warning-volume-confirmation-ttl" type="i">
+      <default>72000</default>
+      <summary>How many seconds a user's warning-volume approval should be remembered.</summary>
+      <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.”	
+      </description>
+    </key>
+    <key name="warning-volume-decibels" type="d">
+      <default>-8.0</default>
+      <summary>Volume level that triggers a high volume warning.</summary>
+      <description>
+        Volume level that triggers a high volume warning.
+        See warning-volume-enabled for details.
+      </description>
+    </key>
+
+    <key name="normal-volume-decibels" type="d">
+      <default>0</default>
+      <summary>Normal output volume.</summary>
+      <description>
+        The maximum volume when com.ubuntu.sound's 'allow-amplified-volume' setting is disabled.
+
+        To conform with EU standard EN 60950-1/Al2, this value should never be
+        set to a dB that causes headphone sound output to exceed 100 dBA, nor
+        electric output to exceed 150 mV.
+
+        The default value (0) corresponds to PulseAudio's PA_VOLUME_NORM.
+      </description>
+    </key>
+
+    <key name="amplified-volume-decibels" type="d">
+      <default>11</default>
+      <summary>Output volume to use when com.ubuntu.sound's 'allow-amplified-volume' setting is enabled.</summary>
+      <description>
+        The maximum volume when com.ubuntu.sound's 'allow-amplified-volume' setting is enabled.
+
+        To conform with EU standard EN 60950-1/Al2, this value should never be
+        set to a dB that causes headphone sound output to exceed 100 dBA, nor
+        electric output to exceed 150 mV.
+
+        The default value (11) corresponds to PulseAudio's PA_VOLUME_UI_MAX.
+      </description>
+    </key>
+
   </schema>
 </schemalist>
 
=== modified file 'debian/changelog'
--- debian/changelog	2015-05-08 12:20:07 +0000
+++ debian/changelog	2015-10-13 13:18:26 +0000
@@ -1,3 +1,45 @@
+indicator-sound (12.10.2+15.04.20150812.3-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Charles Kerr ]
+  * When showing a "Loud volumes can damage your hearing" confirmation
+    warning, clamp the volume until the user hits "OK". (LP: #1481913)
+
+ -- CI Train Bot <[e-mail]>  Wed, 12 Aug 2015 20:55:05 +0000
+
+indicator-sound (12.10.2+15.04.20150807.6-0ubuntu1) vivid; urgency=medium
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+  [ Charles Kerr ]
+  * Revised UI volume warnings to comply with EU requirements. (LP:
+    #1481913)
+
+ -- CI Train Bot <[e-mail]>  Fri, 07 Aug 2015 22:35:58 +0000
+
+indicator-sound (12.10.2+15.04.20150605-0ubuntu1) vivid; urgency=medium
+
+  * 
+
+ -- CI Train Bot <[e-mail]>  Fri, 05 Jun 2015 19:50:06 +0000
+
+indicator-sound (12.10.2+15.04.20150507+eventually4-0ubuntu1) vivid; urgency=medium
+
+  * Using eventually to avoid arbitrary timeouts in tests
+
+ -- Ted Gould <[e-mail]>  Wed, 27 May 2015 11:11:19 -0500
+
+indicator-sound (12.10.2+15.04.20150507-0ubuntu1) vivid; urgency=medium
+
+  [ Charles Kerr ]
+  * Use the BusWatcher to look for org.freedesktop.Notifications
+    ownership changes on the bus. (LP: #1432446)
+
+ -- CI Train Bot <[e-mail]>  Thu, 07 May 2015 15:27:00 +0000
+
 indicator-sound (12.10.2+15.04.20150508-0ubuntu1) vivid; urgency=medium
 
   [ CI Train Bot ]
 
=== modified file 'src/service.vala'
--- src/service.vala	2015-04-20 21:02:32 +0000
+++ src/service.vala	2015-10-13 13:18:26 +0000
@@ -20,6 +20,13 @@
 public class IndicatorSound.Service: Object {
 	DBusConnection bus;
 
+	/**
+	 * A copy of volume_control.volume made before just warn_notification
+	 * is shown. Since the volume is clamped during the warning, we cache
+	 * the previous volume to use iff the user hits "OK".
+	 */
+	VolumeControl.Volume _pre_warn_volume = null;
+
 	public Service (MediaPlayerList playerlist, VolumeControl volume, AccountsServiceUser? accounts) {
 		try {
 			bus = Bus.get_sync(GLib.BusType.SESSION);
@@ -27,14 +34,19 @@
 			error("Unable to get DBus session bus: %s", e.message);
 		}
 
-		sync_notification = new Notify.Notification(_("Volume"), "", "audio-volume-muted");
+		info_notification = new Notify.Notification(_("Volume"), "", "audio-volume-muted");
+
+		warn_notification = new Notify.Notification(_("Volume"), _("High volume can damage your hearing."), "audio-volume-high");
+		warn_notification.set_hint ("x-canonical-non-shaped-icon", "true");
+		warn_notification.set_hint ("x-canonical-snap-decisions", "true");
+		warn_notification.set_hint ("x-canonical-private-affirmative-tint", "true");
+		warn_notification.closed.connect((n) => { n.clear_actions(); });
 		BusWatcher.watch_namespace (GLib.BusType.SESSION,
 		                            "org.freedesktop.Notifications",
-		                            () => { debug("Notifications name appeared"); check_sync_notification = false; },
-		                            () => { debug("Notifications name vanshed");  check_sync_notification = false; });
+		                            () => { debug("Notifications name appeared"); notify_server_caps_checked = false; },
+		                            () => { debug("Notifications name vanshed");  notify_server_caps_checked = false; });
 
 		this.settings = new Settings ("com.canonical.indicator.sound");
-		this.sharedsettings = new Settings ("com.ubuntu.sound");
 
 		this.settings.bind ("visible", this, "visible", SettingsBindFlags.GET);
 		this.notify["visible"].connect ( () => this.update_root_icon () );
@@ -83,19 +95,13 @@
 			this.sync_preferred_players ();
 		});
 
-		sharedsettings.bind ("allow-amplified-volume", this, "allow-amplified-volume", SettingsBindFlags.GET);
-
 		/* Hide the notification when the menu is shown */
 		var shown_action = actions.lookup_action ("indicator-shown") as SimpleAction;
 		shown_action.change_state.connect ((state) => {
-			block_notifications = state.get_boolean();
-			if (block_notifications) {
+			block_info_notifications = state.get_boolean();
+			if (block_info_notifications) {
 				debug("Indicator is shown");
-				try {
-					sync_notification.close();
-				} catch (Error e) {
-					warning("Unable to close synchronous volume notification: %s", e.message);
-				}
+				close_notification(info_notification);
 			} else {
 				debug("Indicator is hidden");
 			}
@@ -111,11 +117,33 @@
 		this.menus.@foreach ( (profile, menu) => menu.export (bus, @"/com/canonical/indicator/sound/$profile"));
 	}
 
+	private void close_notification(Notify.Notification? n) {
+		return_if_fail (n != null);
+		if (n.id != 0) {
+			try {
+				n.close();
+			} catch (GLib.Error e) {
+				warning("Unable to close notification: %s", e.message);
+			}
+		}
+	}
+
+	private void show_notification(Notify.Notification? n) {
+		return_if_fail (n != null);
+		try {
+			n.show ();
+		} catch (GLib.Error e) {
+			warning ("Unable to show notification: %s", e.message);
+		}
+	}
+
 	~Service() {
 		debug("Destroying Service Object");
 
 		clear_acts_player();
 
+		stop_clamp_to_high_timeout();
+
 		if (this.player_action_update_id > 0) {
 			Source.remove (this.player_action_update_id);
 			this.player_action_update_id = 0;
@@ -145,28 +173,6 @@
 
 	public bool visible { get; set; }
 
-	public bool allow_amplified_volume {
-		get {
-			return this.max_volume > 1.0;
-		}
-
-		set {
-			if (this.allow_amplified_volume == value)
-				return;
-
-			if (value) {
-				/* from pulse/volume.h: #define PA_VOLUME_UI_MAX (pa_sw_volume_from_dB(+11.0)) */
-				this.max_volume = (double)PulseAudio.Volume.sw_from_dB(11.0) / PulseAudio.Volume.NORM;
-			}
-			else {
-				this.max_volume = 1.0;
-			}
-
-			/* Normalize volume, because the volume action's state is [0.0, 1.0], see create_volume_action() */
-			this.actions.change_action_state ("volume", this.volume_control.volume.volume / this.max_volume);
-		}
-	}
-
 	const ActionEntry[] action_entries = {
 		{ "root", null, null, "@a{sv} {}", null },
 		{ "scroll", activate_scroll_action, "i", null, null },
@@ -178,7 +184,6 @@
 	SimpleActionGroup actions;
 	HashTable<string, SoundMenu> menus;
 	Settings settings;
-	Settings sharedsettings;
 	VolumeControl volume_control;
 	MediaPlayerList players;
 	uint player_action_update_id;
@@ -187,28 +192,27 @@
 	bool syncing_preferred_players = false;
 	AccountsServiceUser? accounts_service = null;
 	bool export_to_accounts_service = false;
-	private Notify.Notification sync_notification;
-
-	/* Maximum volume as a scaling factor between the volume action's state and the value in
-	 * this.volume_control. See create_volume_action().
-	 */
-	double max_volume = 1.0;
+	private Notify.Notification info_notification;
+	private Notify.Notification warn_notification;
 
 	const double volume_step_percentage = 0.06;
 
-	void activate_scroll_action (SimpleAction action, Variant? param) {
+	private void activate_scroll_action (SimpleAction action, Variant? param) {
 		int delta = param.get_int32(); /* positive for up, negative for down */
-
-		var scrollvol = new VolumeControl.Volume();
-		double v = this.volume_control.volume.volume + volume_step_percentage * delta;
-		scrollvol.volume = v.clamp (0.0, this.max_volume);
-		scrollvol.reason = VolumeControl.VolumeReasons.USER_KEYPRESS;
-		this.volume_control.volume = scrollvol;
+		double v = volume_control.volume.volume + volume_step_percentage * delta;
+		volume_control.set_volume_clamp (v, VolumeControl.VolumeReasons.USER_KEYPRESS);
 	}
 
 	void activate_desktop_settings (SimpleAction action, Variant? param) {
 		var env = Environment.get_variable ("DESKTOP_SESSION");
 		string cmd;
+
+		if (Environment.get_variable ("MIR_SOCKET") != null)
+		{
+			UrlDispatch.send ("settings:///system/sound");
+			return;
+		}
+
 		if (env == "xubuntu" || env == "ubuntustudio")
 			cmd = "pavucontrol";
 		else if (env == "mate")
@@ -242,12 +246,10 @@
 	void update_root_icon () {
 		double volume = this.volume_control.volume.volume;
 		string icon;
-		if (this.volume_control.mute)
+		if (this.volume_control.mute || volume <= 0.0)
 			icon = this.mute_blocks_sound ? "audio-volume-muted-blocking-panel" : "audio-volume-muted-panel";
 		else if (this.accounts_service != null && this.accounts_service.silentMode)
 		  icon = "audio-volume-muted-panel";
-		else if (volume <= 0.0)
-			icon = "audio-volume-low-zero-panel";
 		else if (volume <= 0.3)
 			icon = "audio-volume-low-panel";
 		else if (volume <= 0.7)
@@ -275,60 +277,83 @@
 		root_action.set_state (builder.end());
 	}
 
-	private bool check_sync_notification = false;
-	private bool support_sync_notification = false;
-	private bool block_notifications = false;
-
-	void update_sync_notification () {
-		if (!check_sync_notification) {
-			support_sync_notification = false;
+	private bool notify_server_caps_checked = false;
+	private bool notify_server_supports_actions = false;
+	private bool notify_server_supports_sync = false;
+	private bool block_info_notifications = false;
+
+	private void update_notification () {
+
+		if (!notify_server_caps_checked) {
 			List<string> caps = Notify.get_server_caps ();
-			if (caps.find_custom ("x-canonical-private-synchronous", strcmp) != null) {
-				support_sync_notification = true;
-			}
-			check_sync_notification = true;
+			notify_server_supports_actions = caps.find_custom ("actions", strcmp) != null;
+			notify_server_supports_sync = caps.find_custom ("x-canonical-private-synchronous", strcmp) != null;
+			notify_server_caps_checked = true;
 		}
 
-		if (!support_sync_notification)
-			return;
-
-		if (block_notifications)
-			return;
-
-		/* Determine Label */
-		string volume_label = "";
-		if (volume_control.high_volume)
-			volume_label = _("High volume");
-
-		/* Choose an icon */
-		string icon = "audio-volume-muted";
-		if (volume_control.volume.volume <= 0.0)
-			icon = "audio-volume-muted";
-		else if (volume_control.volume.volume <= 0.3)
-			icon = "audio-volume-low";
-		else if (volume_control.volume.volume <= 0.7)
-			icon = "audio-volume-medium";
-		else
-			icon = "audio-volume-high";
-
-		/* Check tint */
-		string tint = "false";
-		if (volume_control.high_volume)
-			tint = "true";
-
-		/* Put it all into the notification */
-		sync_notification.clear_hints ();
-		sync_notification.update (_("Volume"), volume_label, icon);
-		sync_notification.set_hint ("value", (int32)Math.round(volume_control.volume.volume / this.max_volume * 100.0));
-		sync_notification.set_hint ("x-canonical-value-bar-tint", tint);
-		sync_notification.set_hint ("x-canonical-private-synchronous", "true");
-		sync_notification.set_hint ("x-canonical-non-shaped-icon", "true");
-
-		/* Show it */
-		try {
-			sync_notification.show ();			
-		} catch (GLib.Error e) {
-			warning("Unable to send volume change notification: %s", e.message);
+		var loud = volume_control.high_volume;
+		var warn = loud
+			&& this.notify_server_supports_actions
+			&& !this.volume_control.high_volume_approved;
+
+		if (warn) {
+			close_notification(info_notification);
+			if (_pre_warn_volume == null) {
+				_pre_warn_volume = new VolumeControl.Volume();
+				_pre_warn_volume.volume = volume_control.volume.volume;
+				_pre_warn_volume.reason = volume_control.volume.reason;
+			}
+			warn_notification.clear_actions();
+			warn_notification.add_action ("ok", _("OK"), (n, a) => {
+				stop_clamp_to_high_timeout();
+				volume_control.approve_high_volume ();
+				if (_pre_warn_volume != null) {
+					var tmp = _pre_warn_volume;
+					_pre_warn_volume = null;
+					volume_control.volume = tmp;
+				}
+			});
+			warn_notification.add_action ("cancel", _("Cancel"), (n, a) => {
+				_pre_warn_volume = null;
+			});
+			show_notification(warn_notification);
+		} else {
+			close_notification(warn_notification);
+
+			if (notify_server_supports_sync && !block_info_notifications) {
+
+				/* Determine Label */
+				unowned string volume_label = loud
+					 ? _("High volume can damage your hearing.")
+					 : "";
+
+				/* Choose an icon */
+				unowned string icon;
+				if (loud) {
+					icon = "audio-volume-high";
+				} else {
+					var volume = volume_control.volume.volume;
+
+					if (volume <= 0.0)
+						icon = "audio-volume-muted";
+					else if (volume <= 0.3)
+						icon = "audio-volume-low";
+					else if (volume <= 0.7)
+						icon = "audio-volume-medium";
+					else
+						icon = "audio-volume-high";
+				}
+
+				/* Reset the notification */
+				var n = this.info_notification;
+				n.update (_("Volume"), volume_label, icon);
+				n.clear_hints();
+				n.set_hint ("x-canonical-non-shaped-icon", "true");
+				n.set_hint ("x-canonical-private-synchronous", "true");
+				n.set_hint ("x-canonical-value-bar-tint", loud ? "true" : "false");
+				n.set_hint ("value", (int32)Math.round(get_volume_percent() * 100.0));
+				show_notification(n);
+			}
 		}
 	}
 
@@ -408,49 +433,49 @@
 		return mute_action;
 	}
 
-	SimpleAction volume_action;
-	Action create_volume_action () {
-		/* The action's state is between be in [0.0, 1.0] instead of [0.0,
-		 * max_volume], so that we don't need to update the slider menu item
-		 * every time allow-amplified-volume is changed.  Convert between the
-		 * two here, so that we always pass the full range into
-		 * volume_control.set_volume().
-		 */
-
-		double volume = this.volume_control.volume.volume / this.max_volume;
-
-		volume_action = new SimpleAction.stateful ("volume", VariantType.INT32, new Variant.double (volume));
+	/* return the current volume in the range of [0.0, 1.0] */
+	private double get_volume_percent() {
+		return volume_control.volume.volume / this.volume_control.max_volume;
+	}
+
+	/* volume control's range can vary depending on its max_volume property,
+	 * but the action always needs to be in [0.0, 1.0]... */
+	private Variant create_volume_action_state() {
+		return new Variant.double (get_volume_percent());
+	}
+
+	private void update_volume_action_state() {
+		volume_action.set_state(create_volume_action_state());
+	}
+
+	private SimpleAction volume_action;
+	private Action create_volume_action () {
+		volume_action = new SimpleAction.stateful ("volume", VariantType.INT32, create_volume_action_state());
 
 		volume_action.change_state.connect ( (action, val) => {
-			double v = val.get_double () * this.max_volume;
-
-			var vol = new VolumeControl.Volume();
-			vol.volume = v.clamp (0.0, this.max_volume);
-			vol.reason = VolumeControl.VolumeReasons.USER_KEYPRESS;
-			volume_control.volume = vol;
+			double v = val.get_double () * this.volume_control.max_volume;
+			volume_control.set_volume_clamp (v, VolumeControl.VolumeReasons.USER_KEYPRESS);
 		});
 
 		/* activating this action changes the volume by the amount given in the parameter */
-		volume_action.activate.connect ( (action, param) => {
-			int delta = param.get_int32 ();
-			double v = volume_control.volume.volume + volume_step_percentage * delta;
+		volume_action.activate.connect ((a,p) => activate_scroll_action(a,p));
 
-			var vol = new VolumeControl.Volume();
-			vol.volume = v.clamp (0.0, this.max_volume);
-			vol.reason = VolumeControl.VolumeReasons.USER_KEYPRESS;
-			volume_control.volume = vol;
+		this.volume_control.notify["max-volume"].connect(() => {
+			update_volume_action_state();
 		});
 
 		this.volume_control.notify["volume"].connect (() => {
-			/* Normalize volume, because the volume action's state is [0.0, 1.0], see create_volume_action() */
-			volume_action.set_state (new Variant.double (this.volume_control.volume.volume / this.max_volume));
+			update_volume_action_state();
 
 			this.update_root_icon ();
 
 			var reason = volume_control.volume.reason;
 			if (reason == VolumeControl.VolumeReasons.USER_KEYPRESS ||
 					reason == VolumeControl.VolumeReasons.DEVICE_OUTPUT_CHANGE)
-				this.update_sync_notification ();
+				this.update_notification ();
+
+			if ((warn_notification.id != 0) && (_pre_warn_volume != null))
+				clamp_to_high_soon();
 		});
 
 		this.volume_control.bind_property ("ready", volume_action, "enabled", BindingFlags.SYNC_CREATE);
@@ -481,7 +506,7 @@
 
 		this.volume_control.notify["high-volume"].connect( () => {
 			high_volume_action.set_state(new Variant.boolean (this.volume_control.high_volume));
-			update_sync_notification();
+			update_notification();
 		});
 
 		return high_volume_action;
@@ -604,4 +629,27 @@
 
 		this.update_preferred_players ();
 	}
+
+	/** VOLUME CLAMPING **/
+
+	private uint _clamp_to_high_timeout = 0;
+
+	private void stop_clamp_to_high_timeout() {
+		if (_clamp_to_high_timeout != 0) {
+			Source.remove(_clamp_to_high_timeout);
+			_clamp_to_high_timeout = 0;
+		}
+	}
+
+	private void clamp_to_high_soon() {
+		const uint interval_msec = 200;
+		if (_clamp_to_high_timeout == 0)
+			_clamp_to_high_timeout = Timeout.add(interval_msec, clamp_to_high_idle);
+	}
+
+	private bool clamp_to_high_idle() {
+		_clamp_to_high_timeout = 0;
+		volume_control.clamp_to_high_volume();
+		return false; // Source.REMOVE;
+	}
 }
 
=== modified file 'src/volume-control-pulse.vala'
--- src/volume-control-pulse.vala	2015-04-17 17:10:28 +0000
+++ src/volume-control-pulse.vala	2015-10-13 13:18:26 +0000
@@ -28,8 +28,8 @@
 [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 abstract async string get_active_entry () throws IOError;
+	public signal void entry_selected (string entry_name);
 }
 
 public class VolumeControlPulse : VolumeControl
@@ -44,6 +44,8 @@
 	private bool   _is_playing = false;
 	private VolumeControl.Volume _volume = new VolumeControl.Volume();
 	private double _mic_volume = 0.0;
+	private Settings _settings = new Settings ("com.canonical.indicator.sound");
+	private Settings _shared_settings = new Settings ("com.ubuntu.sound");
 
 	/* Used by the pulseaudio stream restore extension */
 	private DBusConnection _pconn;
@@ -92,13 +94,6 @@
 	/** true when a microphone is active **/
 	public override bool active_mic { get; private set; default = false; }
 
-	/** true when high volume warnings should be shown */
-	public override bool high_volume {
-		get {
-			return this._volume.volume > 0.75 && _active_port_headphone && stream == "multimedia";
-		}
-	}
-
 	public VolumeControlPulse ()
 	{
 		_volume.volume = 0.0;
@@ -110,19 +105,34 @@
 		_mute_cancellable = new Cancellable ();
 		_volume_cancellable = new Cancellable ();
 
+		init_all_properties();
+
 		setup_accountsservice.begin ();
 
 		this.reconnect_to_pulse ();
 	}
 
+	private void init_all_properties()
+	{
+		init_max_volume();
+		init_high_volume();
+		init_high_volume_approved();
+	}
+
 	~VolumeControlPulse ()
 	{
+		stop_all_timers();
+	}
+
+	private void stop_all_timers()
+	{
 		if (_reconnect_timer != 0) {
 			Source.remove (_reconnect_timer);
 			_reconnect_timer = 0;
 		}
 		stop_local_volume_timer();
 		stop_account_service_volume_timer();
+		stop_high_volume_approved_timer();
 	}
 
 	/* PulseAudio logic*/
@@ -212,7 +222,7 @@
 			vol.volume = volume_to_double (i.volume.max ());
 			vol.reason = VolumeControl.VolumeReasons.PULSE_CHANGE;
 			this.volume = vol;
-		} 
+		}
 	}
 
 	private void source_info_cb (Context c, SourceInfo? i, int eol)
@@ -619,7 +629,6 @@
 			var volume_changed = (value.volume != _volume.volume);
 			debug("Setting volume to %f for profile %d because %d", value.volume, _active_sink_input, value.reason);
 
-			var old_high_volume = this.high_volume;
 			_volume = value;
 
 			/* Make sure we're connected to Pulse and pulse didn't give us the change */
@@ -631,15 +640,153 @@
 				else
 					context.get_server_info (server_info_cb_for_set_volume);
 
-			if (this.high_volume != old_high_volume)
-				this.notify_property("high-volume");
 
 			if (volume.reason != VolumeControl.VolumeReasons.ACCOUNTS_SERVICE_SET
 				&& volume_changed) {
 				start_local_volume_timer();
 			}
-		}
-	}
+
+			update_high_volume();
+		}
+	}
+
+	/** MAX VOLUME PROPERTY **/
+
+	private void init_max_volume() {
+		_settings.changed["normal-volume-decibels"].connect(() => update_max_volume());
+		_settings.changed["amplified-volume-decibels"].connect(() => update_max_volume());
+		_shared_settings.changed["allow-amplified-volume"].connect(() => update_max_volume());
+		update_max_volume();
+	}
+	private void update_max_volume () {
+		var new_max_volume = calculate_max_volume();
+		if (max_volume != new_max_volume) {
+			debug("changing max_volume from %f to %f", this.max_volume, new_max_volume);
+			max_volume = calculate_max_volume();
+		}
+	}
+	private double calculate_max_volume () {
+		unowned string decibel_key = _shared_settings.get_boolean("allow-amplified-volume")
+			? "amplified-volume-decibels"
+			: "normal-volume-decibels";
+		var volume_dB = _settings.get_double(decibel_key);
+		var volume_sw = PulseAudio.Volume.sw_from_dB (volume_dB);
+		return volume_to_double (volume_sw);
+	}
+
+	/** HIGH VOLUME PROPERTY **/
+
+	private bool _warning_volume_enabled;
+	private double _warning_volume_norms; /* 1.0 == PA_VOLUME_NORM */
+	private bool _high_volume = false;
+	public override bool high_volume {
+		get { return this._high_volume; }
+		private set { this._high_volume = value; }
+	}
+	private void init_high_volume() {
+		_settings.changed["warning-volume-enabled"].connect(() => update_high_volume_cache());
+		_settings.changed["warning-volume-decibels"].connect(() => update_high_volume_cache());
+		update_high_volume_cache();
+	}
+	private void update_high_volume_cache() {
+		var volume_dB = _settings.get_double ("warning-volume-decibels");
+		var volume_sw = PulseAudio.Volume.sw_from_dB (volume_dB);
+		var volume_norms = volume_to_double (volume_sw);
+		_warning_volume_norms = volume_norms;
+		_warning_volume_enabled = _settings.get_boolean("warning-volume-enabled");
+		debug("updating high volume cache... enabled %d dB %f sw %lu norm %f", (int)_warning_volume_enabled, volume_dB, volume_sw, volume_norms);
+		update_high_volume();
+	}
+	private void update_high_volume() {
+		var new_high_volume = calculate_high_volume();
+		if (high_volume != new_high_volume) {
+			debug("changing high_volume from %d to %d", (int)high_volume, (int)new_high_volume);
+			high_volume = new_high_volume;
+		}
+	}
+	private bool calculate_high_volume() {
+		return calculate_high_volume_from_volume(_volume.volume);
+	}
+	private bool calculate_high_volume_from_volume(double volume) {
+		return _active_port_headphone
+			&& _warning_volume_enabled
+			&& volume >= _warning_volume_norms
+			&& (stream == "multimedia");
+	}
+
+	public override void clamp_to_high_volume() {
+		if (_high_volume && (_volume.volume > _warning_volume_norms)) {
+			var vol = new VolumeControl.Volume();
+			vol.volume = _volume.volume.clamp(0, _warning_volume_norms);
+			vol.reason = _volume.reason;
+			debug("Clamping from %f down to %f", _volume.volume, vol.volume);
+			volume = vol;
+		}
+	}
+
+	/** HIGH VOLUME APPROVED PROPERTY **/
+
+	private bool _high_volume_approved = false;
+	private uint _high_volume_approved_timer = 0;
+	private int64 _high_volume_approved_at = 0;
+	private int64 _high_volume_approved_ttl_usec = 0;
+	public override bool high_volume_approved {
+		get { return this._high_volume_approved; }
+		private set { this._high_volume_approved = value; }
+	}
+	private void init_high_volume_approved() {
+		_settings.changed["warning-volume-confirmation-ttl"].connect(() => update_high_volume_approved_cache());
+		update_high_volume_approved_cache();
+	}
+	private void update_high_volume_approved_cache() {
+		_high_volume_approved_ttl_usec = _settings.get_int("warning-volume-confirmation-ttl");
+		_high_volume_approved_ttl_usec *= 1000000;
+
+		update_high_volume_approved();
+		update_high_volume_approved_timer();
+	}
+	private void update_high_volume_approved_timer() {
+		stop_high_volume_approved_timer();
+		if (_high_volume_approved_at != 0) {
+			int64 expires_at = _high_volume_approved_at + _high_volume_approved_ttl_usec;
+			int64 now = GLib.get_monotonic_time();
+			if (expires_at > now) {
+				var seconds_left = 1 + ((expires_at - now) / 1000000);
+				_high_volume_approved_timer = Timeout.add_seconds((uint)seconds_left, on_high_volume_approved_timer);
+			}
+		}
+	}
+	private void stop_high_volume_approved_timer() {
+		if (_high_volume_approved_timer != 0) {
+			Source.remove (_high_volume_approved_timer);
+			_high_volume_approved_timer = 0;
+		}
+	}
+	private bool on_high_volume_approved_timer() {
+		_high_volume_approved_timer = 0;
+		update_high_volume_approved();
+		return false; /* Source.REMOVE */
+	}
+	private void update_high_volume_approved() {
+		var new_high_volume_approved = calculate_high_volume_approved();
+		if (high_volume_approved != new_high_volume_approved) {
+			debug("changing high_volume_approved from %d to %d", (int)high_volume_approved, (int)new_high_volume_approved);
+			high_volume_approved = new_high_volume_approved;
+		}
+	}
+	private bool calculate_high_volume_approved() {
+		int64 now = GLib.get_monotonic_time();
+		return (_high_volume_approved_at != 0)
+			&& (_high_volume_approved_at + _high_volume_approved_ttl_usec >= now);
+	}
+	public override void approve_high_volume() {
+		_high_volume_approved_at = GLib.get_monotonic_time();
+		update_high_volume_approved();
+		update_high_volume_approved_timer();
+	}
+
+
+	/** MIC VOLUME PROPERTY */
 
 	public override double mic_volume {
 		get {
 
=== modified file 'src/volume-control.vala'
--- src/volume-control.vala	2015-02-17 16:54:33 +0000
+++ src/volume-control.vala	2015-10-13 13:18:26 +0000
@@ -36,12 +36,24 @@
 	public virtual string stream { get { return ""; } }
 	public virtual bool ready { get { return false; } set { } }
 	public virtual bool active_mic { get { return false; } set { } }
-	public virtual bool high_volume { get { return false; } }
+	public virtual bool high_volume { get { return false; } protected set { } }
 	public virtual bool mute { get { return false; } }
 	public virtual bool is_playing { get { return false; } }
 	private Volume _volume;
 	public virtual Volume volume { get { return _volume; } set { } }
 	public virtual double mic_volume { get { return 0.0; } set { } }
+	public virtual double max_volume { get { return 1.0; } protected set { } }
+
+	public virtual bool high_volume_approved { get { return false; } protected set { } }
+	public virtual void approve_high_volume() { }
+	public virtual void clamp_to_high_volume() { }
 
 	public abstract void set_mute (bool mute);
+
+	public void set_volume_clamp (double unclamped, VolumeControl.VolumeReasons reason) {
+		var v = new VolumeControl.Volume();
+		v.volume = unclamped.clamp (0.0, this.max_volume);
+		v.reason = reason;
+		this.volume = v;
+	}
 }
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-02-09 22:10:22 +0000
+++ tests/CMakeLists.txt	2015-10-13 13:18:26 +0000
@@ -163,7 +163,7 @@
 ###########################
 
 include_directories(${CMAKE_SOURCE_DIR}/src)
-add_executable (volume-control-test volume-control-test.cc)
+add_executable (volume-control-test volume-control-test.cc gschemas.compiled)
 target_link_libraries (
 	volume-control-test
 	indicator-sound-service-lib
 
=== modified file 'tests/media-player-user.cc'
--- tests/media-player-user.cc	2015-01-30 16:05:10 +0000
+++ tests/media-player-user.cc	2015-10-13 13:18:26 +0000
@@ -17,6 +17,9 @@
  *      Ted Gould <[e-mail]>
  */
 
+#include <chrono>
+#include <future>
+
 #include <gtest/gtest.h>
 #include <gio/gio.h>
 #include <libdbustest/dbus-test.h>
@@ -31,24 +34,55 @@
 {
 
 	protected:
-		DbusTestService * service = NULL;
+		DbusTestService * testsystem = NULL;
 		AccountsServiceMock service_mock;
 
+		DbusTestService * testsession = NULL;
+
+		DbusTestProcess * systemmonitor = nullptr;
+		DbusTestProcess * sessionmonitor = nullptr;
+
 		GDBusConnection * system = NULL;
+		GDBusConnection * session = NULL;
 		GDBusProxy * proxy = NULL;
 
+		std::chrono::milliseconds _eventuallyTime = std::chrono::seconds{5};
+
 		virtual void SetUp() {
-			service = dbus_test_service_new(NULL);
-			dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SYSTEM);
-
-			dbus_test_service_add_task(service, (DbusTestTask*)service_mock);
-			dbus_test_service_start_tasks(service);
+			/* System Bus */
+			testsystem = dbus_test_service_new(NULL);
+			dbus_test_service_set_bus(testsystem, DBUS_TEST_SERVICE_BUS_SYSTEM);
+
+			systemmonitor = dbus_test_process_new("dbus-monitor");
+			dbus_test_process_append_param(systemmonitor, "--system");
+			dbus_test_task_set_name(DBUS_TEST_TASK(systemmonitor), "System");
+			dbus_test_service_add_task(testsystem, DBUS_TEST_TASK(systemmonitor));
+
+			dbus_test_service_add_task(testsystem, (DbusTestTask*)service_mock);
+			dbus_test_service_start_tasks(testsystem);
 
 			system = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 			ASSERT_NE(nullptr, system);
 			g_dbus_connection_set_exit_on_close(system, FALSE);
 			g_object_add_weak_pointer(G_OBJECT(system), (gpointer *)&system);
 
+			/* Session Bus */
+			testsession = dbus_test_service_new(NULL);
+			dbus_test_service_set_bus(testsession, DBUS_TEST_SERVICE_BUS_SESSION);
+
+			sessionmonitor = dbus_test_process_new("dbus-monitor");
+			dbus_test_process_append_param(sessionmonitor, "--session");
+			dbus_test_task_set_name(DBUS_TEST_TASK(sessionmonitor), "Session");
+			dbus_test_service_add_task(testsession, DBUS_TEST_TASK(sessionmonitor));
+
+			dbus_test_service_start_tasks(testsession);
+
+			session = g_bus_get_sync(G_BUS_TYPE_SYSTEM, 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);
+
+			/* Setup proxy */
 			proxy = g_dbus_proxy_new_sync(system,
 				G_DBUS_PROXY_FLAGS_NONE,
 				NULL,
@@ -60,10 +94,15 @@
 		}
 
 		virtual void TearDown() {
+			g_clear_object(&sessionmonitor);
+			g_clear_object(&systemmonitor);
+
 			g_clear_object(&proxy);
-			g_clear_object(&service);
+			g_clear_object(&testsystem);
+			g_clear_object(&testsession);
 
 			g_object_unref(system);
+			g_object_unref(session);
 
 			#if 0
 			/* Accounts Service keeps a bunch of references around so we
@@ -95,8 +134,78 @@
 		void set_property (const gchar * name, GVariant * value) {
 			dbus_test_dbus_mock_object_update_property((DbusTestDbusMock *)service_mock, service_mock.get_sound(), name, value, NULL);
 		}
+
+		testing::AssertionResult expectEventually (std::function<testing::AssertionResult(void)> &testfunc) {
+			auto loop = std::shared_ptr<GMainLoop>(g_main_loop_new(nullptr, FALSE), [](GMainLoop * loop) { if (loop != nullptr) g_main_loop_unref(loop); });
+
+			std::promise<testing::AssertionResult> retpromise;
+			auto retfuture = retpromise.get_future();
+			auto start = std::chrono::steady_clock::now();
+
+			/* The core of the idle function as an object so we can use the C++-isms
+			   of attaching the variables and make this code reasonably readable */
+			std::function<void(void)> idlefunc = [&loop, &retpromise, &testfunc, &start, this]() -> void {
+				auto result = testfunc();
+
+				if (result == false && _eventuallyTime > (std::chrono::steady_clock::now() - start)) {
+					return;
+				}
+
+				retpromise.set_value(result);
+				g_main_loop_quit(loop.get());
+			};
+
+			auto idlesrc = g_idle_add([](gpointer data) -> gboolean {
+				auto func = reinterpret_cast<std::function<void(void)> *>(data);
+				(*func)();
+				return G_SOURCE_CONTINUE;
+			}, &idlefunc);
+
+			g_main_loop_run(loop.get());
+			g_source_remove(idlesrc);
+
+			return retfuture.get();
+		}
+
+		/* Eventually Helpers */
+		#define _EVENTUALLY_HELPER(oper) \
+		template <typename... Args> testing::AssertionResult expectEventually##oper (Args&& ... args) { \
+			std::function<testing::AssertionResult(void)> func = [&]() { \
+				return testing::internal::CmpHelper##oper(std::forward<Args>(args)...); \
+			}; \
+			return expectEventually(func); \
+		}
+
+		_EVENTUALLY_HELPER(EQ);
+		_EVENTUALLY_HELPER(NE);
+		_EVENTUALLY_HELPER(LT);
+		_EVENTUALLY_HELPER(GT);
+		_EVENTUALLY_HELPER(STREQ);
+		_EVENTUALLY_HELPER(STRNE);
+
+		#undef _EVENTUALLY_HELPER
 };
 
+/* Helpers */
+#define EXPECT_EVENTUALLY_EQ(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyEQ, expected, actual)
+
+#define EXPECT_EVENTUALLY_NE(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyNE, expected, actual)
+
+#define EXPECT_EVENTUALLY_LT(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyLT, expected, actual)
+
+#define EXPECT_EVENTUALLY_GT(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallyGT, expected, actual)
+
+#define EXPECT_EVENTUALLY_STREQ(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallySTREQ, expected, actual)
+
+#define EXPECT_EVENTUALLY_STRNE(expected, actual) \
+	EXPECT_PRED_FORMAT2(MediaPlayerUserTest::expectEventuallySTRNE, expected, actual)
+
+
 TEST_F(MediaPlayerUserTest, BasicObject) {
 	MediaPlayerUser * player = media_player_user_new("user");
 	ASSERT_NE(nullptr, player);
@@ -125,7 +234,12 @@
 	g_clear_object(&player);
 }
 
-TEST_F(MediaPlayerUserTest, DataSet) {
+void
+running_update (GObject * obj, GParamSpec * pspec, bool * running) {
+	*running = media_player_get_is_running(MEDIA_PLAYER(obj)) == TRUE;
+};
+
+TEST_F(MediaPlayerUserTest, DISABLED_DataSet) {
 	/* Put data into Acts */
 	set_property("Timestamp", g_variant_new_uint64(g_get_monotonic_time()));
 	set_property("PlayerName", g_variant_new_string("The Player Formerly Known as Prince"));
@@ -141,11 +255,11 @@
 	MediaPlayerUser * player = media_player_user_new("user");
 	ASSERT_NE(nullptr, player);
 
-	/* Get the proxy -- and it's precious precious data -- oh, my, precious! */
-	loop(100);
-
 	/* Ensure even with the proxy we don't have anything */
-	EXPECT_TRUE(media_player_get_is_running(MEDIA_PLAYER(player)));
+	bool running = false;
+	g_signal_connect(G_OBJECT(player), "notify::is-running", G_CALLBACK(running_update), &running);
+	running_update(G_OBJECT(player), nullptr, &running);
+	EXPECT_EVENTUALLY_EQ(true, running);
 	EXPECT_TRUE(media_player_get_can_raise(MEDIA_PLAYER(player)));
 	EXPECT_STREQ("user", media_player_get_id(MEDIA_PLAYER(player)));
 	EXPECT_STREQ("The Player Formerly Known as Prince", media_player_get_name(MEDIA_PLAYER(player)));
@@ -168,7 +282,7 @@
 	g_clear_object(&player);
 }
 
-TEST_F(MediaPlayerUserTest, TimeoutTest) {
+TEST_F(MediaPlayerUserTest, DISABLED_TimeoutTest) {
 	/* Put data into Acts -- but 15 minutes ago */
 	set_property("Timestamp", g_variant_new_uint64(g_get_monotonic_time() - 15 * 60 * 1000 * 1000));
 	set_property("PlayerName", g_variant_new_string("The Player Formerly Known as Prince"));
@@ -180,24 +294,26 @@
 	set_property("Album", g_variant_new_string("Vinyl is dead"));
 	set_property("ArtUrl", g_variant_new_string("http://art.url"));
 
-	/* Ensure the properties get set before we pull them */
-	loop(100);
-
 	/* Build our media player */
 	MediaPlayerUser * player = media_player_user_new("user");
 	ASSERT_NE(nullptr, player);
 
-	/* Get the proxy -- and the old data, so old, like forever */
-	loop(100);
+	bool running = false;
+	g_signal_connect(G_OBJECT(player), "notify::is-running", G_CALLBACK(running_update), &running);
+	running_update(G_OBJECT(player), nullptr, &running);
 
 	/* Ensure that we show up as not running */
-	EXPECT_FALSE(media_player_get_is_running(MEDIA_PLAYER(player)));
+	EXPECT_EVENTUALLY_EQ(false, running);
 
 	/* Update to make running */
 	set_property("Timestamp", g_variant_new_uint64(g_get_monotonic_time()));
-	loop(100);
-
-	EXPECT_TRUE(media_player_get_is_running(MEDIA_PLAYER(player)));
+
+	EXPECT_EVENTUALLY_EQ(true, running);
+
+	/* Clear to not run */
+	set_property("Timestamp", g_variant_new_uint64(1));
+
+	EXPECT_EVENTUALLY_EQ(false, running);
 
 	g_clear_object(&in_icon);
 	g_clear_object(&player);
 
=== modified file 'tests/notifications-test.cc'
--- tests/notifications-test.cc	2015-02-24 19:05:10 +0000
+++ tests/notifications-test.cc	2015-10-13 13:18:26 +0000
@@ -350,29 +350,29 @@
 
 	/* Set high volume with volume change */
 	notifications->clearNotifications();
-	volume_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), TRUE);
+	volume_control_mock_set_high_volume(VOLUME_CONTROL_MOCK(volumeControl.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("High volume", notev[0].body);
+	EXPECT_EQ("High volume can damage your hearing.", notev[0].body);
 	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
 
 	/* Move it back */
-	volume_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), FALSE);
+	volume_control_mock_set_high_volume(VOLUME_CONTROL_MOCK(volumeControl.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_control_mock_set_mock_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), TRUE);
+	volume_control_mock_set_high_volume(VOLUME_CONTROL_MOCK(volumeControl.get()), TRUE);
 	loop(50);
 	notev = notifications->getNotifications();
 	ASSERT_EQ(1, notev.size());
 	EXPECT_EQ("Volume", notev[0].summary);
-	EXPECT_EQ("High volume", notev[0].body);
+	EXPECT_EQ("High volume can damage your hearing.", notev[0].body);
 	EXPECT_GVARIANT_EQ("@s 'true'", notev[0].hints["x-canonical-value-bar-tint"]);
 }
 
@@ -406,7 +406,7 @@
 	EXPECT_EQ(1, notev.size());
 }
 
-TEST_F(NotificationsTest, ExtendendVolumeNotification) {
+TEST_F(NotificationsTest, DISABLED_ExtendendVolumeNotification) {
 	auto volumeControl = volumeControlMock();
 	auto soundService = standardService(volumeControl, playerListMock());
 
@@ -424,7 +424,7 @@
 
 	/* Allow an amplified volume */
 	notifications->clearNotifications();
-	indicator_sound_service_set_allow_amplified_volume(soundService.get(), TRUE);
+	//indicator_sound_service_set_allow_amplified_volume(soundService.get(), TRUE);
 	loop(50);
 	notev = notifications->getNotifications();
 	ASSERT_EQ(1, notev.size());
@@ -440,7 +440,7 @@
 
 	/* Put back */
 	notifications->clearNotifications();
-	indicator_sound_service_set_allow_amplified_volume(soundService.get(), FALSE);
+	//indicator_sound_service_set_allow_amplified_volume(soundService.get(), FALSE);
 	loop(50);
 	notev = notifications->getNotifications();
 	ASSERT_EQ(1, notev.size());
 
=== modified file 'tests/volume-control-mock.vala'
--- tests/volume-control-mock.vala	2015-02-17 16:54:53 +0000
+++ tests/volume-control-mock.vala	2015-10-13 13:18:26 +0000
@@ -20,12 +20,14 @@
 
 public class VolumeControlMock : VolumeControl
 {
+	private bool _high_volume = false;
+	public override bool high_volume { get { return _high_volume; } protected set { _high_volume = value; } }
+	public void set_high_volume(bool b) { high_volume = b; }
+
 	public string mock_stream { get; set; default = "multimedia"; }
 	public override string stream { get { return mock_stream; } }
 	public override bool ready { get; set; }
 	public override bool active_mic { get; set; }
-	public bool mock_high_volume { get; set; }
-	public override bool high_volume { get { return mock_high_volume; } }
 	public bool mock_mute { get; set; }
 	public override bool mute { get { return mock_mute; } }
 	public bool mock_is_playing { get; set; }
 
=== modified file 'tests/volume-control-test.cc'
--- tests/volume-control-test.cc	2015-02-09 20:14:15 +0000
+++ tests/volume-control-test.cc	2015-10-13 13:18:26 +0000
@@ -32,7 +32,11 @@
 		DbusTestService * service = NULL;
 		GDBusConnection * session = NULL;
 
-		virtual void SetUp() {
+		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);