Merge lp:~renatofilho/indicator-datetime/notify-missing-alarm into lp:indicator-datetime/15.10

[Renato Araujo Oliveira Filho]

Post message on messaging menu if the notification get timeout.

[lp:~renatofilho/indicator-datetime/notify-missing-alarm]

463. By Renato Araujo Oliveira Filho on 2016-04-19

Fixed crash when clicking on messaging menu.

464. By Renato Araujo Oliveira Filho on 2016-04-20

Fix memory leak on messaging_menu.

465. By Renato Araujo Oliveira Filho on 2016-04-20

Vibrate only once when notification about calendar events.

466. By Renato Araujo Oliveira Filho on 2016-04-26

Fixed as reviewer requested.

467. By Renato Araujo Oliveira Filho on 2016-04-26

Make use of G_USEC_PER_SEC.

468. By Renato Araujo Oliveira Filho on 2016-04-27

Update notifications to use the new calendar icon.

469. By Renato Araujo Oliveira Filho on 2016-04-27

Use calendar app icon.

470. By Renato Araujo Oliveira Filho on 2016-04-27

Only creates messaging menu if calendar app is instaled.
Update tests.

471. By Renato Araujo Oliveira Filho on 2016-04-28

Small fixes requeted by charles during the review.

472. By Renato Araujo Oliveira Filho on 2016-04-28

Detect desktop to launch applications.

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-02-03 16:33:39 +0000
+++ CMakeLists.txt	2016-04-19 13:10:52 +0000
@@ -20,7 +20,7 @@
 
 ##
 ##  GNU standard installation directories
-## 
+##
 
 include (GNUInstallDirs)
 if (EXISTS "/etc/debian_version") # Workaround for libexecdir on debian
@@ -47,7 +47,10 @@
                    gstreamer-1.0>=1.2
                    libnotify>=0.7.6
                    url-dispatcher-1>=1
-                   properties-cpp>=0.0.1)
+                   properties-cpp>=0.0.1
+                   libaccounts-glib>=1.18
+                   messaging-menu>=12.10
+                   uuid>=2.25)
 include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 ##

=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2015-10-13 15:06:25 +0000
+++ data/CMakeLists.txt	2016-04-19 13:10:52 +0000
@@ -30,6 +30,7 @@
 
 # build it
 set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
+set (messaging_menu_icon "${CMAKE_INSTALL_FULL_DATAROOTDIR}/icons/suru/actions/scalable/appointment.svg")
 configure_file ("${UPSTART_JOB_FILE_IN}" "${UPSTART_JOB_FILE}")
 
 # install it
@@ -52,7 +53,11 @@
 set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
 configure_file ("${XDG_AUTOSTART_FILE_IN}" "${XDG_AUTOSTART_FILE}")
 
-# install it
+# install desktop file used by messaging-menu
+install (FILES "${XDG_AUTOSTART_FILE}"
+         DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/applications/")
+
+# install XDG autostart
 install (FILES "${XDG_AUTOSTART_FILE}"
          DESTINATION "${XDG_AUTOSTART_DIR}")
 

=== modified file 'data/indicator-datetime.desktop.in'
--- data/indicator-datetime.desktop.in	2014-04-04 13:05:59 +0000
+++ data/indicator-datetime.desktop.in	2016-04-19 13:10:52 +0000
@@ -7,3 +7,4 @@
 StartupNotify=false
 Terminal=false
 AutostartCondition=GNOME3 unless-session gnome
+Icon=@messaging_menu_icon@

=== modified file 'debian/control'
--- debian/control	2016-03-10 16:20:36 +0000
+++ debian/control	2016-04-19 13:10:52 +0000
@@ -29,6 +29,11 @@
                gvfs-daemons,
 # for phone alarm/calendar notification sound tests:
                ubuntu-touch-sounds,
+# for query user e-mails based on accounts
+               libaccounts-glib-dev,
+# messaging menu integration
+               libmessaging-menu-dev,
+               uuid-dev,
 Standards-Version: 3.9.3
 Homepage: https://launchpad.net/indicator-datetime
 # If you aren't a member of ~indicator-applet-developers but need to upload

=== modified file 'include/datetime/appointment.h'
--- include/datetime/appointment.h	2016-03-16 14:42:06 +0000
+++ include/datetime/appointment.h	2016-04-19 13:10:52 +0000
@@ -39,6 +39,8 @@
     DateTime time;
 
     bool operator== (const Alarm& that) const;
+    bool has_sound() const;
+    bool has_text() const;
 };
 
 /**

=== modified file 'include/datetime/engine-eds.h'
--- include/datetime/engine-eds.h	2014-12-08 02:52:50 +0000
+++ include/datetime/engine-eds.h	2016-04-19 13:10:52 +0000
@@ -36,16 +36,17 @@
 /****
 *****
 ****/
+class Myself;
 
 /**
  * Class wrapper around EDS so multiple #EdsPlanners can share resources
- * 
+ *
  * @see EdsPlanner
  */
 class EdsEngine: public Engine
 {
 public:
-    EdsEngine();
+    EdsEngine(const std::shared_ptr<Myself> &myself);
     ~EdsEngine();
 
     void get_appointments(const DateTime& begin,

=== added file 'include/datetime/myself.h'
--- include/datetime/myself.h	1970-01-01 00:00:00 +0000
+++ include/datetime/myself.h	2016-04-19 13:10:52 +0000
@@ -0,0 +1,62 @@
+/*
+ * 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/>.
+ *
+ * Authors:
+ *   Renato Araujo Oliveira Filho <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_MYSELF_H
+#define INDICATOR_DATETIME_MYSELF_H
+
+#include <core/property.h>
+
+#include <string>
+#include <set>
+#include <memory.h>
+#include <glib.h>
+
+typedef struct _AgManager AgManager;
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+class Myself
+{
+public:
+     Myself();
+
+     const core::Property<std::set<std::string>>& emails()
+     {
+         return m_emails;
+     }
+
+     bool isMyEmail(const std::string &email);
+
+private:
+     std::shared_ptr<AgManager> m_accounts_manager;
+     core::Property<std::set<std::string> > m_emails;
+
+     static void on_accounts_changed(AgManager*, guint, Myself*);
+     void reloadEmails();
+
+};
+
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_MYSELF_H

=== modified file 'include/notifications/notifications.h'
--- include/notifications/notifications.h	2014-09-19 14:35:07 +0000
+++ include/notifications/notifications.h	2016-04-19 13:10:52 +0000
@@ -50,6 +50,8 @@
 
     void set_icon_name (const std::string& icon_name);
 
+    void set_start_time(uint64_t time);
+
     /* Set an interval, after which the notification will automatically
        be closed. If not set, the notification server's default timeout
        is used. */
@@ -62,19 +64,24 @@
     static constexpr char const * HINT_NONSHAPED_ICON {"x-canonical-non-shaped-icon"};
     static constexpr char const * HINT_AFFIRMATIVE_HINT {"x-canonical-private-affirmative-tint"};
     static constexpr char const * HINT_REJECTION_TINT {"x-canonical-private-rejection-tint"};
+    static constexpr char const * HINT_INTERACTIVE {"x-canonical-switch-to-application"};
 
     /* Add an action button.
        This may fail if the Engine doesn't support actions.
        @see Engine::supports_actions() */
     void add_action (const std::string& action, const std::string& label);
 
-    /** Sets the closed callback. This will be called exactly once. */
+    /** Sets the closed callback. This will be called exactly once. After notification dissapear */
     void set_closed_callback (std::function<void(const std::string& action)>);
 
+    /** Sets the time-out callback. This will be called exactly once. */
+    void set_missed_click_callback (std::function<void()>);
+
+
 private:
     friend class Engine;
     class Impl;
-    std::unique_ptr<Impl> impl;
+    std::shared_ptr<Impl> impl;
 };
 
 /**

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-09-01 09:52:13 +0000
+++ src/CMakeLists.txt	2016-04-19 13:10:52 +0000
@@ -23,6 +23,7 @@
      locations.cpp
      locations-settings.cpp
      menu.cpp
+     myself.cpp
      notifications.cpp
      planner.cpp
      planner-aggregate.cpp

=== modified file 'src/appointment.cpp'
--- src/appointment.cpp	2015-04-05 22:27:52 +0000
+++ src/appointment.cpp	2016-04-19 13:10:52 +0000
@@ -31,7 +31,17 @@
 {
   return (text==that.text)
       && (audio_url==that.audio_url)
-      && (this->time==that.time);
+          && (this->time==that.time);
+}
+
+bool Alarm::has_sound() const
+{
+    return !audio_url.empty();
+}
+
+bool Alarm::has_text() const
+{
+    return !text.empty();
 }
 
 bool Appointment::operator==(const Appointment& that) const

=== modified file 'src/engine-eds.cpp'
--- src/engine-eds.cpp	2016-03-22 19:32:25 +0000
+++ src/engine-eds.cpp	2016-04-19 13:10:52 +0000
@@ -18,6 +18,7 @@
  */
 
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 
 #include <libical/ical.h>
 #include <libical/icaltime.h>
@@ -48,7 +49,8 @@
 {
 public:
 
-    Impl()
+    Impl(const std::shared_ptr<Myself> &myself)
+        : m_myself(myself)
     {
         auto cancellable_deleter = [](GCancellable * c) {
             g_cancellable_cancel(c);
@@ -56,8 +58,10 @@
         };
 
         m_cancellable = std::shared_ptr<GCancellable>(g_cancellable_new(), cancellable_deleter);
-
         e_source_registry_new(m_cancellable.get(), on_source_registry_ready, this);
+        m_myself->emails().changed().connect([this](const std::set<std::string> &) {
+            set_dirty_soon();
+        });
     }
 
     ~Impl()
@@ -92,26 +96,19 @@
         /**
         ***  init the default timezone
         **/
-
         icaltimezone * default_timezone = nullptr;
         const auto tz = timezone.timezone.get().c_str();
-        if (tz && *tz)
-        {
-            default_timezone = icaltimezone_get_builtin_timezone(tz);
-
-            if (default_timezone == nullptr) // maybe str is a tzid?
-                default_timezone = icaltimezone_get_builtin_timezone_from_tzid(tz);
-
-            g_debug("default_timezone is %p", (void*)default_timezone);
+        auto gtz = timezone_from_name(tz, nullptr, nullptr, &default_timezone);
+        if (gtz == nullptr) {
+            gtz = g_time_zone_new_local();
         }
 
+        g_debug("default_timezone is %s", default_timezone ? icaltimezone_get_display_name(default_timezone) : "null");
+
         /**
         ***  walk through the sources to build the appointment list
         **/
 
-        auto gtz = default_timezone != nullptr
-                 ? g_time_zone_new(icaltimezone_get_location(default_timezone))
-                 : g_time_zone_new_local();
         auto main_task = std::make_shared<Task>(this, func, default_timezone, gtz, begin, end);
 
         for (auto& kv : m_clients)
@@ -125,35 +122,14 @@
             auto extension = e_source_get_extension(source, E_SOURCE_EXTENSION_CALENDAR);
             const auto color = e_source_selectable_get_color(E_SOURCE_SELECTABLE(extension));
 
-            auto begin_str = isodate_from_time_t(begin.to_unix());
-            auto end_str = isodate_from_time_t(end.to_unix());
-            auto sexp_fmt = g_strdup_printf("(%%s? (make-time \"%s\") (make-time \"%s\"))", begin_str, end_str);
-            g_clear_pointer(&begin_str, g_free);
-            g_clear_pointer(&end_str, g_free);
-
-            // ask EDS about alarms that occur in this window...
-            auto sexp = g_strdup_printf(sexp_fmt, "has-alarms-in-range");
-            g_debug("%s alarm sexp is %s", G_STRLOC, sexp);
-            e_cal_client_get_object_list_as_comps(
-                client,
-                sexp,
-                m_cancellable.get(),
-                on_alarm_component_list_ready,
-                new ClientSubtask(main_task, client, m_cancellable, color));
-            g_clear_pointer(&sexp, g_free);
-
-            // ask EDS about events that occur in this window...
-            sexp = g_strdup_printf(sexp_fmt, "occur-in-time-range");
-            g_debug("%s event sexp is %s", G_STRLOC, sexp);
-            e_cal_client_get_object_list_as_comps(
-                client,
-                sexp,
-                m_cancellable.get(),
-                on_event_component_list_ready,
-                new ClientSubtask(main_task, client, m_cancellable, color));
-            g_clear_pointer(&sexp, g_free);
-
-            g_clear_pointer(&sexp_fmt, g_free);
+            e_cal_client_generate_instances(
+                client,
+                begin.to_unix(),
+                end.to_unix(),
+                m_cancellable.get(),
+                on_event_generated,
+                new ClientSubtask(main_task, client, m_cancellable, color),
+                on_event_generated_list_ready);
         }
     }
 
@@ -591,6 +567,8 @@
         ECalClient* client;
         std::shared_ptr<GCancellable> cancellable;
         std::string color;
+        GList *components;
+        GList *instance_components;
 
         ClientSubtask(const std::shared_ptr<Task>& task_in,
                       ECalClient* client_in,
@@ -598,10 +576,13 @@
                       const char* color_in):
             task(task_in),
             client(client_in),
-            cancellable(cancellable_in)
+            cancellable(cancellable_in),
+            components(nullptr),
+            instance_components(nullptr)
         {
             if (color_in)
                 color = color_in;
+
         }
     };
 
@@ -622,7 +603,7 @@
         return ret;
     }
 
-    static std::string get_alarm_sound_url(ECalComponentAlarm * alarm)
+    static std::string get_alarm_sound_url(ECalComponentAlarm * alarm, const std::string & default_sound)
     {
         std::string ret;
 
@@ -643,92 +624,129 @@
 
                 icalattach_unref(attach);
             }
+            if (ret.empty())
+                ret = default_sound;
         }
 
         return ret;
     }
 
-    static void
-    on_alarm_component_list_ready(GObject      * oclient,
-                                  GAsyncResult * res,
-                                  gpointer       gsubtask)
-    {
-        GError * error = NULL;
-        GSList * comps_slist = NULL;
-        auto subtask = static_cast<ClientSubtask*>(gsubtask);
-
-        if (e_cal_client_get_object_list_as_comps_finish(E_CAL_CLIENT(oclient),
-                                                         res,
-                                                         &comps_slist,
-                                                         &error))
-        {
-            // _generate_alarms takes a GList, so make a shallow one
-            GList * comps_list = nullptr;
-            for (auto l=comps_slist; l!=nullptr; l=l->next)
-                comps_list = g_list_prepend(comps_list, l->data);
-
-            constexpr std::array<ECalComponentAlarmAction,1> omit = {
-                (ECalComponentAlarmAction)-1
-            }; // list of action types to omit, terminated with -1
-            GSList * comp_alarms = nullptr;
-            e_cal_util_generate_alarms_for_list(
-                comps_list,
-                subtask->task->begin.to_unix(),
-                subtask->task->end.to_unix(),
-                const_cast<ECalComponentAlarmAction*>(omit.data()),
-                &comp_alarms,
-                e_cal_client_resolve_tzid_cb,
-                oclient,
-                subtask->task->default_timezone);
-
-            // walk the alarms & add them
-            for (auto l=comp_alarms; l!=nullptr; l=l->next)
-                add_alarms_to_subtask(static_cast<ECalComponentAlarms*>(l->data), subtask, subtask->task->gtz);
-
-            // cleanup
-            e_cal_free_alarms(comp_alarms);
-            g_list_free(comps_list);
-            e_cal_client_free_ecalcomp_slist(comps_slist);
-        }
-        else if (error != nullptr)
-        {
-            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-                g_warning("can't get ecalcomponent list: %s", error->message);
-
-            g_error_free(error);
-        }
-
-        delete subtask;
-    }
-
-    static void
-    on_event_component_list_ready(GObject      * oclient,
-                                  GAsyncResult * res,
-                                  gpointer       gsubtask)
-    {
-        GError * error = NULL;
-        GSList * comps_slist = NULL;
-        auto subtask = static_cast<ClientSubtask*>(gsubtask);
-
-        if (e_cal_client_get_object_list_as_comps_finish(E_CAL_CLIENT(oclient),
-                                                         res,
-                                                         &comps_slist,
-                                                         &error))
-        {
-            for (auto l=comps_slist; l!=nullptr; l=l->next)
-                add_event_to_subtask(static_cast<ECalComponent*>(l->data), subtask, subtask->task->gtz);
-
-            e_cal_client_free_ecalcomp_slist(comps_slist);
-        }
-        else if (error != nullptr)
-        {
-            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-                g_warning("can't get ecalcomponent list: %s", error->message);
-
-            g_error_free(error);
-        }
-
-        delete subtask;
+    static gboolean
+    on_event_generated(ECalComponent *comp,
+                       time_t,
+                       time_t,
+                       gpointer gsubtask)
+    {
+        auto subtask = static_cast<ClientSubtask*>(gsubtask);
+        const gchar *uid = nullptr;
+        e_cal_component_get_uid (comp, &uid);
+        g_object_ref(comp);
+        if (e_cal_component_is_instance(comp))
+            subtask->instance_components = g_list_append(subtask->instance_components, comp);
+        else
+            subtask->components = g_list_append(subtask->components, comp);
+        return TRUE;
+    }
+
+    static void
+    on_event_generated_list_ready(gpointer gsubtask)
+    {
+        auto subtask = static_cast<ClientSubtask*>(gsubtask);
+
+        // generate alarms
+        constexpr std::array<ECalComponentAlarmAction,1> omit = {
+            (ECalComponentAlarmAction)-1
+        }; // list of action types to omit, terminated with -1
+        GSList * comp_alarms = nullptr;
+
+        // we do not need translate tz for instance events,
+        // they are aredy in the correct time
+        e_cal_util_generate_alarms_for_list(
+            subtask->instance_components,
+            subtask->task->begin.to_unix(),
+            subtask->task->end.to_unix(),
+            const_cast<ECalComponentAlarmAction*>(omit.data()),
+            &comp_alarms,
+            e_cal_client_resolve_tzid_cb,
+            subtask->client,
+            nullptr);
+
+        // convert timezone for non-instance events
+        e_cal_util_generate_alarms_for_list(
+            subtask->components,
+            subtask->task->begin.to_unix(),
+            subtask->task->end.to_unix(),
+            const_cast<ECalComponentAlarmAction*>(omit.data()),
+            &comp_alarms,
+            e_cal_client_resolve_tzid_cb,
+            subtask->client,
+            subtask->task->default_timezone);
+
+        // walk the alarms & add them
+        for (auto l=comp_alarms; l!=nullptr; l=l->next)
+            add_alarms_to_subtask(static_cast<ECalComponentAlarms*>(l->data), subtask, subtask->task->gtz);
+
+        subtask->components = g_list_concat(subtask->components, subtask->instance_components);
+        // add events without alarm
+        for (auto l=subtask->components; l!=nullptr; l=l->next) {
+            auto component = static_cast<ECalComponent*>(l->data);
+            if (!e_cal_component_has_alarms(component))
+                add_event_to_subtask(component, subtask, subtask->task->gtz);
+        }
+        g_list_free_full(subtask->components, g_object_unref);
+        e_cal_free_alarms(comp_alarms);
+        delete subtask;
+    }
+
+    static GTimeZone *
+    timezone_from_name (const char * tzid,
+                        ECalClient * client,
+                        GCancellable * cancellable,
+                        icaltimezone **itimezone)
+    {
+        if (tzid == nullptr)
+            return nullptr;
+
+        auto itz = icaltimezone_get_builtin_timezone_from_tzid(tzid); // usually works
+
+        if (itz == nullptr) // fallback
+            itz = icaltimezone_get_builtin_timezone(tzid);
+
+        if (client && (itz == nullptr)) // ok we have a strange tzid... ask EDS to look it up in VTIMEZONES
+            e_cal_client_get_timezone_sync(client, tzid, &itz, cancellable, nullptr);
+
+        const char* identifier {};
+        if (itimezone)
+            *itimezone = itz;
+
+        if (itz != nullptr)
+        {
+            identifier = icaltimezone_get_display_name(itz);
+
+            if (identifier == nullptr)
+                identifier = icaltimezone_get_location(itz);
+        }
+
+        // handle the TZID /freeassociation.sourceforge.net/Tzfile/[Location] case
+        if (identifier != nullptr)
+        {
+            const char* pch;
+            const char* key = "/freeassociation.sourceforge.net/";
+            if ((pch = strstr(identifier, key)))
+            {
+                identifier = pch + strlen(key);
+                key = "Tzfile/"; // some don't have this, so check for it separately
+                if ((pch = strstr(identifier, key)))
+                    identifier = pch + strlen(key);
+            }
+        }
+
+        if (identifier == nullptr)
+            g_warning("Unrecognized TZID: '%s'", tzid);
+        else
+            return g_time_zone_new(identifier);
+
+        return nullptr;
     }
 
     static DateTime
@@ -740,51 +758,9 @@
         DateTime out;
         g_return_val_if_fail(in.value != nullptr, out);
 
-        GTimeZone * gtz {};
-        if (in.tzid != nullptr)
-        {
-            auto itz = icaltimezone_get_builtin_timezone_from_tzid(in.tzid); // usually works
-
-            if (itz == nullptr) // fallback
-                itz = icaltimezone_get_builtin_timezone(in.tzid);
-
-            if (itz == nullptr) // ok we have a strange tzid... ask EDS to look it up in VTIMEZONES
-                e_cal_client_get_timezone_sync(client, in.tzid, &itz, cancellable.get(), nullptr);
-
-            const char* identifier {};
-
-            if (itz != nullptr)
-            {
-                identifier = icaltimezone_get_display_name(itz);
-
-                if (identifier == nullptr)
-                    identifier = icaltimezone_get_location(itz);
-            }
-
-            // handle the TZID /freeassociation.sourceforge.net/Tzfile/[Location] case
-            if (identifier != nullptr)
-            {
-                const char* pch;
-                const char* key = "/freeassociation.sourceforge.net/";
-                if ((pch = strstr(identifier, key)))
-                {
-                    identifier = pch + strlen(key);
-                    key = "Tzfile/"; // some don't have this, so check for it separately
-                    if ((pch = strstr(identifier, key)))
-                        identifier = pch + strlen(key);
-                }
-            }
-
-            if (identifier == nullptr)
-                g_warning("Unrecognized TZID: '%s'", in.tzid);
-
-            gtz = g_time_zone_new(identifier);
-            g_debug("%s eccdt.tzid -> offset is %d", G_STRLOC, in.tzid, (int)g_time_zone_get_offset(gtz,0));
-        }
-        else
-        {
+        GTimeZone * gtz = timezone_from_name(in.tzid, client, cancellable.get(), nullptr);
+        if (gtz == nullptr)
             gtz = g_time_zone_ref(default_timezone);
-        }
 
         out = DateTime(gtz,
                        in.value->year,
@@ -797,7 +773,7 @@
         return out;
     }
 
-    static bool
+    bool
     is_component_interesting(ECalComponent * component)
     {
         // we only want calendar events and vtodos
@@ -823,6 +799,28 @@
                 disabled = true;
         }
         e_cal_component_free_categories_list(categ_list);
+
+        if (!disabled) {
+            // we don't want not attending alarms
+            // check if the user is part of attendee list if we found it check the status
+            GSList *attendeeList = nullptr;
+            e_cal_component_get_attendee_list(component, &attendeeList);
+
+            for (GSList *attendeeIter=attendeeList; attendeeIter != nullptr; attendeeIter = attendeeIter->next) {
+                ECalComponentAttendee *attendee = static_cast<ECalComponentAttendee *>(attendeeIter->data);
+                if (attendee->value) {
+                    if (strncmp(attendee->value, "mailto:", 7) == 0) {
+                        if (m_myself->isMyEmail(attendee->value+7)) {
+                            disabled = (attendee->status == ICAL_PARTSTAT_DECLINED);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (attendeeList)
+                e_cal_component_free_attendee_list(attendeeList);
+        }
+
         if (disabled)
             return false;
 
@@ -903,35 +901,13 @@
     }
 
     static void
-    add_event_to_subtask(ECalComponent * component,
-                         ClientSubtask * subtask,
-                         GTimeZone     * gtz)
-    {
-        // events with alarms are covered by add_alarms_to_subtask(),
-        // so skip them here
-        auto auids = e_cal_component_get_alarm_uids(component);
-        const bool has_alarms = auids != nullptr;
-        cal_obj_uid_list_free(auids);
-        if (has_alarms)
-            return;
-
-        // add it. simple, eh?
-        if (is_component_interesting(component))
-        {
-            Appointment appointment = get_appointment(subtask->client, subtask->cancellable, component, gtz);
-            appointment.color = subtask->color;
-            subtask->task->appointments.push_back(appointment);
-        }
-    }
-
-    static void
     add_alarms_to_subtask(ECalComponentAlarms * comp_alarms,
                           ClientSubtask       * subtask,
                           GTimeZone           * gtz)
     {
         auto& component = comp_alarms->comp;
 
-        if (!is_component_interesting(component))
+        if (!subtask->task->p->is_component_interesting(component))
             return;
 
         Appointment baseline = get_appointment(subtask->client, subtask->cancellable, component, gtz);
@@ -965,13 +941,15 @@
             auto instance_time = std::make_pair(DateTime{gtz, ai->occur_start},
                                                 DateTime{gtz, ai->occur_end});
             auto trigger_time = DateTime{gtz, ai->trigger};
-
             auto& alarm = alarms[instance_time][trigger_time];
-
             if (alarm.text.empty())
                 alarm.text = get_alarm_text(a);
+
             if (alarm.audio_url.empty())
-                alarm.audio_url = get_alarm_sound_url(a);
+                alarm.audio_url = get_alarm_sound_url(a,  (baseline.is_ubuntu_alarm() ?
+                                                         "file://" ALARM_DEFAULT_SOUND :
+                                                         "file://" CALENDAR_DEFAULT_SOUND));
+
             if (!alarm.time.is_set())
                 alarm.time = trigger_time;
 
@@ -985,7 +963,25 @@
             appointment.end = i.first.second;
             appointment.alarms.reserve(i.second.size());
             for (auto& j : i.second)
-                appointment.alarms.push_back(j.second);
+            {
+                if (j.second.has_text() || j.second.has_sound())
+                    appointment.alarms.push_back(j.second);
+            }
+            subtask->task->appointments.push_back(appointment);
+        }
+    }
+
+
+    static void
+    add_event_to_subtask(ECalComponent * component,
+                         ClientSubtask * subtask,
+                         GTimeZone     * gtz)
+    {
+        // add it. simple, eh?
+        if (subtask->task->p->is_component_interesting(component))
+        {
+            Appointment appointment = get_appointment(subtask->client, subtask->cancellable, component, gtz);
+            appointment.color = subtask->color;
             subtask->task->appointments.push_back(appointment);
         }
     }
@@ -1062,14 +1058,15 @@
     ESourceRegistry* m_source_registry {};
     guint m_rebuild_tag {};
     time_t m_rebuild_deadline {};
+    std::shared_ptr<Myself> m_myself;
 };
 
 /***
 ****
 ***/
 
-EdsEngine::EdsEngine():
-    p(new Impl())
+EdsEngine::EdsEngine(const std::shared_ptr<Myself> &myself):
+    p(new Impl(myself))
 {
 }
 

=== modified file 'src/main.cpp'
--- src/main.cpp	2016-04-12 17:03:36 +0000
+++ src/main.cpp	2016-04-19 13:10:52 +0000
@@ -25,6 +25,7 @@
 #include <datetime/exporter.h>
 #include <datetime/locations-settings.h>
 #include <datetime/menu.h>
+#include <datetime/myself.h>
 #include <datetime/planner-aggregate.h>
 #include <datetime/planner-snooze.h>
 #include <datetime/planner-range.h>
@@ -58,7 +59,7 @@
         if (!g_strcmp0("lightdm", g_get_user_name()))
             engine.reset(new MockEngine);
         else
-            engine.reset(new EdsEngine);
+            engine.reset(new EdsEngine(std::shared_ptr<Myself>(new Myself)));
 
         return engine;
     }
@@ -151,7 +152,10 @@
     auto on_snooze = [snooze_planner](const Appointment& appointment, const Alarm& alarm) {
         snooze_planner->add(appointment, alarm);
     };
-    auto on_ok = [](const Appointment&, const Alarm&){};
+    auto on_ok = [actions](const Appointment& app, const Alarm&){
+        //TODO: add support for desktop
+        actions->phone_open_appointment(app, app.begin);
+    };
     auto on_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& appointment, const Alarm& alarm) {
         (*snap)(appointment, alarm, on_snooze, on_ok);
         engine->disable_ubuntu_alarm(appointment);

=== added file 'src/myself.cpp'
--- src/myself.cpp	1970-01-01 00:00:00 +0000
+++ src/myself.cpp	2016-04-19 13:10:52 +0000
@@ -0,0 +1,76 @@
+/*
+ * 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/>.
+ *
+ * Authors:
+ *   Renato Araujo Oliveira Filho <[e-mail]>
+ */
+
+#include "datetime/myself.h"
+
+#include <libaccounts-glib/ag-manager.h>
+#include <libaccounts-glib/ag-account.h>
+
+#include <algorithm>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+Myself::Myself()
+    : m_accounts_manager(ag_manager_new(), g_object_unref)
+{
+    reloadEmails();
+    g_object_connect(m_accounts_manager.get(),
+                     "signal::account-created", on_accounts_changed, this,
+                     "signal::account-deleted", on_accounts_changed, this,
+                     "signal::account-updated", on_accounts_changed, this,
+                     nullptr);
+}
+
+bool Myself::isMyEmail(const std::string &email)
+{
+    return m_emails.get().count(email) > 0;
+}
+
+void Myself::on_accounts_changed(AgManager *, guint, Myself *self)
+{
+    self->reloadEmails();
+}
+
+void Myself::reloadEmails()
+{
+    std::set<std::string> emails;
+
+    auto manager = m_accounts_manager.get();
+    auto ids = ag_manager_list(manager);
+    for (auto l=ids; l!=nullptr; l=l->next)
+    {
+        auto acc = ag_manager_get_account(manager, GPOINTER_TO_UINT(l->data));
+        if (acc) {
+            auto account_name = ag_account_get_display_name(acc);
+            if (account_name != nullptr)
+                emails.insert(account_name);
+            g_object_unref(acc);
+        }
+    }
+    ag_manager_list_free(ids);
+
+    m_emails.set(emails);
+}
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+

=== modified file 'src/notifications.cpp'
--- src/notifications.cpp	2014-09-17 17:08:01 +0000
+++ src/notifications.cpp	2016-04-19 13:10:52 +0000
@@ -21,10 +21,18 @@
 
 #include <libnotify/notify.h>
 
+#include <messaging-menu/messaging-menu-app.h>
+#include <messaging-menu/messaging-menu-message.h>
+
+
+#include <uuid/uuid.h>
+
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
+#include <memory>
+
 
 namespace unity {
 namespace indicator {
@@ -45,9 +53,11 @@
     std::string m_body;
     std::string m_icon_name;
     std::chrono::seconds m_duration;
+    gint64 m_start_time;
     std::set<std::string> m_string_hints;
     std::vector<std::pair<std::string,std::string>> m_actions;
     std::function<void(const std::string&)> m_closed_callback;
+    std::function<void()> m_missed_click_callback;
 };
 
 Builder::Builder():
@@ -101,6 +111,18 @@
   impl->m_closed_callback.swap (cb);
 }
 
+void
+Builder::set_missed_click_callback (std::function<void()> cb)
+{
+  impl->m_missed_click_callback.swap (cb);
+}
+
+void
+Builder::set_start_time (uint64_t time)
+{
+  impl->m_start_time = time;
+}
+
 /***
 ****
 ***/
@@ -110,23 +132,39 @@
     struct notification_data
     {
         std::shared_ptr<NotifyNotification> nn;
-        std::function<void(const std::string&)> closed_callback;
+        Builder::Impl data;
+    };
+
+    struct messaging_menu_data
+    {
+        std::shared_ptr<MessagingMenuMessage> mm;
+        std::function<void()> callback;
     };
 
 public:
 
     Impl(const std::string& app_name):
+        m_messaging_app(messaging_menu_app_new(DATETIME_INDICATOR_DESKTOP_FILE), g_object_unref),
         m_app_name(app_name)
     {
         if (!notify_init(app_name.c_str()))
             g_critical("Unable to initialize libnotify!");
+
+        // messaging menu
+        GIcon *icon = g_themed_icon_new("calendar-app");
+
+        messaging_menu_app_register(m_messaging_app.get());
+        messaging_menu_app_append_source(m_messaging_app.get(), m_app_name.c_str(), icon, "Calendar");
+        g_object_unref(icon);
     }
 
     ~Impl()
     {
         close_all ();
+        remove_all ();
 
         notify_uninit ();
+        messaging_menu_app_unregister (m_messaging_app.get());
     }
 
     const std::string& app_name() const
@@ -217,7 +255,7 @@
                             notification_key_quark(),
                             GINT_TO_POINTER(key));
 
-        m_notifications[key] = { nn, info.m_closed_callback };
+        m_notifications[key] = { nn, info };
         g_signal_connect (nn.get(), "closed",
                           G_CALLBACK(on_notification_closed), this);
      
@@ -238,6 +276,59 @@
         return ret;
     }
 
+    std::string post(const Builder::Impl& data)
+    {
+        uuid_t message_uuid;
+        uuid_generate(message_uuid);
+
+        char message_id[37];
+        uuid_unparse(message_uuid, message_id);
+
+        GIcon *icon = g_themed_icon_new(data.m_icon_name.c_str());
+        std::shared_ptr<MessagingMenuMessage> msg (messaging_menu_message_new(message_id,
+                                                                              icon,
+                                                                              data.m_title.c_str(),
+                                                                              nullptr,
+                                                                              data.m_body.c_str(),
+                                                                              data.m_start_time * 1000000), // secs -> microsecs
+                                                   g_object_ref);
+        g_object_unref(icon);
+        if (msg)
+        {
+            m_messaging_messages[std::string(message_id)] = { msg, data.m_missed_click_callback };
+            g_signal_connect(msg.get(), "activate",
+                             G_CALLBACK(on_message_activated), this);
+            messaging_menu_app_append_message(m_messaging_app.get(), msg.get(), m_app_name.c_str(), false);
+            return message_id;
+        } else {
+            g_warning("Fail to create messaging menu message");
+        }
+        return "";
+    }
+
+    void remove (const std::string &key)
+    {
+        auto it = m_messaging_messages.find(key);
+        if (it != m_messaging_messages.end())
+        {
+            // tell the server to remove message
+            messaging_menu_app_remove_message(m_messaging_app.get(), it->second.mm.get());
+            m_messaging_messages.erase(it);
+        }
+    }
+
+    void remove_all ()
+    {
+        // call remove() on all our keys
+
+        std::set<std::string> keys;
+        for (const auto& it : m_messaging_messages)
+            keys.insert (it.first);
+
+        for (const std::string &key : keys)
+            remove (key);
+    }
+
 private:
 
     const std::set<std::string>& server_caps() const
@@ -279,6 +370,22 @@
         static_cast<Impl*>(gself)->remove_closed_notification(GPOINTER_TO_INT(gkey));
     }
 
+    static void on_message_activated (MessagingMenuMessage *,
+                                      const char *actionId,
+                                      GVariant *,
+                                      gpointer gself)
+    {
+        auto self =  static_cast<Impl*>(gself);
+        auto it = self->m_messaging_messages.find(actionId);
+        g_return_if_fail (it != self->m_messaging_messages.end());
+        const auto& ndata = it->second;
+
+        if (ndata.callback)
+            ndata.callback();
+
+        self->m_messaging_messages.erase(it);
+    }
+
     void remove_closed_notification (int key)
     {
         auto it = m_notifications.find(key);
@@ -286,16 +393,20 @@
 
         const auto& ndata = it->second;
         auto nn = ndata.nn.get();
-        if (ndata.closed_callback)
+
+        if (ndata.data.m_closed_callback)
         {
             std::string action;
-
             const GQuark q = notification_action_quark();
             const gpointer p = g_object_get_qdata(G_OBJECT(nn), q);
             if (p != nullptr)
                 action = static_cast<const char*>(p);
 
-            ndata.closed_callback (action);
+            ndata.data.m_closed_callback (action);
+            // empty action means that the notification got timeout
+            // post a message on messaging menu
+            if (action.empty())
+                post(ndata.data);
         }
 
         m_notifications.erase(it);
@@ -305,6 +416,10 @@
     ****
     ***/
 
+    // messaging menu
+    std::shared_ptr<MessagingMenuApp> m_messaging_app;
+    std::map<std::string, messaging_menu_data> m_messaging_messages;
+
     const std::string m_app_name;
 
     // key-to-data
@@ -315,6 +430,8 @@
     mutable std::set<std::string> m_lazy_caps;
 
     static constexpr char const * HINT_TIMEOUT {"x-canonical-snap-decisions-timeout"};
+    static constexpr char const * DATETIME_INDICATOR_DESKTOP_FILE  {"indicator-datetime.desktop"};
+    static constexpr char const * DATETIME_INDICATOR_SOURCE_ID  {"indicator-datetime"};
 };
 
 /***

=== modified file 'src/snap.cpp'
--- src/snap.cpp	2016-02-03 17:06:31 +0000
+++ src/snap.cpp	2016-04-19 13:10:52 +0000
@@ -102,7 +102,7 @@
 
         // calendar events are muted in silent mode; alarm clocks never are
         std::shared_ptr<uin::Sound> sound;
-        if (appointment.is_ubuntu_alarm() || !silent_mode()) {
+        if (appointment.is_ubuntu_alarm() || (alarm.has_sound() && !silent_mode())) {
             // create the sound.
             const auto role = appointment.is_ubuntu_alarm() ? "alarm" : "alert";
             const auto uri = get_alarm_uri(appointment, alarm, m_settings);
@@ -123,8 +123,9 @@
         const auto minutes = std::chrono::minutes(m_settings->alarm_duration.get());
         uin::Builder b;
         b.set_body (appointment.summary);
-        b.set_icon_name (appointment.is_ubuntu_alarm() ? "alarm-clock" : "reminder");
+        b.set_icon_name (appointment.is_ubuntu_alarm() ? "alarm-clock" : "appointment");
         b.add_hint (uin::Builder::HINT_NONSHAPED_ICON);
+        b.set_start_time (appointment.begin.to_unix());
 
         const char * timefmt;
         if (is_locale_12h()) {
@@ -150,6 +151,9 @@
             b.add_hint (uin::Builder::HINT_AFFIRMATIVE_HINT);
             b.add_action ("ok", _("OK"));
             b.add_action ("snooze", _("Snooze"));
+        } else {
+            b.add_hint (uin::Builder::HINT_INTERACTIVE);
+            b.add_action ("ok", _("OK"));
         }
 
         // add 'sound', 'haptic', and 'awake' objects to the capture so
@@ -159,10 +163,14 @@
                               (const std::string& action){
             if (action == "snooze")
                 snooze(appointment, alarm);
-            else
+            else if (action == "ok")
                 ok(appointment, alarm);
         });
 
+        b.set_missed_click_callback([appointment, alarm, ok](){
+            ok(appointment, alarm);
+        });
+
         const auto key = m_engine->show(b);
         if (key)
             m_notifications.insert (key);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-03-22 18:51:50 +0000
+++ tests/CMakeLists.txt	2016-04-19 13:10:52 +0000
@@ -85,7 +85,8 @@
             ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}               # arg2: test executable path
             ${TEST_NAME}                                           # arg3: test name
             ${CMAKE_CURRENT_SOURCE_DIR}/test-eds-ics-config-files  # arg4: base directory for config file template
-            ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}.ics)          # arg5: the ical file for this test
+            ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}.ics           # arg5: the ical file for this test
+            ${CMAKE_CURRENT_SOURCE_DIR}/accounts.db)               # arg6: online accounts database
 endfunction()
 add_eds_ics_test_by_name(test-eds-ics-all-day-events)
 add_eds_ics_test_by_name(test-eds-ics-repeating-events)
@@ -95,6 +96,7 @@
 add_eds_ics_test_by_name(test-eds-ics-tzids)
 add_eds_ics_test_by_name(test-eds-ics-tzids-2)
 add_eds_ics_test_by_name(test-eds-ics-tzids-utc)
+add_eds_ics_test_by_name(test-eds-ics-non-attending-alarms)
 
 
 # disabling the timezone unit tests because they require

=== added file 'tests/accounts.db'
Binary files tests/accounts.db	1970-01-01 00:00:00 +0000 and tests/accounts.db	2016-04-19 13:10:52 +0000 differ
=== modified file 'tests/notification-fixture.h'
--- tests/notification-fixture.h	2016-02-10 20:48:24 +0000
+++ tests/notification-fixture.h	2016-04-19 13:10:52 +0000
@@ -53,7 +53,7 @@
   static constexpr char const * HAPTIC_METHOD_VIBRATE_PATTERN {"VibratePattern"};
 
   static constexpr int SCREEN_COOKIE {8675309};
-  static constexpr char const * SCREEN_METHOD_KEEP_DISPLAY_ON {"keepDisplayOn"}; 
+  static constexpr char const * SCREEN_METHOD_KEEP_DISPLAY_ON {"keepDisplayOn"};
   static constexpr char const * SCREEN_METHOD_REMOVE_DISPLAY_ON_REQUEST {"removeDisplayOnRequest"};
 
   static constexpr int POWERD_SYS_STATE_ACTIVE = 1;
@@ -111,7 +111,7 @@
     const auto christmas = unity::indicator::datetime::DateTime::Local(2015,12,25,0,0,0);
     appt.begin = christmas.start_of_day();
     appt.end = christmas.end_of_day();
-    appt.alarms.push_back(unity::indicator::datetime::Alarm{"Ho Ho Ho!", "", appt.begin});
+    appt.alarms.push_back(unity::indicator::datetime::Alarm{"Ho Ho Ho!", CALENDAR_DEFAULT_SOUND, appt.begin});
 
     // init an Ubuntu Alarm
     ualarm.color = "red";
@@ -165,8 +165,8 @@
                                                 NOTIFY_INTERFACE,
                                                 &error);
     g_assert_no_error(error);
-   
-    // METHOD_GET_INFO 
+
+    // METHOD_GET_INFO
     str = g_strdup("ret = ('mock-notify', 'test vendor', '1.0', '1.1')");
     dbus_test_dbus_mock_object_add_method(notify_mock,
                                           notify_obj,
@@ -196,7 +196,7 @@
     g_assert_no_error (error);
     g_free (str);
 
-    // METHOD_CLOSE 
+    // METHOD_CLOSE
     str = g_strdup_printf("self.EmitSignal('%s', '%s', 'uu', [ args[0], %d ])",
                           NOTIFY_INTERFACE,
                           SIGNAL_CLOSED,
@@ -223,8 +223,8 @@
                                                 BUS_POWERD_INTERFACE,
                                                 &error);
     g_assert_no_error(error);
-   
-    str = g_strdup_printf ("ret = '%s'", POWERD_COOKIE); 
+
+    str = g_strdup_printf ("ret = '%s'", POWERD_COOKIE);
     dbus_test_dbus_mock_object_add_method(powerd_mock,
                                           powerd_obj,
                                           POWERD_METHOD_REQUEST_SYS_STATE,
@@ -256,8 +256,8 @@
                                                 BUS_SCREEN_INTERFACE,
                                                 &error);
     g_assert_no_error(error);
-   
-    str = g_strdup_printf ("ret = %d", SCREEN_COOKIE); 
+
+    str = g_strdup_printf ("ret = %d", SCREEN_COOKIE);
     dbus_test_dbus_mock_object_add_method(screen_mock,
                                           screen_obj,
                                           SCREEN_METHOD_KEEP_DISPLAY_ON,
@@ -287,7 +287,7 @@
                                                 BUS_HAPTIC_PATH,
                                                 BUS_HAPTIC_INTERFACE,
                                                 &error);
-   
+
     dbus_test_dbus_mock_object_add_method(haptic_mock,
                                           haptic_obj,
                                           HAPTIC_METHOD_VIBRATE_PATTERN,

=== modified file 'tests/run-eds-ics-test.sh'
--- tests/run-eds-ics-test.sh	2015-07-20 16:31:28 +0000
+++ tests/run-eds-ics-test.sh	2016-04-19 13:10:52 +0000
@@ -6,6 +6,7 @@
 TEST_NAME=$3   # test name
 CONFIG_DIR=$4  # config files
 ICS_FILE=$5    # ical file holding test data
+ACCOUNTS_DB=$6 # online account database
 
 echo "this script: ${SELF}"
 echo "test-runner: ${TEST_RUNNER}"
@@ -54,8 +55,15 @@
   cp --verbose --archive ${ICS_FILE} ${XDG_DATA_HOME}/evolution/tasks/system/tasks.ics
 fi
 
+# prepare online accounts database
+if [ -e ${ACCOUNTS_DB} ]; then
+  echo "copying ${ACCOUNTS_DB} into $HOME"
+  mkdir -p ${XDG_CONFIG_HOME}/libaccounts-glib/
+  cp --verbose --archive ${ACCOUNTS_DB} ${XDG_CONFIG_HOME}/libaccounts-glib/accounts.db
+fi
+
 # run the test
-${TEST_RUNNER} --keep-env --max-wait=90 --task ${TEST_EXEC} --task-name ${TEST_NAME} --wait-until-complete 
+${TEST_RUNNER} --keep-env --max-wait=90 --task ${TEST_EXEC} --task-name ${TEST_NAME} --wait-until-complete
 rv=$?
 
 # if the test passed, blow away the tmpdir

=== modified file 'tests/test-eds-ics-all-day-events.cpp'
--- tests/test-eds-ics-all-day-events.cpp	2015-05-21 12:47:24 +0000
+++ tests/test-eds-ics-all-day-events.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150521T111538Z-7449-1000-3572-0@ghidorah";

=== modified file 'tests/test-eds-ics-missing-trigger.cpp'
--- tests/test-eds-ics-missing-trigger.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-missing-trigger.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MissingTriggers)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};

=== added file 'tests/test-eds-ics-non-attending-alarms.cpp'
--- tests/test-eds-ics-non-attending-alarms.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-eds-ics-non-attending-alarms.cpp	2016-04-19 13:10:52 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2015 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/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <algorithm>
+
+#include <datetime/alarm-queue-simple.h>
+#include <datetime/clock-mock.h>
+#include <datetime/engine-eds.h>
+#include <datetime/myself.h>
+#include <datetime/planner-range.h>
+
+#include <gtest/gtest.h>
+
+#include "glib-fixture.h"
+#include "print-to.h"
+#include "timezone-mock.h"
+#include "wakeup-timer-mock.h"
+
+using namespace unity::indicator::datetime;
+using VAlarmFixture = GlibFixture;
+
+/***
+****
+***/
+
+TEST_F(VAlarmFixture, NonAttendingEvent)
+{
+    // start the EDS engine
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
+
+    // we need a consistent timezone for the planner and our local DateTimes
+    constexpr char const * zone_str {"America/Recife"};
+    auto tz = std::make_shared<MockTimezone>(zone_str);
+    auto gtz = g_time_zone_new(zone_str);
+
+    // make a planner that looks at the first half of 2016 in EDS
+    auto planner = std::make_shared<SimpleRangePlanner>(engine, tz);
+    const DateTime range_begin {gtz, 2016,1, 1, 0, 0, 0.0};
+    const DateTime range_end   {gtz, 2016,6,31,23,59,59.5};
+    planner->range().set(std::make_pair(range_begin, range_end));
+
+    // give EDS a moment to load
+    if (planner->appointments().get().empty()) {
+        g_message("waiting a moment for EDS to load...");
+        auto on_appointments_changed = [this](const std::vector<Appointment>& appointments){
+            g_message("ah, they loaded");
+            if (!appointments.empty())
+                g_main_loop_quit(loop);
+        };
+        core::ScopedConnection conn(planner->appointments().changed().connect(on_appointments_changed));
+        constexpr int max_wait_sec = 10;
+        wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
+    }
+
+    // the planner should match what we've got in the calendar.ics file
+    const auto appts = planner->appointments().get();
+    EXPECT_EQ(2, appts.size());
+    EXPECT_EQ(appts[0].begin, DateTime(gtz, 2016, 4, 4, 16, 0, 0));
+    EXPECT_EQ(appts[1].begin, DateTime(gtz, 2016, 4, 6, 16, 0, 0));
+
+    // cleanup
+    g_time_zone_unref(gtz);
+}

=== added file 'tests/test-eds-ics-non-attending-alarms.ics.in'
--- tests/test-eds-ics-non-attending-alarms.ics.in	1970-01-01 00:00:00 +0000
+++ tests/test-eds-ics-non-attending-alarms.ics.in	2016-04-19 13:10:52 +0000
@@ -0,0 +1,53 @@
+BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+PRODID:-//Ximian//NONSGML Evolution Calendar//EN
+VERSION:2.0
+X-EVOLUTION-DATA-REVISION:2015-04-05T21:32:47.354433Z(2)
+BEGIN:VEVENT
+STATUS:CONFIRMED
+DTSTAMP:20160405T152128Z
+CREATED:20160405T152128Z
+UID:[e-mail]
+SEQUENCE:1
+TRANSP:OPAQUE
+SUMMARY:Every day at 4PM
+DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160404T160000
+RRULE:FREQ=DAILY;UNTIL=20160406T190000Z
+DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160404T170000
+ATTENDEE;CN=Uphablet;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;
+ CUTYPE=INDIVIDUAL:mailto:[e-mail]
+LAST-MODIFIED:20160405T152128Z
+BEGIN:VALARM
+TRIGGER;VALUE=DURATION:-PT30M
+ACTION:EMAIL
+DESCRIPTION:This is an event reminder
+X-EVOLUTION-ALARM-UID:20160405T152128Z-2848-32011-1844-65@ubuntu-phablet
+END:VALARM
+END:VEVENT
+BEGIN:VEVENT
+STATUS:CONFIRMED
+DTSTAMP:20160405T152128Z
+CREATED:20160405T151054Z
+UID:[e-mail]
+SEQUENCE:1
+TRANSP:OPAQUE
+SUMMARY::Every day at 4PM
+DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/America/Fortaleza:
+ 20160405T160000
+RECURRENCE-ID;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160405T160000
+DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/America/Fortaleza:
+ 20160405T170000
+ATTENDEE;CN=Uphablet;PARTSTAT=DECLINED;ROLE=REQ-PARTICIPANT;
+ CUTYPE=INDIVIDUAL:mailto:[e-mail]
+LAST-MODIFIED:20160405T152128Z
+BEGIN:VALARM
+TRIGGER;VALUE=DURATION:-PT30M
+ACTION:EMAIL
+DESCRIPTION:This is an event reminder
+X-EVOLUTION-ALARM-UID:20160405T152128Z-2848-32011-1844-66@ubuntu-phablet
+END:VALARM
+END:VEVENT
+END:VCALENDAR

=== modified file 'tests/test-eds-ics-nonrepeating-events.cpp'
--- tests/test-eds-ics-nonrepeating-events.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-nonrepeating-events.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150520T000726Z-3878-32011-1770-81@ubuntu-phablet";

=== modified file 'tests/test-eds-ics-repeating-events.cpp'
--- tests/test-eds-ics-repeating-events.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-repeating-events.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150507T211449Z-4262-32011-1418-1@ubuntu-phablet";

=== modified file 'tests/test-eds-ics-repeating-valarms.cpp'
--- tests/test-eds-ics-repeating-valarms.cpp	2015-05-20 23:23:32 +0000
+++ tests/test-eds-ics-repeating-valarms.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -72,14 +73,14 @@
     ASSERT_EQ(1, appts.size());
     const auto& appt = appts.front();
     ASSERT_EQ(8, appt.alarms.size());
-    EXPECT_EQ(Alarm({"Time to pack!",      "", DateTime(gtz,2015,4,23,13,35,0)}), appt.alarms[0]);
-    EXPECT_EQ(Alarm({"Time to pack!",      "", DateTime(gtz,2015,4,23,13,37,0)}), appt.alarms[1]);
-    EXPECT_EQ(Alarm({"Time to pack!",      "", DateTime(gtz,2015,4,23,13,39,0)}), appt.alarms[2]);
-    EXPECT_EQ(Alarm({"Time to pack!",      "", DateTime(gtz,2015,4,23,13,41,0)}), appt.alarms[3]);
-    EXPECT_EQ(Alarm({"Go to the airport!", "", DateTime(gtz,2015,4,24,10,35,0)}), appt.alarms[4]);
-    EXPECT_EQ(Alarm({"Go to the airport!", "", DateTime(gtz,2015,4,24,10,37,0)}), appt.alarms[5]);
-    EXPECT_EQ(Alarm({"Go to the airport!", "", DateTime(gtz,2015,4,24,10,39,0)}), appt.alarms[6]);
-    EXPECT_EQ(Alarm({"Go to the airport!", "", DateTime(gtz,2015,4,24,10,41,0)}), appt.alarms[7]);
+    EXPECT_EQ(Alarm({"Time to pack!",      "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,23,13,35,0)}), appt.alarms[0]);
+    EXPECT_EQ(Alarm({"Time to pack!",      "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,23,13,37,0)}), appt.alarms[1]);
+    EXPECT_EQ(Alarm({"Time to pack!",      "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,23,13,39,0)}), appt.alarms[2]);
+    EXPECT_EQ(Alarm({"Time to pack!",      "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,23,13,41,0)}), appt.alarms[3]);
+    EXPECT_EQ(Alarm({"Go to the airport!", "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,24,10,35,0)}), appt.alarms[4]);
+    EXPECT_EQ(Alarm({"Go to the airport!", "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,24,10,37,0)}), appt.alarms[5]);
+    EXPECT_EQ(Alarm({"Go to the airport!", "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,24,10,39,0)}), appt.alarms[6]);
+    EXPECT_EQ(Alarm({"Go to the airport!", "file://" CALENDAR_DEFAULT_SOUND, DateTime(gtz,2015,4,24,10,41,0)}), appt.alarms[7]);
 
     // now let's try this out with AlarmQueue...
     // hook the planner up to a SimpleAlarmQueue and confirm that it triggers for each of the reminders

=== modified file 'tests/test-eds-ics-tzids-2.cpp'
--- tests/test-eds-ics-tzids-2.cpp	2015-07-09 20:56:13 +0000
+++ tests/test-eds-ics-tzids-2.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Los_Angeles"};

=== modified file 'tests/test-eds-ics-tzids-utc.cpp'
--- tests/test-eds-ics-tzids-utc.cpp	2016-03-22 19:13:10 +0000
+++ tests/test-eds-ics-tzids-utc.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, UTCAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Recife"};

=== modified file 'tests/test-eds-ics-tzids.cpp'
--- tests/test-eds-ics-tzids.cpp	2015-07-09 19:14:32 +0000
+++ tests/test-eds-ics-tzids.cpp	2016-04-19 13:10:52 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"Europe/Berlin"};

=== modified file 'tests/test-notification.cpp'
--- tests/test-notification.cpp	2016-02-11 04:30:46 +0000
+++ tests/test-notification.cpp	2016-04-19 13:10:52 +0000
@@ -63,7 +63,7 @@
     bool expected_notify_called;
     bool expected_vibrate_called;
   } test_appts[] = {
-    { appt, "reminder", "Event", true, true },
+    { appt, "appointment", "Event", true, true },
     { ualarm, "alarm-clock", "Alarm", true, true }
   };
 

=== modified file 'tests/test-sound.cpp'
--- tests/test-sound.cpp	2016-02-10 20:49:01 +0000
+++ tests/test-sound.cpp	2016-04-19 13:10:52 +0000
@@ -85,7 +85,7 @@
 
   // confirm that the icon passed to Notify was "alarm-clock"
   g_variant_get_child (params, 2, "&s", &str);
-  ASSERT_STREQ("reminder", str);
+  ASSERT_STREQ("appointment", str);
 
   // confirm that the hints passed to Notify included a timeout matching duration_minutes
   int32_t i32;