Merge lp:~artmello/ubuntu-push/ubuntu-push-settings_notifications into lp:ubuntu-push

[Arthur Mello]

Update ubuntu-push to work wih the new Notification panel

Update ubuntu-push to work wih the new Notification panel

[system-apps-ci-bot (system-apps-ci-bot)]

FAILED: Continuous integration, rev:163
https://jenkins.canonical.com/system-apps/job/lp-ubuntu-push-ci/8/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/system-apps/job/build/915/console
    SUCCESS: https://jenkins.canonical.com/system-apps/job/build-0-fetch/915
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=vivid+overlay/825/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=xenial+overlay/825/console
    FAILURE: https://jenkins.canonical.com/system-apps/job/build-1-sourcepkg/release=yakkety/825/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/system-apps/job/lp-ubuntu-push-ci/8/rebuild

review: Needs Fixing (continuous-integration)

=== modified file 'bus/haptic/haptic.go'
--- bus/haptic/haptic.go	2015-03-05 14:09:54 +0000
+++ bus/haptic/haptic.go	2016-07-08 17:08:02 +0000
@@ -1,5 +1,5 @@
 /*
- Copyright 2014 Canonical Ltd.
+ Copyright 2014-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 version 3, as published
@@ -22,6 +22,7 @@
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/accounts"
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/click/cnotificationsettings"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -46,12 +47,27 @@
 	return &Haptic{endp, log, acc, fallback}
 }
 
+var vibrateInSilentMode = cnotificationsettings.VibrateInSilentMode
+var canUseVibrationsNotify = cnotificationsettings.CanUseVibrationsNotify
+
 // Present presents the notification via a vibrate pattern
-func (haptic *Haptic) Present(_ *click.AppId, nid string, notification *launch_helper.Notification) bool {
+func (haptic *Haptic) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
 	if notification == nil {
 		panic("please check notification is not nil before calling present")
 	}
 
+	if !canUseVibrationsNotify(app) {
+		haptic.log.Debugf("[%s] vibrate disabled by user for this app.", nid)
+		return false
+	}
+
+	if (haptic.acc.SilentMode()) {
+		if (!vibrateInSilentMode()) {
+			haptic.log.Debugf("[%s] vibrate disabled by user when in Silent Mode.", nid)
+			return false
+		}
+	}
+
 	if !haptic.acc.Vibrate() {
 		haptic.log.Debugf("[%s] vibrate disabled by user.", nid)
 		return false

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2015-12-04 15:31:27 +0000
+++ bus/notifications/raw.go	2016-07-08 17:08:02 +0000
@@ -29,6 +29,7 @@
 
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/click/cnotificationsettings"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/sounds"
@@ -127,6 +128,8 @@
 	return ch, nil
 }
 
+var canUseBubblesNotify = cnotificationsettings.CanUseBubblesNotify
+
 // Present displays a given card.
 //
 // If card.Actions is empty it's a plain, noninteractive bubble notification.
@@ -138,6 +141,16 @@
 		panic("please check notification is not nil before calling present")
 	}
 
+	if (!canUseBubblesNotify(app)) {
+		raw.log.Debugf("[%s] bubbles disabled by user for this app.", nid)
+
+		if raw.sound != nil {
+			return raw.sound.Present(app, nid, notification)
+		} else {
+			return false
+		}
+	}
+
 	card := notification.Card
 
 	if card == nil || !card.Popup || card.Summary == "" {

=== removed directory 'click/cblacklist'
=== removed file 'click/cblacklist/cblacklist.go'
--- click/cblacklist/cblacklist.go	2014-08-01 23:25:43 +0000
+++ click/cblacklist/cblacklist.go	1970-01-01 00:00:00 +0000
@@ -1,75 +0,0 @@
-/*
- Copyright 2013-2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU General Public License version 3, as published
- by the Free Software Foundation.
-
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-// Package cblacklist accesses the g_settings notification blacklist
-
-package cblacklist
-
-/*
-#cgo pkg-config: gio-unix-2.0
-#cgo pkg-config: glib-2.0
-
-#include <stdlib.h>
-#include <gio/gio.h>
-
-#define BLACKLIST_CONFIG_SCHEMA_ID "com.ubuntu.notifications.hub"
-#define BLACKLIST_KEY "blacklist"
-
-int is_blacklisted(const char *pkgname, const char *appname) {
-    static GSettings *pushSettings = NULL;
-    GVariantIter *iter;
-    gchar *pkg;
-    gchar *app;
-    int blacklisted = 0;
-
-    if (!pushSettings) {
-        GSettingsSchemaSource * source = g_settings_schema_source_get_default ();
-        if (!g_settings_schema_source_lookup (g_settings_schema_source_get_default (), BLACKLIST_CONFIG_SCHEMA_ID, TRUE)) {
-            return -1;
-        }
-        pushSettings = g_settings_new(BLACKLIST_CONFIG_SCHEMA_ID);
-    }
-    GVariant *blacklist = g_settings_get_value(pushSettings, BLACKLIST_KEY);
-    g_variant_get (blacklist, "a(ss)", &iter);
-    while (g_variant_iter_loop (iter, "(ss)", &pkg, &app)) {
-        if (0==g_strcmp0(pkg, pkgname) && 0==g_strcmp0(app, appname)) {
-            blacklisted = 1;
-            break;
-        }
-        // No need to free pkg and app, according to GVariant array example
-    }
-    g_variant_iter_free (iter);
-    g_variant_unref (blacklist);
-    return blacklisted;
-}
-
-*/
-import "C"
-
-import (
-	"unsafe"
-
-	"launchpad.net/ubuntu-push/click"
-)
-
-// IsBlacklisted returns true if the application is in the gsettings blacklist
-func IsBlacklisted(app *click.AppId) bool {
-	pkgname := C.CString(app.Package)
-	appname := C.CString(app.Application)
-	defer C.free(unsafe.Pointer(pkgname))
-	defer C.free(unsafe.Pointer(appname))
-	return C.is_blacklisted(pkgname, appname) == 1
-}

=== added directory 'click/cnotificationsettings'
=== added file 'click/cnotificationsettings/cnotificationsettings.go'
--- click/cnotificationsettings/cnotificationsettings.go	1970-01-01 00:00:00 +0000
+++ click/cnotificationsettings/cnotificationsettings.go	2016-07-08 17:08:02 +0000
@@ -0,0 +1,230 @@
+/*
+ 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 version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+*/
+
+// Package cnotificationsettings accesses the g_settings notification settings
+
+package cnotificationsettings
+
+/*
+#cgo pkg-config: gio-unix-2.0
+#cgo pkg-config: glib-2.0
+
+#include <stdlib.h>
+#include <gio/gio.h>
+
+#define NOTIFICATION_APPS_SETTINGS_SCHEMA_ID "com.ubuntu.notifications.settings.applications"
+#define VIBRATE_SILENT_MODE_KEY "vibrate-silent-mode"
+#define NOTIFICATION_SETTINGS_SCHEMA_ID "com.ubuntu.notifications.settings"
+#define SETTINGS_BASE_PATH "/com/ubuntu/NotificationSettings/"
+#define ENABLE_NOTIFICATIONS_KEY "enable-notifications"
+#define USE_SOUNDS_NOTIFICATIONS_KEY "use-sounds-notifications"
+#define USE_VIBRATIONS_NOTIFICATIONS_KEY "use-vibrations-notifications"
+#define USE_BUBBLES_NOTIFICATIONS_KEY "use-bubbles-notifications"
+#define USE_LIST_NOTIFICATIONS_KEY "use-list-notifications"
+
+GSettings* get_settings() {
+    // Check if GSettings schema exists
+    GSettingsSchemaSource *source = g_settings_schema_source_get_default();
+    if (!g_settings_schema_source_lookup(source, NOTIFICATION_APPS_SETTINGS_SCHEMA_ID, TRUE)) {
+        return NULL;
+    }
+
+    return g_settings_new(NOTIFICATION_APPS_SETTINGS_SCHEMA_ID);
+}
+
+int vibrate_in_silent_mode() {
+    GSettings *settings = NULL;
+    int vibrateInSilentMode = 0;
+
+    settings = get_settings();
+    if (!settings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(settings, VIBRATE_SILENT_MODE_KEY)) {
+        vibrateInSilentMode = 1;
+    }
+
+    g_object_unref(settings);
+    return vibrateInSilentMode;
+}
+
+GSettings* get_settings_for_app(const char *pkgname, const char *appname) {
+    GSettings *settings = NULL;
+    gchar *path;
+
+    // Check if GSettings schema exists
+    GSettingsSchemaSource *source = g_settings_schema_source_get_default();
+    if (!g_settings_schema_source_lookup(source, NOTIFICATION_SETTINGS_SCHEMA_ID, TRUE)) {
+        return NULL;
+    }
+
+    // Define notifications settings GSettings path
+    if (pkgname == "") {
+        // Use "dpkg" as package name for legacy apps
+        path = g_strconcat(SETTINGS_BASE_PATH, "dpkg/", appname, "/", NULL);
+    } else {
+        path = g_strconcat(SETTINGS_BASE_PATH, pkgname, "/", appname, "/", NULL);
+    }
+
+    settings = g_settings_new_with_path(NOTIFICATION_SETTINGS_SCHEMA_ID, path);
+    g_free(path);
+
+    return settings;
+}
+
+int are_notifications_enabled(const char *pkgname, const char *appname) {
+    GSettings *notificationSettings = NULL;
+    int enableNotifications = 0;
+
+    notificationSettings = get_settings_for_app(pkgname, appname);
+    if (!notificationSettings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(notificationSettings, ENABLE_NOTIFICATIONS_KEY)) {
+        enableNotifications = 1;
+    }
+
+    g_object_unref(notificationSettings);
+    return enableNotifications;
+}
+
+int can_use_sounds_notify(const char *pkgname, const char *appname) {
+    GSettings *notificationSettings = NULL;
+    int soundsNotify = 0;
+
+    notificationSettings = get_settings_for_app(pkgname, appname);
+    if (!notificationSettings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(notificationSettings, USE_SOUNDS_NOTIFICATIONS_KEY)) {
+        soundsNotify = 1;
+    }
+
+    g_object_unref(notificationSettings);
+    return soundsNotify;
+}
+
+int can_use_vibrations_notify(const char *pkgname, const char *appname) {
+    GSettings *notificationSettings = NULL;
+    int vibrationsNotify = 0;
+
+    notificationSettings = get_settings_for_app(pkgname, appname);
+    if (!notificationSettings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(notificationSettings, USE_VIBRATIONS_NOTIFICATIONS_KEY)) {
+        vibrationsNotify = 1;
+    }
+
+    g_object_unref(notificationSettings);
+    return vibrationsNotify;
+}
+
+int can_use_bubbles_notify(const char *pkgname, const char *appname) {
+    GSettings *notificationSettings = NULL;
+    int bubblesNotify = 0;
+
+    notificationSettings = get_settings_for_app(pkgname, appname);
+    if (!notificationSettings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(notificationSettings, USE_BUBBLES_NOTIFICATIONS_KEY)) {
+        bubblesNotify = 1;
+    }
+
+    g_object_unref(notificationSettings);
+    return bubblesNotify;
+}
+
+int can_use_list_notify(const char *pkgname, const char *appname) {
+    GSettings *notificationSettings = NULL;
+    int listNotify = 0;
+
+    notificationSettings = get_settings_for_app(pkgname, appname);
+    if (!notificationSettings) {
+        return -1;
+    }
+
+    if (g_settings_get_boolean(notificationSettings, USE_LIST_NOTIFICATIONS_KEY)) {
+        listNotify = 1;
+    }
+
+    g_object_unref(notificationSettings);
+    return listNotify;
+}
+*/
+import "C"
+
+import (
+	"unsafe"
+
+	"launchpad.net/ubuntu-push/click"
+)
+
+// VibrateInSilentMode returns true if applications can use vibrations notify when in silent mode
+func VibrateInSilentMode() bool {
+	return C.vibrate_in_silent_mode() != 0
+}
+
+// AreNotificationsEnabled returns true if the application is marked on gsettings to use notifications
+func AreNotificationsEnabled(app *click.AppId) bool {
+	pkgname := C.CString(app.Package)
+	appname := C.CString(app.Application)
+	defer C.free(unsafe.Pointer(pkgname))
+	defer C.free(unsafe.Pointer(appname))
+	return C.are_notifications_enabled(pkgname, appname) != 0
+}
+
+// CanUseSoundsNotify returns true if the application is marked on gsettings to use sounds notify
+func CanUseSoundsNotify(app *click.AppId) bool {
+	pkgname := C.CString(app.Package)
+	appname := C.CString(app.Application)
+	defer C.free(unsafe.Pointer(pkgname))
+	defer C.free(unsafe.Pointer(appname))
+	return C.can_use_sounds_notify(pkgname, appname) != 0
+}
+
+// CanUseVibrationsNotify returns true if the application is marked on gsettings to use vibrations notify
+func CanUseVibrationsNotify(app *click.AppId) bool {
+	pkgname := C.CString(app.Package)
+	appname := C.CString(app.Application)
+	defer C.free(unsafe.Pointer(pkgname))
+	defer C.free(unsafe.Pointer(appname))
+	return C.can_use_vibrations_notify(pkgname, appname) != 0
+}
+
+// CanUseBubblesNotify returns true if the application is marked on gsettings to use bubbles notify
+func CanUseBubblesNotify(app *click.AppId) bool {
+	pkgname := C.CString(app.Package)
+	appname := C.CString(app.Application)
+	defer C.free(unsafe.Pointer(pkgname))
+	defer C.free(unsafe.Pointer(appname))
+	return C.can_use_bubbles_notify(pkgname, appname) != 0
+}
+
+// CanUseListNotify returns true if the application is marked on gsettings to use list notificy
+func CanUseListNotify(app *click.AppId) bool {
+	pkgname := C.CString(app.Package)
+	appname := C.CString(app.Application)
+	defer C.free(unsafe.Pointer(pkgname))
+	defer C.free(unsafe.Pointer(appname))
+	return C.can_use_list_notify(pkgname, appname) != 0
+}

=== modified file 'client/service/postal.go'
--- client/service/postal.go	2015-12-04 15:31:27 +0000
+++ client/service/postal.go	2016-07-08 17:08:02 +0000
@@ -31,7 +31,7 @@
 	"launchpad.net/ubuntu-push/bus/unitygreeter"
 	"launchpad.net/ubuntu-push/bus/windowstack"
 	"launchpad.net/ubuntu-push/click"
-	"launchpad.net/ubuntu-push/click/cblacklist"
+	"launchpad.net/ubuntu-push/click/cnotificationsettings"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/messaging"
@@ -416,7 +416,7 @@
 	return svc.urlDispatcher.TestURL(app, notif.Card.Actions)
 }
 
-var isBlacklisted = cblacklist.IsBlacklisted
+var areNotificationsEnabled = cnotificationsettings.AreNotificationsEnabled
 
 func (svc *PostalService) messageHandler(app *click.AppId, nid string, output *launch_helper.HelperOutput) bool {
 	if output == nil || output.Notification == nil {
@@ -437,8 +437,8 @@
 		return false
 	}
 
-	if isBlacklisted(app) {
-		svc.Log.Debugf("notification skipped (except emblem counter) because app is blacklisted")
+	if !areNotificationsEnabled(app) {
+		svc.Log.Debugf("notification skipped (except emblem counter) because app has notifications disabled")
 		return svc.emblemCounter.Present(app, nid, output.Notification)
 	}
 

=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2016-05-03 11:12:44 +0000
+++ client/service/postal_test.go	2016-07-08 17:08:02 +0000
@@ -175,8 +175,8 @@
 	accountsCh      chan []interface{}
 	fakeLauncher    *fakeHelperLauncher
 	getTempDir      func(string) (string, error)
-	oldIsBlisted    func(*click.AppId) bool
-	blacklisted     bool
+	oldAreEnabled   func(*click.AppId) bool
+	notifyEnabled   bool
 }
 
 type ualPostalSuite struct {
@@ -191,8 +191,8 @@
 var _ = Suite(&trivialPostalSuite{})
 
 func (ps *postalSuite) SetUpTest(c *C) {
-	ps.oldIsBlisted = isBlacklisted
-	isBlacklisted = func(*click.AppId) bool { return ps.blacklisted }
+	ps.oldAreEnabled = areNotificationsEnabled
+	areNotificationsEnabled = func(*click.AppId) bool { return ps.notifyEnabled }
 	ps.log = helpers.NewTestLogger(c, "debug")
 	ps.cfg = &PostalServiceSetup{}
 	ps.bus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
@@ -209,7 +209,7 @@
 	ps.unityGreeterBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), false)
 	ps.winStackBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []windowstack.WindowsInfo{})
 	ps.fakeLauncher = &fakeHelperLauncher{ch: make(chan []byte)}
-	ps.blacklisted = false
+	ps.notifyEnabled = true
 
 	ps.getTempDir = launch_helper.GetTempDir
 	d := c.MkDir()
@@ -223,7 +223,7 @@
 }
 
 func (ps *postalSuite) TearDownTest(c *C) {
-	isBlacklisted = ps.oldIsBlisted
+	areNotificationsEnabled = ps.oldAreEnabled
 	launch_helper.GetTempDir = ps.getTempDir
 	close(ps.accountsCh)
 }
@@ -866,19 +866,19 @@
 	ps.unityGreeterBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), false, false, false, false)
 	svc := ps.replaceBuses(NewPostalService(ps.cfg, ps.log))
 	svc.Start()
-	ps.blacklisted = false
+	ps.notifyEnabled = true
 
 	emb := &launch_helper.EmblemCounter{Count: 2, Visible: true}
 	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Persist: true}
 	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: card}}
 	embOut := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{EmblemCounter: emb}}
 	app := clickhelp.MustParseAppId("com.example.app_app_1.0")
-	// sanity check: things are presented as normal if blacklist == false
-	ps.blacklisted = false
+	// sanity check: things are presented as normal if notifyEnabled == true
+	ps.notifyEnabled = true
 	c.Check(svc.messageHandler(app, "0", output), Equals, true)
 	c.Check(svc.messageHandler(app, "1", embOut), Equals, true)
-	ps.blacklisted = true
-	// and regular notifications (but not emblem counters) are suppressed if blacklisted.
+	ps.notifyEnabled = false
+	// and regular notifications (but not emblem counters) are suppressed if notifications are disabled.
 	c.Check(svc.messageHandler(app, "2", output), Equals, false)
 	c.Check(svc.messageHandler(app, "3", embOut), Equals, true)
 }

=== modified file 'debian/push-helper.hook'
--- debian/push-helper.hook	2014-07-29 20:41:34 +0000
+++ debian/push-helper.hook	2016-07-08 17:08:02 +0000
@@ -1,4 +1,4 @@
 Pattern: ${home}/.local/share/ubuntu-push-client/helpers/${id}.json
 User-Level: yes
 Hook-Name: push-helper
-Exec: /usr/lib/ubuntu-push-client/click-hook
+Exec: /usr/lib/ubuntu-push-client/click-hook-wrapper

=== modified file 'debian/ubuntu-push-client.install'
--- debian/ubuntu-push-client.install	2014-08-12 02:31:51 +0000
+++ debian/ubuntu-push-client.install	2016-07-08 17:08:02 +0000
@@ -4,6 +4,7 @@
 debian/exec-tool /usr/lib/${DEB_HOST_MULTIARCH}/ubuntu-app-launch/push-helper
 debian/push-helper.hook /usr/share/click/hooks
 signing-helper/signing-helper /usr/lib/ubuntu-push-client
+scripts/click-hook-wrapper /usr/lib/ubuntu-push-client
 scripts/click-hook /usr/lib/ubuntu-push-client
 usr/bin/ubuntu-push => /usr/lib/ubuntu-push-client/ubuntu-push-client
 

=== modified file 'messaging/messaging.go'
--- messaging/messaging.go	2015-08-13 19:59:45 +0000
+++ messaging/messaging.go	2016-07-08 17:08:02 +0000
@@ -25,6 +25,7 @@
 
 	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/click/cnotificationsettings"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/messaging/cmessaging"
@@ -143,11 +144,18 @@
 	return len(nids)
 }
 
+var canUseListNotify = cnotificationsettings.CanUseListNotify
+
 func (mmu *MessagingMenu) Present(app *click.AppId, nid string, notification *launch_helper.Notification) bool {
 	if notification == nil {
 		panic("please check notification is not nil before calling present")
 	}
 
+	if !canUseListNotify(app) {
+		mmu.Log.Debugf("[%s] list notify disabled by user for this app.", nid)
+		return false
+	}
+
 	card := notification.Card
 
 	if card == nil || !card.Persist || card.Summary == "" {

=== modified file 'scripts/click-hook'
--- scripts/click-hook	2015-04-01 14:46:20 +0000
+++ scripts/click-hook	2016-07-08 17:08:02 +0000
@@ -17,38 +17,24 @@
 hook_ext = '.json'
 
 
-def tup2variant(tup):
-    builder = GLib.VariantBuilder.new(GLib.VariantType.new("(ss)"))
-    builder.add_value(GLib.Variant.new_string(tup[0]))
-    builder.add_value(GLib.Variant.new_string(tup[1]))
-    return builder.end()
-
-
-def cleanup_settings():
-    settings = Gio.Settings.new('com.ubuntu.notifications.hub')
-    blacklist = settings.get_value('blacklist').unpack()
+def migrate_old_settings():
+    old_settings = Gio.Settings.new('com.ubuntu.notifications.hub')
+    blacklist = old_settings.get_value('blacklist').unpack()
     if not blacklist:
         return
 
-    clickdb = Click.DB.new()
-    clickdb.read()
-
-    pkgnames = set()
-    for package in clickdb.get_packages(False):
-        pkgnames.add(package.get_property('package'))
-
-    goodapps = GLib.VariantBuilder.new(GLib.VariantType.new("a(ss)"))
-
-    dirty = False
-
-    for appname in blacklist:
-        if appname[0] not in pkgnames and Gio.DesktopAppInfo.new(appname[1] + ".desktop") is None:
-            dirty = True
-        else:
-            goodapps.add_value(tup2variant(appname))
-
-    if dirty:
-        settings.set_value('blacklist', goodapps.end())
+    old_settings.reset('blacklist')
+
+    for app in blacklist:
+        app_key = app[0] + '/'
+        if not app[0]:
+            app_key = 'dpkg/'
+         
+        app_key += app[1]
+
+        settings_path = '/com/ubuntu/NotificationSettings/' + app_key + '/'
+        settings = Gio.Settings.new_with_path('com.ubuntu.notifications.settings', settings_path)
+        settings.set_boolean('enable-notifications', False)
 
 
 def collect_helpers(helpers_data_path, helpers_data_path_tmp, hooks_path):
@@ -92,15 +78,107 @@
     return False
 
 
+def populate_settings_from_legacy_dpkg():
+    dpkg_apps_keys = list()
+    legacy_helpers_path = '/usr/lib/ubuntu-push-client/legacy-helpers/'
+    if os.path.isdir(legacy_helpers_path):
+        for f in os.listdir(legacy_helpers_path):
+            if not os.path.isfile(os.path.join(legacy_helpers_path, f)):
+                break
+
+            dpkg_app_key = '/'.join(['dpkg', f, '0'])
+            dpkg_apps_keys.append(dpkg_app_key)
+
+    return dpkg_apps_keys
+
+
+def reset_settings(path=None):
+    if not path:
+        return
+
+    settings_path = '/com/ubuntu/NotificationSettings/' + path + '/'
+    try:
+        settings = Gio.Settings.new_with_path('com.ubuntu.notifications.settings', settings_path)
+        for k in settings.list_keys():
+            settings.reset(k)
+    except Exception:
+        pass
+
+
+def reset_removed_applications(current_apps=None, new_apps=None):
+    if not current_apps or not new_apps:
+        return
+
+    current_keys = list()
+    for k in current_apps:
+        key = '/'.join(k.split('/')[:2])
+        current_keys.append(key)
+
+    new_keys = list()
+    for k in new_apps:
+        key = '/'.join(k.split('/')[:2])
+        new_keys.append(key)
+
+    for settings_path in set(current_keys) - set(new_keys):
+        reset_settings(settings_path)
+
+
+def populate_notifications_settings(hooks_path=None):
+    if not hooks_path or not os.path.isdir(hooks_path):
+        return
+
+    db = Click.DB.new()
+    db.read()
+
+    settings = Gio.Settings.new('com.ubuntu.notifications.settings.applications')
+    applications = GLib.VariantBuilder.new(GLib.VariantType.new('as'))
+
+    current_applications_keys = settings.get_value('applications').unpack()
+
+    applications_keys = list()
+    applications_keys += populate_settings_from_legacy_dpkg()
+    for hook in os.listdir(hooks_path):
+        helper_id = os.path.splitext(hook)[0]
+        pkg_name, helper_name, version = helper_id.split('_')
+
+        manifest = json.loads(db.get_manifest_as_string(pkg_name, version))
+        hooks = manifest.get('hooks', None)
+        if not hooks:
+            continue
+
+        app_names = list()
+        for h in hooks.keys():
+            if 'desktop' in hooks[h].keys():
+                app_names.append(h)
+
+        for app_name in app_names:
+            app_key = '/'.join([pkg_name, app_name, version])
+            applications_keys.append(app_key)
+
+    for app_key in applications_keys:
+        applications.add_value(GLib.Variant.new_string(app_key))
+
+    settings.set_value('applications', applications.end())
+
+    reset_removed_applications(current_applications_keys, applications_keys)
+
+
 def main(helpers_data_path=None, helpers_data_path_tmp=None, hooks_path=None):
     collect_fail = collect_helpers(helpers_data_path, helpers_data_path_tmp,
                                    hooks_path)
-    clean_settings_fail = False
-    try:
-        cleanup_settings()
-    except Exception:
-        clean_settings_fail = True
-    return int(collect_fail or clean_settings_fail)
+    migrate_old_settings_fail = False
+    try:
+        migrate_old_settings()
+    except Exception:
+        migrate_old_settings_fail = True
+
+    populate_settings_fail = False
+    try:
+        populate_notifications_settings(hooks_path)
+    except Exception:
+        populate_settings_fail = True
+
+    return int(collect_fail or migrate_old_settings_fail or populate_settings_fail)
 
 
 if __name__ == "__main__":

=== added file 'scripts/click-hook-wrapper'
--- scripts/click-hook-wrapper	1970-01-01 00:00:00 +0000
+++ scripts/click-hook-wrapper	2016-07-08 17:08:02 +0000
@@ -0,0 +1,13 @@
+#!/bin/sh  
+                                                                   
+# PackageKit clears all environment variables, so we get the UID and then read
+# in $DBUS_SESSION_BUS_ADDRESS from /run/user/$UID/dbus-session    
+
+USERID=`id -u`                                                     
+
+if test -z "$DBUS_SESSION_BUS_ADDRESS" ; then                      
+  [ -e /run/user/$USERID/dbus-session ] && . /run/user/$USERID/dbus-session 
+  [ -n "$DBUS_SESSION_BUS_ADDRESS" ] && export DBUS_SESSION_BUS_ADDRESS 
+fi
+  
+/usr/lib/ubuntu-push-client/click-hook

=== modified file 'sounds/sounds.go'
--- sounds/sounds.go	2015-12-04 15:31:27 +0000
+++ sounds/sounds.go	2016-07-08 17:08:02 +0000
@@ -27,6 +27,7 @@
 
 	"launchpad.net/ubuntu-push/bus/accounts"
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/click/cnotificationsettings"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -84,8 +85,14 @@
 	return true
 }
 
+var canUseSoundsNotify = cnotificationsettings.CanUseSoundsNotify
+
 // Returns the absolute path of the sound to be played for app, nid and notification.
 func (snd *sound) GetSound(app *click.AppId, nid string, notification *launch_helper.Notification) string {
+	if !canUseSoundsNotify(app) {
+		snd.log.Debugf("[%s] sounds disabled by user for this app.", nid)
+		return ""
+	}
 
 	if snd.acc.SilentMode() {
 		snd.log.Debugf("[%s] no sounds: silent mode on.", nid)