Merge lp:~artmello/indicator-datetime/indicator-datetime-notfication_settings into lp:indicator-datetime

[Arthur Mello]

Update indicator-datetime to work with the new notification settings

Update indicator-datetime to work with the new notification settings

[Charles Kerr (charlesk)]

Haven't tested, but code LGTM. A couple of optional minor suggestions inline.

The biggest takeaway that I'm getting from this patch is the gsettings-propertiescpp bridge code is too brittle. That's not new to this patch and isn't your problem; it's just become worse over time as we add more settings and I'll clean it up in a followup patch.

review: Approve

[Charles Kerr (charlesk)]

I don't understand the point of r456/r457 and would prefer they be backed out altogether. Surely the gsettings schema should be a hard requirement for us?

review: Needs Information

[lp:~artmello/indicator-datetime/indicator-datetime-notfication_settings]

458. By Arthur Mello on 2016-06-30

Undo revisions 456/457

459. By Arthur Mello on 2016-06-30

Fix notifications so it respects if it should or not show bubbles or add to notification list

[Arthur Mello (artmello)]

> I don't understand the point of r456/r457 and would prefer they be backed out
> altogether. Surely the gsettings schema should be a hard requirement for us?

r458 reverted both r456 and r457 and unittests run fine on device (krillin, rc-proposed r369). This was added to silo 54 and, unfortunately, its build fails under all archs for Vivid, Xenial and Yakkety. Log file [0] for armhf/vivid (but the same error happens on all of them) shows that test-settings is failing with an exception related with missing 'com.canonical.indicator.datetime' gsetting schema. When we instantiate LiveSettings on that test, it will try to open the settings using that schema and that is causing the crash. Idea with r456/r457 was to lookup for the schema and skip settings test if it was missing. Any suggestions on how can we fix this build?

[0] https://launchpadlibrarian.net/268720228/buildlog_ubuntu-vivid-armhf.indicator-datetime_15.10+15.04.20160630-0ubuntu1_BUILDING.txt.gz

[Arthur Mello (artmello)]

Also r459 fix the control for displaying notification bubbles and adding notifications to messaging menu. Let me know what you think about it

[Charles Kerr (charlesk)]

> exception related with missing 'com.canonical.indicator.datetime' gsetting schema... any suggestions on how can we fix this build?

That's strange, tests/CMakeLists.txt already has rules in it to ensure the tests can find the schema, and this has been passing up until now.

Off the top of my head I don't know what's going wrong here. I'll see if I can reproduce in a vivid chroot that doesn't have indicator-datetime installed.

A couple of questions about schema lookups are inline below

review: Needs Information

[Arthur Mello (artmello)]

> That's strange, tests/CMakeLists.txt already has rules in it to ensure the
> tests can find the schema, and this has been passing up until now.
>
> Off the top of my head I don't know what's going wrong here. I'll see if I can
> reproduce in a vivid chroot that doesn't have indicator-datetime installed.

Yes, we were trying to find out what could be causing this after the changes on this MR but didnt find it yet.

> A couple of questions about schema lookups are inline below

I answered those

[Charles Kerr (charlesk)]

100% reproducible for me in a vivid chroot. One interesting clue, test-utils loads the same com.canonical.indicator.datetime schema, and /that/ test is passing. They use two different code paths to get there though. I feel like there's something simple here that we're both missing, so I'll stare at the screen a little more. :)

Thanks for explaining the plan with the relocatable schema, that part LGTM.

[Charles Kerr (charlesk)]

Okay, got a fix for it at http://paste.ubuntu.com/18201522/

The issue is that creating 'source' before calling SetUp() causes glib's schema search path to be created before GLibFixture::SetUp() sets the GSETTINGS_SEARCH_DIR environment variable to prepend our sandbox to the schema search path.

So, that's progress. After that fix I get a new & improved failure:
"Settings schema 'com.ubuntu.notifications.settings' is not installed"

Which I think is more straightforward, I think for /that/ I think we just need to add gsettings-ubuntu-touch-schemes (>= your-version-number) to debian/control

[lp:~artmello/indicator-datetime/indicator-datetime-notfication_settings]

460. By Arthur Mello on 2016-07-01

Do not fail gracefully if gsettings schema is not installed

461. By Arthur Mello on 2016-07-01

Remove gsettings source call during unit tests
Set minimal version for gsettings-ubuntu-touch-schemas package

462. By Arthur Mello on 2016-07-01

Only wake device if bubbles notifications are enabled

463. By Arthur Mello on 2016-07-04

If in silent mode should only vibrate if the settings say so

464. By Arthur Mello on 2016-07-04

Should not use sounds notifications for calendar in silent mode

[Charles Kerr (charlesk)]

LGTM. Thanks Art :-)

review: Approve

=== modified file 'debian/control'
--- debian/control	2016-05-14 02:07:10 +0000
+++ debian/control	2016-07-04 23:46:11 +0000
@@ -15,7 +15,7 @@
                liburl-dispatcher1-dev,
                libproperties-cpp-dev,
 # for com.ubuntu.notifications.hub schema to pick up blacklist of apps that can't show notifications
-               gsettings-ubuntu-schemas,
+               gsettings-ubuntu-schemas (>= 0.0.7),
 # for the test harness:
                libgtest-dev,
                libdbustest1-dev,
@@ -47,7 +47,7 @@
 Architecture: any
 Depends: ${shlibs:Depends}, 
          ${misc:Depends},
-         gsettings-ubuntu-schemas,
+         gsettings-ubuntu-schemas (>= 0.0.7),
          systemd | systemd-shim,
 Recommends: indicator-applet | indicator-renderer,
             evolution-data-server,
 
=== modified file 'include/datetime/settings-live.h'
--- include/datetime/settings-live.h	2016-02-02 00:07:18 +0000
+++ include/datetime/settings-live.h	2016-07-04 23:46:11 +0000
@@ -39,9 +39,11 @@
 
 private:
     static void on_changed_ccid(GSettings*, gchar*, gpointer);
-    static void on_changed_cunh(GSettings*, gchar*, gpointer);
+    static void on_changed_cal_notification(GSettings*, gchar*, gpointer);
+    static void on_changed_general_notification(GSettings*, gchar*, gpointer);
     void update_key_ccid(const std::string& key);
-    void update_key_cunh(const std::string& key);
+    void update_key_cal_notification(const std::string& key);
+    void update_key_general_notification(const std::string& key);
 
     void update_custom_time_format();
     void update_locations();
@@ -63,10 +65,16 @@
     void update_alarm_duration();
     void update_alarm_haptic();
     void update_snooze_duration();
-    void update_muted_apps();
+    void update_cal_notification_enabled();
+    void update_cal_notification_sounds();
+    void update_cal_notification_vibrations();
+    void update_cal_notification_bubbles();
+    void update_cal_notification_list();
+    void update_vibrate_silent_mode();
 
     GSettings* m_settings;
-    GSettings* m_settings_cunh;
+    GSettings* m_settings_cal_notification;
+    GSettings* m_settings_general_notification;
 
     // we've got a raw pointer here, so disable copying
     LiveSettings(const LiveSettings&) =delete;
 
=== modified file 'include/datetime/settings-shared.h'
--- include/datetime/settings-shared.h	2016-02-02 00:07:18 +0000
+++ include/datetime/settings-shared.h	2016-07-04 23:46:11 +0000
@@ -52,7 +52,14 @@
 #define SETTINGS_ALARM_HAPTIC_S         "alarm-haptic-feedback"
 #define SETTINGS_SNOOZE_DURATION_S      "snooze-duration-minutes"
 
-#define SETTINGS_CUNH_SCHEMA_ID         "com.ubuntu.notifications.hub"
-#define SETTINGS_CUNH_BLACKLIST_S       "blacklist"
+#define SETTINGS_NOTIFY_APPS_SCHEMA_ID  "com.ubuntu.notifications.settings.applications"
+#define SETTINGS_VIBRATE_SILENT_KEY     "vibrate-silent-mode"
+#define SETTINGS_NOTIFY_SCHEMA_ID       "com.ubuntu.notifications.settings"
+#define SETTINGS_NOTIFY_CALENDAR_PATH   "/com/ubuntu/NotificationSettings/com.ubuntu.calendar/calendar/"
+#define SETTINGS_NOTIFY_ENABLED_KEY     "enable-notifications"
+#define SETTINGS_NOTIFY_SOUNDS_KEY      "use-sounds-notifications"
+#define SETTINGS_NOTIFY_VIBRATIONS_KEY  "use-vibrations-notifications"
+#define SETTINGS_NOTIFY_BUBBLES_KEY     "use-bubbles-notifications"
+#define SETTINGS_NOTIFY_LIST_KEY        "use-list-notifications"
 
 #endif // INDICATOR_DATETIME_SETTINGS_SHARED
 
=== modified file 'include/datetime/settings.h'
--- include/datetime/settings.h	2016-02-02 00:05:45 +0000
+++ include/datetime/settings.h	2016-07-04 23:46:11 +0000
@@ -62,7 +62,12 @@
     core::Property<unsigned int> alarm_volume;
     core::Property<unsigned int> alarm_duration;
     core::Property<unsigned int> snooze_duration;
-    core::Property<std::set<std::pair<std::string,std::string>>> muted_apps;
+    core::Property<bool> cal_notification_enabled;
+    core::Property<bool> cal_notification_sounds;
+    core::Property<bool> cal_notification_vibrations;
+    core::Property<bool> cal_notification_bubbles;
+    core::Property<bool> cal_notification_list;
+    core::Property<bool> vibrate_silent_mode;
 };
 
 } // namespace datetime
 
=== modified file 'include/notifications/notifications.h'
--- include/notifications/notifications.h	2016-05-14 02:07:10 +0000
+++ include/notifications/notifications.h	2016-07-04 23:46:11 +0000
@@ -77,6 +77,12 @@
     /** Sets the time-out callback. This will be called exactly once. */
     void set_timeout_callback (std::function<void()>);
 
+    /** Sets if a notification bubble should be displayed. */
+    void set_show_notification_bubble (bool show);
+
+    /** Sets if notification should be posted to messaging menu after it is closed. */
+    void set_post_to_messaging_menu (bool post);
+
 
 private:
     friend class Engine;
 
=== modified file 'src/notifications.cpp'
--- src/notifications.cpp	2016-05-14 02:07:10 +0000
+++ src/notifications.cpp	2016-07-04 23:46:11 +0000
@@ -61,6 +61,8 @@
     std::vector<std::pair<std::string,std::string>> m_actions;
     std::function<void(const std::string&)> m_closed_callback;
     std::function<void()> m_timeout_callback;
+    bool m_show_notification_bubble;
+    bool m_post_to_messaging_menu;
 };
 
 Builder::Builder():
@@ -126,6 +128,18 @@
   impl->m_start_time = time;
 }
 
+void
+Builder::set_show_notification_bubble (bool show)
+{
+  impl->m_show_notification_bubble = show;
+}
+
+void
+Builder::set_post_to_messaging_menu (bool post)
+{
+  impl->m_post_to_messaging_menu = post;
+}
+
 /***
 ****
 ***/
@@ -262,7 +276,12 @@
         m_notifications[key] = { nn, info };
         g_signal_connect (nn.get(), "closed",
                           G_CALLBACK(on_notification_closed), this);
-     
+
+        if (!info.m_show_notification_bubble) {
+            post(info);
+            return ret;
+        }
+
         GError * error = nullptr;
         if (notify_notification_show(nn.get(), &error))
         {
@@ -282,6 +301,10 @@
 
     std::string post(const Builder::Impl& data)
     {
+        if (!data.m_post_to_messaging_menu) {
+            return "";
+        }
+
         if (!m_messaging_app) {
             return std::string();
         }
 
=== modified file 'src/settings-live.cpp'
--- src/settings-live.cpp	2016-02-03 20:25:19 +0000
+++ src/settings-live.cpp	2016-07-04 23:46:11 +0000
@@ -29,16 +29,20 @@
 
 LiveSettings::~LiveSettings()
 {
-    g_clear_object(&m_settings_cunh);
+    g_clear_object(&m_settings_general_notification);
+    g_clear_object(&m_settings_cal_notification);
     g_clear_object(&m_settings);
 }
 
 LiveSettings::LiveSettings():
     m_settings(g_settings_new(SETTINGS_INTERFACE)),
-    m_settings_cunh(g_settings_new(SETTINGS_CUNH_SCHEMA_ID))
+    m_settings_cal_notification(g_settings_new_with_path(SETTINGS_NOTIFY_SCHEMA_ID, SETTINGS_NOTIFY_CALENDAR_PATH)),
+    m_settings_general_notification(g_settings_new(SETTINGS_NOTIFY_APPS_SCHEMA_ID))
 {
-    g_signal_connect (m_settings,      "changed", G_CALLBACK(on_changed_ccid), this);
-    g_signal_connect (m_settings_cunh, "changed", G_CALLBACK(on_changed_cunh), this);
+
+    g_signal_connect (m_settings,                      "changed", G_CALLBACK(on_changed_ccid), this);
+    g_signal_connect (m_settings_cal_notification,     "changed", G_CALLBACK(on_changed_cal_notification), this);
+    g_signal_connect (m_settings_general_notification, "changed", G_CALLBACK(on_changed_general_notification), this);
 
     // init the Properties from the GSettings backend
     update_custom_time_format();
@@ -61,7 +65,12 @@
     update_alarm_duration();
     update_alarm_haptic();
     update_snooze_duration();
-    update_muted_apps();
+    update_cal_notification_enabled();
+    update_cal_notification_sounds();
+    update_cal_notification_vibrations();
+    update_cal_notification_bubbles();
+    update_cal_notification_list();
+    update_vibrate_silent_mode();
 
     // now listen for clients to change the properties s.t. we can sync update GSettings
 
@@ -69,17 +78,6 @@
         g_settings_set_string(m_settings, SETTINGS_CUSTOM_TIME_FORMAT_S, value.c_str());
     });
 
-    muted_apps.changed().connect([this](const std::set<std::pair<std::string,std::string>>& value){
-        GVariantBuilder builder;
-        g_variant_builder_init(&builder, G_VARIANT_TYPE("a(ss)"));
-        for(const auto& app : value){
-            const std::string& pkgname {app.first};
-            const std::string& appname {app.second};
-            g_variant_builder_add(&builder, "(ss)", pkgname.c_str(), appname.c_str());
-        }
-        g_settings_set_value(m_settings_cunh, SETTINGS_CUNH_BLACKLIST_S, g_variant_builder_end(&builder));
-    });
-
     locations.changed().connect([this](const std::vector<std::string>& value){
         const int n = value.size();
         gchar** strv = g_new0(gchar*, n+1);
@@ -160,6 +158,30 @@
     snooze_duration.changed().connect([this](unsigned int value){
         g_settings_set_uint(m_settings, SETTINGS_SNOOZE_DURATION_S, value);
     });
+
+    cal_notification_enabled.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_ENABLED_KEY, value);
+    });
+
+    cal_notification_sounds.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_SOUNDS_KEY, value);
+    });
+
+    cal_notification_vibrations.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_VIBRATIONS_KEY, value);
+    });
+
+    cal_notification_bubbles.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_BUBBLES_KEY, value);
+    });
+
+    cal_notification_list.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_LIST_KEY, value);
+    });
+
+    vibrate_silent_mode.changed().connect([this](bool value){
+        g_settings_set_boolean(m_settings_general_notification, SETTINGS_VIBRATE_SILENT_KEY, value);
+    });
 }
 
 /***
@@ -183,24 +205,6 @@
     locations.set(l);
 }
 
-void LiveSettings::update_muted_apps()
-{
-    std::set<std::pair<std::string,std::string>> apps;
-
-    auto blacklist = g_settings_get_value(m_settings_cunh, SETTINGS_CUNH_BLACKLIST_S);
-    GVariantIter* iter {nullptr};
-    g_variant_get (blacklist, "a(ss)", &iter);
-    gchar* pkgname;
-    gchar* appname;
-    while (g_variant_iter_loop (iter, "(ss)", &pkgname, &appname)) {
-        apps.insert(std::make_pair(pkgname,appname));
-    }
-    g_variant_iter_free (iter);
-    g_clear_pointer(&blacklist, g_variant_unref);
-
-    muted_apps.set(apps);
-}
-
 void LiveSettings::update_show_calendar()
 {
     const auto val = g_settings_get_boolean(m_settings, SETTINGS_SHOW_CALENDAR_S);
@@ -304,21 +308,77 @@
     snooze_duration.set(g_settings_get_uint(m_settings, SETTINGS_SNOOZE_DURATION_S));
 }
 
-/***
-****
-***/
-
-void LiveSettings::on_changed_cunh(GSettings* /*settings*/,
-                                   gchar*       key,
-                                   gpointer     gself)
-{
-    static_cast<LiveSettings*>(gself)->update_key_cunh(key);
-}
-
-void LiveSettings::update_key_cunh(const std::string& key)
-{
-    if (key == SETTINGS_CUNH_BLACKLIST_S)
-        update_muted_apps();
+void LiveSettings::update_cal_notification_enabled()
+{
+    cal_notification_enabled.set(g_settings_get_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_ENABLED_KEY));
+}
+
+void LiveSettings::update_cal_notification_sounds()
+{
+    cal_notification_sounds.set(g_settings_get_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_SOUNDS_KEY));
+}
+
+void LiveSettings::update_cal_notification_vibrations()
+{
+    cal_notification_vibrations.set(g_settings_get_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_VIBRATIONS_KEY));
+}
+
+void LiveSettings::update_cal_notification_bubbles()
+{
+    cal_notification_bubbles.set(g_settings_get_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_BUBBLES_KEY));
+}
+
+void LiveSettings::update_cal_notification_list()
+{
+    cal_notification_list.set(g_settings_get_boolean(m_settings_cal_notification, SETTINGS_NOTIFY_LIST_KEY));
+}
+
+void LiveSettings::update_vibrate_silent_mode()
+{
+    vibrate_silent_mode.set(g_settings_get_boolean(m_settings_general_notification, SETTINGS_VIBRATE_SILENT_KEY));
+}
+
+/***
+****
+***/
+
+void LiveSettings::on_changed_cal_notification(GSettings* /*settings*/,
+                                               gchar*     key,
+                                               gpointer   gself)
+{
+    static_cast<LiveSettings*>(gself)->update_key_cal_notification(key);
+}
+
+
+void LiveSettings::update_key_cal_notification(const std::string& key)
+{
+    if (key == SETTINGS_NOTIFY_ENABLED_KEY)
+        update_cal_notification_enabled();
+    else if (key == SETTINGS_NOTIFY_SOUNDS_KEY)
+        update_cal_notification_sounds();
+    else if (key == SETTINGS_NOTIFY_VIBRATIONS_KEY)
+        update_cal_notification_vibrations();
+    else if (key == SETTINGS_NOTIFY_BUBBLES_KEY)
+        update_cal_notification_bubbles();
+    else if (key == SETTINGS_NOTIFY_LIST_KEY)
+        update_cal_notification_list();
+}
+
+/***
+****
+***/
+
+void LiveSettings::on_changed_general_notification(GSettings* /*settings*/,
+                                                   gchar*     key,
+                                                   gpointer   gself)
+{
+    static_cast<LiveSettings*>(gself)->update_key_general_notification(key);
+}
+
+void LiveSettings::update_key_general_notification(const std::string& key)
+{
+    if (key == SETTINGS_VIBRATE_SILENT_KEY)
+        update_vibrate_silent_mode();
 }
 
 /***
 
=== modified file 'src/snap.cpp'
--- src/snap.cpp	2016-05-14 17:18:45 +0000
+++ src/snap.cpp	2016-07-04 23:46:11 +0000
@@ -84,9 +84,9 @@
                     const Alarm& alarm,
                     response_func on_response)
     {
-        // If calendar notifications are muted, don't show them
-        if (!appointment.is_ubuntu_alarm() && calendar_events_are_muted()) {
-            g_debug("Skipping muted calendar event '%s' notification", appointment.summary.c_str());
+        // If calendar notifications are disabled, don't show them
+        if (!appointment.is_ubuntu_alarm() && !calendar_notifications_are_enabled()) {
+            g_debug("Skipping disabled calendar event '%s' notification", appointment.summary.c_str());
             return;
         }
 
@@ -97,13 +97,14 @@
         const bool interactive = appointment.is_ubuntu_alarm() && m_engine->supports_actions();
 
         // force the system to stay awake
-        auto awake = std::make_shared<uin::Awake>(m_engine->app_name());
+        std::shared_ptr<uin::Awake> awake;
+        if (appointment.is_ubuntu_alarm() || calendar_bubbles_enabled() || calendar_list_enabled()) {
+            awake = std::make_shared<uin::Awake>(m_engine->app_name());
+        }
 
         // calendar events are muted in silent mode; alarm clocks never are
         std::shared_ptr<uin::Sound> sound;
-        // FIXME: only play sounds for alarms for now, we should itegrate it with
-        // system settings to decide if we should play sounds for calendar notification or not
-        if (appointment.is_ubuntu_alarm()) {
+        if (appointment.is_ubuntu_alarm() || (calendar_sounds_enabled() && !silent_mode())) {
             // create the sound.
             const auto role = appointment.is_ubuntu_alarm() ? "alarm" : "alert";
             const auto uri = get_alarm_uri(appointment, alarm, m_settings);
@@ -114,10 +115,13 @@
 
         // create the haptic feedback...
         std::shared_ptr<uin::Haptic> haptic;
-        if (should_vibrate()) {
-            const auto haptic_mode = m_settings->alarm_haptic.get();
-            if (haptic_mode == "pulse")
-                haptic = std::make_shared<uin::Haptic>(uin::Haptic::MODE_PULSE, appointment.is_ubuntu_alarm());
+        if (should_vibrate() && (appointment.is_ubuntu_alarm() || calendar_vibrations_enabled())) {
+            // when in silent mode should only vibrate if user defined so
+            if (!silent_mode() || vibrate_in_silent_mode_enabled()) {
+                const auto haptic_mode = m_settings->alarm_haptic.get();
+                if (haptic_mode == "pulse")
+                    haptic = std::make_shared<uin::Haptic>(uin::Haptic::MODE_PULSE, appointment.is_ubuntu_alarm());
+            }
         }
 
         // show a notification...
@@ -180,6 +184,9 @@
             });
         }
 
+        b.set_show_notification_bubble(appointment.is_ubuntu_alarm() || calendar_bubbles_enabled());
+        b.set_post_to_messaging_menu(appointment.is_ubuntu_alarm() || calendar_list_enabled());
+
         const auto key = m_engine->show(b);
         if (key)
             m_notifications.insert (key);
@@ -187,15 +194,34 @@
 
 private:
 
-    bool calendar_events_are_muted() const
-    {
-        for(const auto& app : m_settings->muted_apps.get()) {
-            if (app.first == "com.ubuntu.calendar") {
-                return true;
-            }
-        }
-
-        return false;
+    bool calendar_notifications_are_enabled() const
+    {
+        return m_settings->cal_notification_enabled.get();
+    }
+
+    bool calendar_sounds_enabled() const
+    {
+        return m_settings->cal_notification_sounds.get();
+    }
+
+    bool calendar_vibrations_enabled() const
+    {
+        return m_settings->cal_notification_vibrations.get();
+    }
+
+    bool calendar_bubbles_enabled() const
+    {
+        return m_settings->cal_notification_bubbles.get();
+    }
+
+    bool calendar_list_enabled() const
+    {
+        return m_settings->cal_notification_list.get();
+    }
+
+    bool vibrate_in_silent_mode_enabled() const
+    {
+        return m_settings->vibrate_silent_mode.get();
     }
 
     static void on_sound_proxy_ready(GObject* /*source_object*/, GAsyncResult* res, gpointer gself)
 
=== modified file 'tests/test-notification.cpp'
--- tests/test-notification.cpp	2016-05-16 20:57:51 +0000
+++ tests/test-notification.cpp	2016-07-04 23:46:11 +0000
@@ -87,18 +87,16 @@
     { false, true, false }
   };
 
-  // combinatorial factor #4: system settings' notifications app blacklist
-  const std::set<std::pair<std::string,std::string>> blacklist_calendar { std::make_pair(std::string{"com.ubuntu.calendar"}, std::string{"calendar-app"}) };
-  const std::set<std::pair<std::string,std::string>> blacklist_empty;
+  // combinatorial factor #4: system settings' notifications disabled
   struct {
-    std::set<std::pair<std::string,std::string>> muted_apps; // apps that should not trigger notifications
+    bool cal_notification_enabled; // calendar app can trigger notifications
     std::set<Appointment::Type> expected_notify_called; // do we expect the notification to show?
     std::set<Appointment::Type> expected_vibrate_called; // do we expect the phone to vibrate?
-  } test_muted_apps[] = {
-    { blacklist_empty,    std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT },
-                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT } },
-    { blacklist_calendar, std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM },
-                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM } }
+  } test_cal_disabled[] = {
+    { true,  std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT },
+             std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT } },
+    { false, std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM },
+             std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM } }
   };
 
   for (const auto& test_appt : test_appts)
@@ -107,20 +105,24 @@
   {
   for (const auto& test_vibes : test_other_vibrations)
   {
-  for (const auto& test_muted : test_muted_apps)
+  for (const auto& test_disabled : test_cal_disabled)
   {
     const bool expected_notify_called = test_appt.expected_notify_called
                                      && test_vibes.expected_notify_called
-                                     && (test_muted.expected_notify_called.count(test_appt.appt.type) > 0)
+                                     && (test_disabled.expected_notify_called.count(test_appt.appt.type) > 0)
                                      && test_haptic.expected_notify_called;
 
     const bool expected_vibrate_called = test_appt.expected_vibrate_called
                                       && test_vibes.expected_vibrate_called
-                                      && (test_muted.expected_vibrate_called.count(test_appt.appt.type) > 0)
+                                      && (test_disabled.expected_vibrate_called.count(test_appt.appt.type) > 0)
                                       && test_haptic.expected_vibrate_called;
 
-    // set test case properties: blacklist
-    settings->muted_apps.set(test_muted.muted_apps);
+    // set test case properties: cal_notification_enabled
+    settings->cal_notification_enabled.set(test_disabled.cal_notification_enabled);
+    settings->cal_notification_sounds.set(test_disabled.cal_notification_enabled);
+    settings->cal_notification_vibrations.set(test_disabled.cal_notification_enabled);
+    settings->cal_notification_bubbles.set(test_disabled.cal_notification_enabled);
+    settings->cal_notification_list.set(test_disabled.cal_notification_enabled);
 
     // set test case properties: haptic mode
     settings->alarm_haptic.set(test_haptic.haptic_mode);
@@ -228,6 +230,12 @@
   };
 
 
+  settings->cal_notification_enabled.set(true);
+  settings->cal_notification_sounds.set(true);
+  settings->cal_notification_vibrations.set(true);
+  settings->cal_notification_bubbles.set(true);
+  settings->cal_notification_list.set(true);
+
   // walk through the tests
   for (const auto& test : tests)
   {
 
=== modified file 'tests/test-settings.cpp'
--- tests/test-settings.cpp	2016-02-02 00:08:13 +0000
+++ tests/test-settings.cpp	2016-07-04 23:46:11 +0000
@@ -37,15 +37,15 @@
 
     std::shared_ptr<LiveSettings> m_live;
     std::shared_ptr<Settings> m_settings;
-    GSettings * m_gsettings;
-    GSettings * m_gsettings_cunh;
+    GSettings * m_gsettings {};
+    GSettings * m_gsettings_cal_notification {};
 
     void SetUp() override
     {
         super::SetUp();
 
         m_gsettings = g_settings_new(SETTINGS_INTERFACE);
-        m_gsettings_cunh = g_settings_new(SETTINGS_CUNH_SCHEMA_ID);
+        m_gsettings_cal_notification = g_settings_new_with_path(SETTINGS_NOTIFY_SCHEMA_ID, SETTINGS_NOTIFY_CALENDAR_PATH);
 
         m_live.reset(new LiveSettings);
         m_settings = std::dynamic_pointer_cast<Settings>(m_live);
@@ -53,7 +53,7 @@
 
     void TearDown() override
     {
-        g_clear_object(&m_gsettings_cunh);
+        g_clear_object(&m_gsettings_cal_notification);
         g_clear_object(&m_gsettings);
         m_settings.reset();
         m_live.reset();
@@ -61,62 +61,62 @@
         super::TearDown();
     }
 
-    void TestBoolProperty(core::Property<bool>& property, const gchar* key)
+    void TestBoolProperty(GSettings* gsettings, core::Property<bool>& property, const gchar* key)
     {
-        EXPECT_EQ(g_settings_get_boolean(m_gsettings, key), property.get());
-        g_settings_set_boolean(m_gsettings, key, false);
+        EXPECT_EQ(g_settings_get_boolean(gsettings, key), property.get());
+        g_settings_set_boolean(gsettings, key, false);
         EXPECT_FALSE(property.get());
-        g_settings_set_boolean(m_gsettings, key, true);
+        g_settings_set_boolean(gsettings, key, true);
         EXPECT_TRUE(property.get());
 
         property.set(false);
-        EXPECT_FALSE(g_settings_get_boolean(m_gsettings, key));
+        EXPECT_FALSE(g_settings_get_boolean(gsettings, key));
         property.set(true);
-        EXPECT_TRUE(g_settings_get_boolean(m_gsettings, key));
+        EXPECT_TRUE(g_settings_get_boolean(gsettings, key));
     }
 
-    void TestStringProperty(core::Property<std::string>& property, const gchar* key)
+    void TestStringProperty(GSettings* gsettings, core::Property<std::string>& property, const gchar* key)
     {
         gchar* tmp;
         std::string str;
 
-        tmp = g_settings_get_string(m_gsettings, key);
+        tmp = g_settings_get_string(gsettings, key);
         EXPECT_EQ(tmp, property.get());
         g_clear_pointer(&tmp, g_free);
 
         str = "a";
-        g_settings_set_string(m_gsettings, key, str.c_str());
+        g_settings_set_string(gsettings, key, str.c_str());
         EXPECT_EQ(str, property.get());
 
         str = "b";
-        g_settings_set_string(m_gsettings, key, str.c_str());
+        g_settings_set_string(gsettings, key, str.c_str());
         EXPECT_EQ(str, property.get());
 
         str = "a";
         property.set(str);
-        tmp = g_settings_get_string(m_gsettings, key);
+        tmp = g_settings_get_string(gsettings, key);
         EXPECT_EQ(str, tmp);
         g_clear_pointer(&tmp, g_free);
 
         str = "b";
         property.set(str);
-        tmp = g_settings_get_string(m_gsettings, key);
+        tmp = g_settings_get_string(gsettings, key);
         EXPECT_EQ(str, tmp);
         g_clear_pointer(&tmp, g_free);
     }
 
-    void TestUIntProperty(core::Property<unsigned int>& property, const gchar* key)
+    void TestUIntProperty(GSettings* gsettings, core::Property<unsigned int>& property, const gchar* key)
     {
-        EXPECT_EQ(g_settings_get_uint(m_gsettings, key), property.get());
+        EXPECT_EQ(g_settings_get_uint(gsettings, key), property.get());
 
         unsigned int expected_values[] = { 1, 2, 3 };
 
         // modify GSettings and confirm that the new value is propagated
         for(const auto& expected_value : expected_values)
         {
-            g_settings_set_uint(m_gsettings, key, expected_value);
+            g_settings_set_uint(gsettings, key, expected_value);
             EXPECT_EQ(expected_value, property.get());
-            EXPECT_EQ(expected_value, g_settings_get_uint(m_gsettings, key));
+            EXPECT_EQ(expected_value, g_settings_get_uint(gsettings, key));
         }
 
         // modify the property and confirm that the new value is propagated
@@ -124,7 +124,7 @@
         {
             property.set(expected_value);
             EXPECT_EQ(expected_value, property.get());
-            EXPECT_EQ(expected_value, g_settings_get_uint(m_gsettings, key));
+            EXPECT_EQ(expected_value, g_settings_get_uint(gsettings, key));
         }
     }
 };
@@ -140,32 +140,32 @@
 
 TEST_F(SettingsFixture, BoolProperties)
 {
-    TestBoolProperty(m_settings->show_seconds, SETTINGS_SHOW_SECONDS_S);
-    TestBoolProperty(m_settings->show_calendar, SETTINGS_SHOW_CALENDAR_S);
-    TestBoolProperty(m_settings->show_clock, SETTINGS_SHOW_CLOCK_S);
-    TestBoolProperty(m_settings->show_date, SETTINGS_SHOW_DATE_S);
-    TestBoolProperty(m_settings->show_day, SETTINGS_SHOW_DAY_S);
-    TestBoolProperty(m_settings->show_detected_location, SETTINGS_SHOW_DETECTED_S);
-    TestBoolProperty(m_settings->show_events, SETTINGS_SHOW_EVENTS_S);
-    TestBoolProperty(m_settings->show_locations, SETTINGS_SHOW_LOCATIONS_S);
-    TestBoolProperty(m_settings->show_week_numbers, SETTINGS_SHOW_WEEK_NUMBERS_S);
-    TestBoolProperty(m_settings->show_year, SETTINGS_SHOW_YEAR_S);
+    TestBoolProperty(m_gsettings, m_settings->show_seconds, SETTINGS_SHOW_SECONDS_S);
+    TestBoolProperty(m_gsettings, m_settings->show_calendar, SETTINGS_SHOW_CALENDAR_S);
+    TestBoolProperty(m_gsettings, m_settings->show_clock, SETTINGS_SHOW_CLOCK_S);
+    TestBoolProperty(m_gsettings, m_settings->show_date, SETTINGS_SHOW_DATE_S);
+    TestBoolProperty(m_gsettings, m_settings->show_day, SETTINGS_SHOW_DAY_S);
+    TestBoolProperty(m_gsettings, m_settings->show_detected_location, SETTINGS_SHOW_DETECTED_S);
+    TestBoolProperty(m_gsettings, m_settings->show_events, SETTINGS_SHOW_EVENTS_S);
+    TestBoolProperty(m_gsettings, m_settings->show_locations, SETTINGS_SHOW_LOCATIONS_S);
+    TestBoolProperty(m_gsettings, m_settings->show_week_numbers, SETTINGS_SHOW_WEEK_NUMBERS_S);
+    TestBoolProperty(m_gsettings, m_settings->show_year, SETTINGS_SHOW_YEAR_S);
 }
 
 TEST_F(SettingsFixture, UIntProperties)
 {
-    TestUIntProperty(m_settings->alarm_duration, SETTINGS_ALARM_DURATION_S);
-    TestUIntProperty(m_settings->alarm_volume, SETTINGS_ALARM_VOLUME_S);
-    TestUIntProperty(m_settings->snooze_duration, SETTINGS_SNOOZE_DURATION_S);
+    TestUIntProperty(m_gsettings, m_settings->alarm_duration, SETTINGS_ALARM_DURATION_S);
+    TestUIntProperty(m_gsettings, m_settings->alarm_volume, SETTINGS_ALARM_VOLUME_S);
+    TestUIntProperty(m_gsettings, m_settings->snooze_duration, SETTINGS_SNOOZE_DURATION_S);
 }
 
 TEST_F(SettingsFixture, StringProperties)
 {
-    TestStringProperty(m_settings->custom_time_format, SETTINGS_CUSTOM_TIME_FORMAT_S);
-    TestStringProperty(m_settings->timezone_name, SETTINGS_TIMEZONE_NAME_S);
-    TestStringProperty(m_settings->alarm_sound, SETTINGS_ALARM_SOUND_S);
-    TestStringProperty(m_settings->calendar_sound, SETTINGS_CALENDAR_SOUND_S);
-    TestStringProperty(m_settings->alarm_haptic, SETTINGS_ALARM_HAPTIC_S);
+    TestStringProperty(m_gsettings, m_settings->custom_time_format, SETTINGS_CUSTOM_TIME_FORMAT_S);
+    TestStringProperty(m_gsettings, m_settings->timezone_name, SETTINGS_TIMEZONE_NAME_S);
+    TestStringProperty(m_gsettings, m_settings->alarm_sound, SETTINGS_ALARM_SOUND_S);
+    TestStringProperty(m_gsettings, m_settings->calendar_sound, SETTINGS_CALENDAR_SOUND_S);
+    TestStringProperty(m_gsettings, m_settings->alarm_haptic, SETTINGS_ALARM_HAPTIC_S);
 }
 
 TEST_F(SettingsFixture, TimeFormatMode)
@@ -229,36 +229,13 @@
 
 TEST_F(SettingsFixture, MutedApps)
 {
-    const auto key = SETTINGS_CUNH_BLACKLIST_S;
-
-    struct {
-        std::string pkgname;
-        std::string appname;
-    } apps[] = {
-        { "", "ubuntu-system-settings" },
-        { "com.ubuntu.calendar", "calendar" },
-        { "com.ubuntu.developer.webapps.webapp-facebook", "webapp-facebook" },
-        { "com.ubuntu.reminders", "reminders" }
-    };
-    std::set<std::pair<std::string,std::string>> apps_set;
-    for (const auto& app : apps)
-        apps_set.insert(std::make_pair(app.pkgname, app.appname));
-
-    // test that changing Settings is reflected in the schema
-    m_settings->muted_apps.set(apps_set);
-    auto v = g_settings_get_value(m_gsettings_cunh, key);
-    auto str = g_variant_print(v, true);
-    EXPECT_STREQ("[('', 'ubuntu-system-settings'), ('com.ubuntu.calendar', 'calendar'), ('com.ubuntu.developer.webapps.webapp-facebook', 'webapp-facebook'), ('com.ubuntu.reminders', 'reminders')]", str);
-    g_clear_pointer(&str, g_free);
-
-    // test that clearing the schema clears the settings
-    g_settings_reset(m_gsettings_cunh, key);
-    EXPECT_EQ(0, m_settings->muted_apps.get().size());
-
-    // test thst setting the schema updates the settings
-    g_settings_set_value(m_gsettings_cunh, key, v);
-    EXPECT_EQ(apps_set, m_settings->muted_apps.get());
-
-    // cleanup
-    g_clear_pointer(&v, g_variant_unref);
+    if (!m_gsettings_cal_notification) {
+        return;
+    }
+
+    TestBoolProperty(m_gsettings_cal_notification, m_settings->cal_notification_enabled, SETTINGS_NOTIFY_ENABLED_KEY);
+    TestBoolProperty(m_gsettings_cal_notification, m_settings->cal_notification_sounds, SETTINGS_NOTIFY_SOUNDS_KEY);
+    TestBoolProperty(m_gsettings_cal_notification, m_settings->cal_notification_vibrations, SETTINGS_NOTIFY_VIBRATIONS_KEY);
+    TestBoolProperty(m_gsettings_cal_notification, m_settings->cal_notification_bubbles, SETTINGS_NOTIFY_BUBBLES_KEY);
+    TestBoolProperty(m_gsettings_cal_notification, m_settings->cal_notification_list, SETTINGS_NOTIFY_LIST_KEY);
 }
 
=== modified file 'tests/test-sound.cpp'
--- tests/test-sound.cpp	2016-05-14 17:20:00 +0000
+++ tests/test-sound.cpp	2016-07-04 23:46:11 +0000
@@ -59,6 +59,12 @@
   auto sb = std::make_shared<unity::indicator::notifications::DefaultSoundBuilder>();
   auto snap = create_snap(ne, sb, settings);
 
+  settings->cal_notification_enabled.set(true);
+  settings->cal_notification_sounds.set(true);
+  settings->cal_notification_vibrations.set(true);
+  settings->cal_notification_bubbles.set(true);
+  settings->cal_notification_list.set(true);
+
   make_interactive();
 
   // call the Snap Decision
@@ -150,6 +156,12 @@
   auto sb = std::make_shared<TestSoundBuilder>();
   auto func = [this](const Appointment&, const Alarm&, const Snap::Response&){g_idle_add(quit_idle, loop);};
 
+  settings->cal_notification_enabled.set(true);
+  settings->cal_notification_sounds.set(true);
+  settings->cal_notification_vibrations.set(true);
+  settings->cal_notification_bubbles.set(true);
+  settings->cal_notification_list.set(true);
+
   const struct {
       Appointment appointment;
       std::string expected_role;