From 9e29a4fdb99b722c43af1268312db68fff17fc60 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Wed, 25 Mar 2015 12:42:28 -0500 Subject: 60 seconds after triggering an alarm, release our keepDisplayOn request --- src/awake.cpp | 134 ++++++++++++++++++++++++++++++++++++++-------------------- src/snap.cpp | 23 ++++++++-- 2 files changed, 107 insertions(+), 50 deletions(-) (limited to 'src') diff --git a/src/awake.cpp b/src/awake.cpp index 57358ab..fda4099 100644 --- a/src/awake.cpp +++ b/src/awake.cpp @@ -22,7 +22,7 @@ #include -#include +#include namespace unity { namespace indicator { @@ -56,6 +56,19 @@ public: } } + bool display_forced() const + { + return !m_screen_cookies.empty(); + } + + void set_display_forced(bool force) + { + if (force) + force_screen(); + else if (!force) + unforce_screen(); + } + private: static void on_system_bus_ready (GObject *, @@ -95,19 +108,7 @@ private: on_force_awake_response, self); - // ask unity-system-compositor to turn on the screen - g_dbus_connection_call (system_bus, - BUS_SCREEN_NAME, - BUS_SCREEN_PATH, - BUS_SCREEN_INTERFACE, - "keepDisplayOn", - nullptr, - G_VARIANT_TYPE("(i)"), - G_DBUS_CALL_FLAGS_NONE, - -1, - self->m_cancellable, - on_force_screen_response, - self); + self->force_screen(); g_object_unref (system_bus); } @@ -146,6 +147,53 @@ private: } } + void unforce_awake () + { + g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); + + if (m_awake_cookie != nullptr) + { + g_dbus_connection_call (m_system_bus, + BUS_POWERD_NAME, + BUS_POWERD_PATH, + BUS_POWERD_INTERFACE, + "clearSysState", + g_variant_new("(s)", m_awake_cookie), + nullptr, + G_DBUS_CALL_FLAGS_NONE, + -1, + nullptr, + nullptr, + nullptr); + + g_clear_pointer (&m_awake_cookie, g_free); + } + } + + /*** + **** FORCE DISPLAY ON + ***/ + + void force_screen() + { + g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); + g_return_if_fail (m_screen_cookies.empty()); + + // ask unity-system-compositor to turn on the screen + g_dbus_connection_call (m_system_bus, + BUS_SCREEN_NAME, + BUS_SCREEN_PATH, + BUS_SCREEN_INTERFACE, + "keepDisplayOn", + nullptr, + G_VARIANT_TYPE("(i)"), + G_DBUS_CALL_FLAGS_NONE, + -1, + m_cancellable, + on_force_screen_response, + this); + } + static void on_force_screen_response (GObject * connection, GAsyncResult * res, gpointer gself) @@ -171,34 +219,11 @@ private: { auto self = static_cast(gself); - self->m_screen_cookie = NO_SCREEN_COOKIE; - g_variant_get (args, "(i)", &self->m_screen_cookie); - g_debug ("m_screen_cookie is now '%d'", self->m_screen_cookie); - + gint32 cookie = 0; + g_variant_get (args, "(i)", &cookie); g_variant_unref (args); - } - } - - void unforce_awake () - { - g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); - - if (m_awake_cookie != nullptr) - { - g_dbus_connection_call (m_system_bus, - BUS_POWERD_NAME, - BUS_POWERD_PATH, - BUS_POWERD_INTERFACE, - "clearSysState", - g_variant_new("(s)", m_awake_cookie), - nullptr, - G_DBUS_CALL_FLAGS_NONE, - -1, - nullptr, - nullptr, - nullptr); - - g_clear_pointer (&m_awake_cookie, g_free); + g_debug ("got screen_cookie '%d'", (int)cookie); + self->m_screen_cookies.insert (cookie); } } @@ -206,32 +231,34 @@ private: { g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); - if (m_screen_cookie != NO_SCREEN_COOKIE) + for (auto cookie : m_screen_cookies) { g_dbus_connection_call (m_system_bus, BUS_SCREEN_NAME, BUS_SCREEN_PATH, BUS_SCREEN_INTERFACE, "removeDisplayOnRequest", - g_variant_new("(i)", m_screen_cookie), + g_variant_new("(i)", cookie), nullptr, G_DBUS_CALL_FLAGS_NONE, -1, nullptr, nullptr, nullptr); - - m_screen_cookie = NO_SCREEN_COOKIE; } + + m_screen_cookies.clear(); } const std::string m_app_name; GCancellable * m_cancellable = nullptr; GDBusConnection * m_system_bus = nullptr; char * m_awake_cookie = nullptr; - int32_t m_screen_cookie = NO_SCREEN_COOKIE; - static constexpr int32_t NO_SCREEN_COOKIE { std::numeric_limits::min() }; + // In general there will only be one cookie in this container... + // holding N cookies is a safeguard in case the client calls force_screen() + // while there's aleady a pending keepDisplayOn call on the bus. + std::set m_screen_cookies; }; /*** @@ -247,6 +274,19 @@ Awake::~Awake() { } +bool +Awake::display_forced() const +{ + return impl->display_forced(); +} + +void +Awake::set_display_forced(bool forced) +{ + impl->set_display_forced(forced); +} + + /*** **** ***/ diff --git a/src/snap.cpp b/src/snap.cpp index e655d2d..80f200d 100644 --- a/src/snap.cpp +++ b/src/snap.cpp @@ -88,8 +88,9 @@ public: intervention and shouldn't loop the sound. */ const bool interactive = appointment.is_ubuntu_alarm() && m_engine->supports_actions(); - // force the system to stay awake - auto awake = std::make_shared(m_engine->app_name()); + // Force the system to stay awake. + // In a clean world this would be a shared_ptr, but we use it as a GSourceFunc arg... + auto awake = new uin::Awake(m_engine->app_name()); // calendar events are muted in silent mode; alarm clocks never are std::shared_ptr sound; @@ -137,15 +138,31 @@ public: b.add_action ("snooze", _("Snooze")); } + // Don't keep the screen on forever. + // If the alarm keeps going on and on, release our screen-on lock + // after awhile to prevent unneccesary battery drain + constexpr int screen_awake_seconds { 60 }; + auto awake_timeout_func = [](gpointer a){ + static_cast(a)->set_display_forced(false); + return G_SOURCE_REMOVE; + }; + auto awake_timeout_tag = g_timeout_add_seconds (screen_awake_seconds, + awake_timeout_func, + awake); + // add 'sound', 'haptic', and 'awake' objects to the capture so // they stay alive until the closed callback is called; i.e., // for the lifespan of the notficiation - b.set_closed_callback([appointment, snooze, ok, sound, awake, haptic] + b.set_closed_callback([appointment, snooze, ok, sound, haptic, + awake, awake_timeout_tag] (const std::string& action){ if (action == "snooze") snooze(appointment); else ok(appointment); + + g_source_remove(awake_timeout_tag); + delete awake; }); const auto key = m_engine->show(b); -- cgit v1.2.3 From 4bf70c7afae44d4005d25105690304b4e9e361f3 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Wed, 25 Mar 2015 15:47:22 -0500 Subject: the previous commit made the Awake API too complicated... simplifying. --- src/awake.cpp | 176 ++++++++++++++++++++++++++-------------------------------- src/snap.cpp | 26 ++------- 2 files changed, 86 insertions(+), 116 deletions(-) (limited to 'src') diff --git a/src/awake.cpp b/src/awake.cpp index fda4099..a37d185 100644 --- a/src/awake.cpp +++ b/src/awake.cpp @@ -22,7 +22,7 @@ #include -#include +#include namespace unity { namespace indicator { @@ -36,9 +36,10 @@ class Awake::Impl { public: - Impl(const std::string& app_name): + Impl(const std::string& app_name, unsigned int display_on_seconds): m_app_name(app_name), - m_cancellable(g_cancellable_new()) + m_cancellable(g_cancellable_new()), + m_display_on_seconds(display_on_seconds) { g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this); } @@ -48,27 +49,20 @@ public: g_cancellable_cancel (m_cancellable); g_object_unref (m_cancellable); + if (m_display_on_timer) + { + g_source_remove (m_display_on_timer); + m_display_on_timer = 0; + } + if (m_system_bus != nullptr) { unforce_awake (); - unforce_screen (); + remove_display_on_request (); g_object_unref (m_system_bus); } } - bool display_forced() const - { - return !m_screen_cookies.empty(); - } - - void set_display_forced(bool force) - { - if (force) - force_screen(); - else if (!force) - unforce_screen(); - } - private: static void on_system_bus_ready (GObject *, @@ -108,7 +102,19 @@ private: on_force_awake_response, self); - self->force_screen(); + // ask unity-system-compositor to turn on the screen + g_dbus_connection_call (system_bus, + BUS_SCREEN_NAME, + BUS_SCREEN_PATH, + BUS_SCREEN_INTERFACE, + "keepDisplayOn", + nullptr, + G_VARIANT_TYPE("(i)"), + G_DBUS_CALL_FLAGS_NONE, + -1, + self->m_cancellable, + on_keep_display_on_response, + self); g_object_unref (system_bus); } @@ -147,56 +153,9 @@ private: } } - void unforce_awake () - { - g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); - - if (m_awake_cookie != nullptr) - { - g_dbus_connection_call (m_system_bus, - BUS_POWERD_NAME, - BUS_POWERD_PATH, - BUS_POWERD_INTERFACE, - "clearSysState", - g_variant_new("(s)", m_awake_cookie), - nullptr, - G_DBUS_CALL_FLAGS_NONE, - -1, - nullptr, - nullptr, - nullptr); - - g_clear_pointer (&m_awake_cookie, g_free); - } - } - - /*** - **** FORCE DISPLAY ON - ***/ - - void force_screen() - { - g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); - g_return_if_fail (m_screen_cookies.empty()); - - // ask unity-system-compositor to turn on the screen - g_dbus_connection_call (m_system_bus, - BUS_SCREEN_NAME, - BUS_SCREEN_PATH, - BUS_SCREEN_INTERFACE, - "keepDisplayOn", - nullptr, - G_VARIANT_TYPE("(i)"), - G_DBUS_CALL_FLAGS_NONE, - -1, - m_cancellable, - on_force_screen_response, - this); - } - - static void on_force_screen_response (GObject * connection, - GAsyncResult * res, - gpointer gself) + static void on_keep_display_on_response (GObject * connection, + GAsyncResult * res, + gpointer gself) { GError * error; GVariant * args; @@ -219,54 +178,92 @@ private: { auto self = static_cast(gself); - gint32 cookie = 0; - g_variant_get (args, "(i)", &cookie); + self->m_display_on_cookie = NO_DISPLAY_ON_COOKIE; + g_variant_get (args, "(i)", &self->m_display_on_cookie); + g_debug ("m_display_on_cookie is now '%d'", self->m_display_on_cookie); + + self->m_display_on_timer = g_timeout_add_seconds (self->m_display_on_seconds, + on_display_on_timer, + gself); + g_variant_unref (args); - g_debug ("got screen_cookie '%d'", (int)cookie); - self->m_screen_cookies.insert (cookie); } } - void unforce_screen () + static gboolean on_display_on_timer (gpointer gself) + { + auto self = static_cast(gself); + + self->m_display_on_timer = 0; + self->remove_display_on_request(); + + return G_SOURCE_REMOVE; + } + + + void unforce_awake () { g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); - for (auto cookie : m_screen_cookies) + if (m_awake_cookie != nullptr) + { + g_dbus_connection_call (m_system_bus, + BUS_POWERD_NAME, + BUS_POWERD_PATH, + BUS_POWERD_INTERFACE, + "clearSysState", + g_variant_new("(s)", m_awake_cookie), + nullptr, + G_DBUS_CALL_FLAGS_NONE, + -1, + nullptr, + nullptr, + nullptr); + + g_clear_pointer (&m_awake_cookie, g_free); + } + } + + void remove_display_on_request () + { + g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus)); + + if (m_display_on_cookie != NO_DISPLAY_ON_COOKIE) { g_dbus_connection_call (m_system_bus, BUS_SCREEN_NAME, BUS_SCREEN_PATH, BUS_SCREEN_INTERFACE, "removeDisplayOnRequest", - g_variant_new("(i)", cookie), + g_variant_new("(i)", m_display_on_cookie), nullptr, G_DBUS_CALL_FLAGS_NONE, -1, nullptr, nullptr, nullptr); - } - m_screen_cookies.clear(); + m_display_on_cookie = NO_DISPLAY_ON_COOKIE; + } } const std::string m_app_name; GCancellable * m_cancellable = nullptr; GDBusConnection * m_system_bus = nullptr; char * m_awake_cookie = nullptr; + int32_t m_display_on_cookie = NO_DISPLAY_ON_COOKIE; + const guint m_display_on_seconds; + guint m_display_on_timer; - // In general there will only be one cookie in this container... - // holding N cookies is a safeguard in case the client calls force_screen() - // while there's aleady a pending keepDisplayOn call on the bus. - std::set m_screen_cookies; + static constexpr int32_t NO_DISPLAY_ON_COOKIE { std::numeric_limits::min() }; }; /*** **** ***/ -Awake::Awake(const std::string& app_name): - impl(new Impl (app_name)) +Awake::Awake(const std::string& app_name, unsigned int display_on_seconds): + impl(new Impl (app_name, display_on_seconds)) { } @@ -274,19 +271,6 @@ Awake::~Awake() { } -bool -Awake::display_forced() const -{ - return impl->display_forced(); -} - -void -Awake::set_display_forced(bool forced) -{ - impl->set_display_forced(forced); -} - - /*** **** ***/ diff --git a/src/snap.cpp b/src/snap.cpp index 80f200d..4329eca 100644 --- a/src/snap.cpp +++ b/src/snap.cpp @@ -88,9 +88,11 @@ public: intervention and shouldn't loop the sound. */ const bool interactive = appointment.is_ubuntu_alarm() && m_engine->supports_actions(); - // Force the system to stay awake. - // In a clean world this would be a shared_ptr, but we use it as a GSourceFunc arg... - auto awake = new uin::Awake(m_engine->app_name()); + // keep the screen on for the first part of the alarm; + // keep the system awake for the duration of the alarm + constexpr unsigned int display_on_seconds = 60; + auto awake = std::make_shared(m_engine->app_name(), + display_on_seconds); // calendar events are muted in silent mode; alarm clocks never are std::shared_ptr sound; @@ -138,31 +140,15 @@ public: b.add_action ("snooze", _("Snooze")); } - // Don't keep the screen on forever. - // If the alarm keeps going on and on, release our screen-on lock - // after awhile to prevent unneccesary battery drain - constexpr int screen_awake_seconds { 60 }; - auto awake_timeout_func = [](gpointer a){ - static_cast(a)->set_display_forced(false); - return G_SOURCE_REMOVE; - }; - auto awake_timeout_tag = g_timeout_add_seconds (screen_awake_seconds, - awake_timeout_func, - awake); - // add 'sound', 'haptic', and 'awake' objects to the capture so // they stay alive until the closed callback is called; i.e., // for the lifespan of the notficiation - b.set_closed_callback([appointment, snooze, ok, sound, haptic, - awake, awake_timeout_tag] + b.set_closed_callback([appointment, snooze, ok, sound, awake, haptic] (const std::string& action){ if (action == "snooze") snooze(appointment); else ok(appointment); - - g_source_remove(awake_timeout_tag); - delete awake; }); const auto key = m_engine->show(b); -- cgit v1.2.3 From 845067b3f37ff48eab3b612d52518e529559b738 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Tue, 31 Mar 2015 13:54:26 -0500 Subject: simplify the awake display timeout code --- src/awake.cpp | 23 ++++++++++++++++------- src/snap.cpp | 7 ++----- 2 files changed, 18 insertions(+), 12 deletions(-) (limited to 'src') diff --git a/src/awake.cpp b/src/awake.cpp index a37d185..e1bec6c 100644 --- a/src/awake.cpp +++ b/src/awake.cpp @@ -36,10 +36,9 @@ class Awake::Impl { public: - Impl(const std::string& app_name, unsigned int display_on_seconds): + Impl(const std::string& app_name): m_app_name(app_name), - m_cancellable(g_cancellable_new()), - m_display_on_seconds(display_on_seconds) + m_cancellable(g_cancellable_new()) { g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this); } @@ -251,9 +250,19 @@ private: GCancellable * m_cancellable = nullptr; GDBusConnection * m_system_bus = nullptr; char * m_awake_cookie = nullptr; + + /** + * As described by bug #1434637, alarms should have the display turn on, + * dim, and turn off "just like it would if you'd woken it up yourself". + * USC may be adding an intent-based bus API to handle this use case, + * e.g. turnDisplayOnTemporarily(intent), but there's no timeframe for it. + * + * Until that's avaialble, we can get close to Design's specs by + * requesting a display-on cookie and then releasing the cookie + * a moment later. */ + const guint m_display_on_seconds = 1; + guint m_display_on_timer = 0; int32_t m_display_on_cookie = NO_DISPLAY_ON_COOKIE; - const guint m_display_on_seconds; - guint m_display_on_timer; static constexpr int32_t NO_DISPLAY_ON_COOKIE { std::numeric_limits::min() }; }; @@ -262,8 +271,8 @@ private: **** ***/ -Awake::Awake(const std::string& app_name, unsigned int display_on_seconds): - impl(new Impl (app_name, display_on_seconds)) +Awake::Awake(const std::string& app_name): + impl(new Impl(app_name)) { } diff --git a/src/snap.cpp b/src/snap.cpp index 4329eca..e655d2d 100644 --- a/src/snap.cpp +++ b/src/snap.cpp @@ -88,11 +88,8 @@ public: intervention and shouldn't loop the sound. */ const bool interactive = appointment.is_ubuntu_alarm() && m_engine->supports_actions(); - // keep the screen on for the first part of the alarm; - // keep the system awake for the duration of the alarm - constexpr unsigned int display_on_seconds = 60; - auto awake = std::make_shared(m_engine->app_name(), - display_on_seconds); + // force the system to stay awake + auto awake = std::make_shared(m_engine->app_name()); // calendar events are muted in silent mode; alarm clocks never are std::shared_ptr sound; -- cgit v1.2.3 From fff19d70649589b81a896e4deb032a7bd4bdca1e Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Tue, 31 Mar 2015 18:54:04 -0500 Subject: add an Alarm class to represent ical valarm components; change the Appointment class to hold an arbitrary number of Alarms. --- src/actions-live.cpp | 19 ++++-- src/appointment.cpp | 13 +++- src/engine-eds.cpp | 163 ++++++++++++++++++++++++++++++++++++++++----------- src/main.cpp | 12 ++-- src/snap.cpp | 16 ++--- 5 files changed, 167 insertions(+), 56 deletions(-) (limited to 'src') diff --git a/src/actions-live.cpp b/src/actions-live.cpp index 4d1f770..3cbfb78 100644 --- a/src/actions-live.cpp +++ b/src/actions-live.cpp @@ -135,12 +135,19 @@ void LiveActions::phone_open_alarm_app() void LiveActions::phone_open_appointment(const Appointment& appt) { - if (!appt.url.empty()) - dispatch_url(appt.url); - else if (appt.is_ubuntu_alarm()) - phone_open_alarm_app(); - else - phone_open_calendar_app(DateTime::NowLocal()); + if (!appt.activation_url.empty()) + { + dispatch_url(appt.activation_url); + } + else switch (appt.type) + { + case Appointment::UBUNTU_ALARM: + phone_open_alarm_app(); + break; + + default: + phone_open_calendar_app(appt.begin); + } } void LiveActions::phone_open_calendar_app(const DateTime&) diff --git a/src/appointment.cpp b/src/appointment.cpp index ae71459..236c5f4 100644 --- a/src/appointment.cpp +++ b/src/appointment.cpp @@ -27,16 +27,23 @@ namespace datetime { ***** ****/ +bool Alarm::operator==(const Alarm& that) const +{ + return (text==that.text) + && (audio_url==that.audio_url) + && (this->time==that.time) + && (duration==that.duration); +} + bool Appointment::operator==(const Appointment& that) const { return (type==that.type) && (uid==that.uid) && (color==that.color) && (summary==that.summary) - && (url==that.url) - && (audio_url==that.audio_url) && (begin==that.begin) - && (end==that.end); + && (end==that.end) + && (alarms==that.alarms); } /**** diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 47c7a9b..820d9d4 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -126,12 +126,18 @@ public: auto extension = e_source_get_extension(source, E_SOURCE_EXTENSION_CALENDAR); const auto color = e_source_selectable_get_color(E_SOURCE_SELECTABLE(extension)); g_debug("calling e_cal_client_generate_instances for %p", (void*)client); + auto subtask = new AppointmentSubtask(main_task, + client, + color, + default_timezone, + begin_timet, + end_timet); e_cal_client_generate_instances(client, begin_timet, end_timet, m_cancellable, my_get_appointments_foreach, - new AppointmentSubtask (main_task, client, color), + subtask, [](gpointer g){delete static_cast(g);}); } } @@ -409,14 +415,71 @@ private: std::shared_ptr task; ECalClient* client; std::string color; - AppointmentSubtask(const std::shared_ptr& task_in, ECalClient* client_in, const char* color_in): - task(task_in), client(client_in) + icaltimezone* default_timezone; + time_t begin; + time_t end; + + AppointmentSubtask(const std::shared_ptr& task_in, + ECalClient* client_in, + const char* color_in, + icaltimezone* default_tz, + time_t begin_, + time_t end_): + task(task_in), + client(client_in), + default_timezone(default_tz), + begin(begin_), + end(end_) { if (color_in) color = color_in; } }; + static std::string get_alarm_text(ECalComponentAlarm * alarm) + { + std::string ret; + + ECalComponentAlarmAction action; + e_cal_component_alarm_get_action(alarm, &action); + if (action == E_CAL_COMPONENT_ALARM_DISPLAY) + { + ECalComponentText text; + text.value = nullptr; + e_cal_component_alarm_get_description(alarm, &text); + if (text.value) + ret = text.value; + } + + return ret; + } + + static std::string get_alarm_sound_url(ECalComponentAlarm * alarm) + { + std::string ret; + + ECalComponentAlarmAction action; + e_cal_component_alarm_get_action(alarm, &action); + if (action == E_CAL_COMPONENT_ALARM_AUDIO) + { + icalattach* attach = nullptr; + e_cal_component_alarm_get_attach(alarm, &attach); + if (attach != nullptr) + { + if (icalattach_get_is_url (attach)) + { + const char* url = icalattach_get_url(attach); + if (url != nullptr) + ret = url; + } + + icalattach_unref(attach); + } + } + + return ret; + } + static gboolean my_get_appointments_foreach(ECalComponent* component, time_t begin, @@ -461,6 +524,7 @@ private: (status != ICAL_STATUS_COMPLETED) && (status != ICAL_STATUS_CANCELLED)) { + ECalComponentAlarmAction omit[] = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 Appointment appointment; ECalComponentText text; @@ -475,47 +539,76 @@ private: appointment.uid = uid; appointment.type = type; - // Look through all of this component's alarms - // for DISPLAY or AUDIO url attachments. - // If we find any, use them for appointment.url and audio_sound - auto alarm_uids = e_cal_component_get_alarm_uids(component); - for(auto walk=alarm_uids; appointment.url.empty() && walk!=nullptr; walk=walk->next) + icalcomponent * icc = e_cal_component_get_icalcomponent(component); + g_debug("%s", icalcomponent_as_ical_string(icc)); // libical owns this string; no leak + + auto e_alarms = e_cal_util_generate_alarms_for_comp(component, + subtask->begin, + subtask->end, + omit, + e_cal_client_resolve_tzid_cb, + subtask->client, + subtask->default_timezone); + + std::map alarms; + + if (e_alarms != nullptr) { - auto alarm = e_cal_component_get_alarm(component, static_cast(walk->data)); + for (auto l=e_alarms->alarms; l!=nullptr; l=l->next) + { + auto ai = static_cast(l->data); + auto a = e_cal_component_get_alarm(component, ai->auid); - ECalComponentAlarmAction action; - e_cal_component_alarm_get_action(alarm, &action); - if ((action == E_CAL_COMPONENT_ALARM_DISPLAY) || (action == E_CAL_COMPONENT_ALARM_AUDIO)) + if (a != nullptr) + { + const DateTime alarm_begin{ai->occur_start}; + auto& alarm = alarms[alarm_begin]; + + if (alarm.text.empty()) + alarm.text = get_alarm_text(a); + if (alarm.audio_url.empty()) + alarm.audio_url = get_alarm_sound_url(a); + if (!alarm.time.is_set()) + alarm.time = alarm_begin; + if (alarm.duration == std::chrono::seconds::zero()) + alarm.duration = std::chrono::seconds(ai->occur_end - ai->occur_start); + + e_cal_component_alarm_free(a); + } + } + + e_cal_component_alarms_free(e_alarms); + } + // hm, no trigger. if this came from ubuntu-clock-app, + // manually add a single trigger for the todo event's time + else if (appointment.is_ubuntu_alarm()) + { + Alarm tmp; + tmp.time = appointment.begin; + + auto auids = e_cal_component_get_alarm_uids(component); + for(auto l=auids; l!=nullptr; l=l->next) { - icalattach* attach = nullptr; - e_cal_component_alarm_get_attach(alarm, &attach); - if (attach != nullptr) + const auto auid = static_cast(l->data); + auto a = e_cal_component_get_alarm(component, auid); + if (a != nullptr) { - if (icalattach_get_is_url (attach)) - { - const char* url = icalattach_get_url(attach); - if (url != nullptr) - { - if ((action == E_CAL_COMPONENT_ALARM_DISPLAY) && appointment.url.empty()) - { - appointment.url = url; - } - else if ((action == E_CAL_COMPONENT_ALARM_AUDIO) && appointment.audio_url.empty()) - { - appointment.audio_url = url; - } - } - } - - icalattach_unref(attach); + if (tmp.text.empty()) + tmp.text = get_alarm_text(a); + if (tmp.audio_url.empty()) + tmp.audio_url = get_alarm_sound_url(a); + e_cal_component_alarm_free(a); } } + cal_obj_uid_list_free(auids); - e_cal_component_alarm_free(alarm); + alarms[tmp.time] = tmp; } - cal_obj_uid_list_free(alarm_uids); - g_debug("adding appointment '%s' '%s'", appointment.summary.c_str(), appointment.url.c_str()); + appointment.alarms.reserve(alarms.size()); + for (const auto& it : alarms) + appointment.alarms.push_back(it.second); + subtask->task->appointments.push_back(appointment); } } diff --git a/src/main.cpp b/src/main.cpp index 9aa502c..38e5caa 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -138,11 +138,13 @@ main(int /*argc*/, char** /*argv*/) auto notification_engine = std::make_shared("indicator-datetime-service"); std::unique_ptr snap (new Snap(notification_engine, state->settings)); auto alarm_queue = create_simple_alarm_queue(state->clock, snooze_planner, engine, timezone_); - auto on_snooze = [snooze_planner](const Appointment& a) {snooze_planner->add(a);}; - auto on_ok = [](const Appointment&){}; - auto on_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& a) { - (*snap)(a, on_snooze, on_ok); - engine->disable_ubuntu_alarm(a); + auto on_snooze = [snooze_planner](const Appointment& appointment, const Alarm&) {snooze_planner->add(appointment);}; + auto on_ok = [](const Appointment&, const Alarm&){}; + auto on_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& appointment) { +#warning placeholder; next step is to have AlarmQueue pass an appointment and alarm + Alarm alarm; + (*snap)(appointment, alarm, on_snooze, on_ok); + engine->disable_ubuntu_alarm(appointment); }; alarm_queue->alarm_reached().connect(on_alarm_reached); diff --git a/src/snap.cpp b/src/snap.cpp index e655d2d..ae0a62a 100644 --- a/src/snap.cpp +++ b/src/snap.cpp @@ -79,6 +79,7 @@ public: } void operator()(const Appointment& appointment, + const Alarm& alarm, appointment_func snooze, appointment_func ok) { @@ -96,7 +97,7 @@ public: if (appointment.is_ubuntu_alarm() || !silent_mode()) { // create the sound. const auto role = appointment.is_ubuntu_alarm() ? "alarm" : "alert"; - const auto uri = get_alarm_uri(appointment, m_settings); + const auto uri = get_alarm_uri(alarm, m_settings); const auto volume = m_settings->alarm_volume.get(); const bool loop = interactive; sound = std::make_shared(role, uri, volume, loop); @@ -140,12 +141,12 @@ public: // add 'sound', 'haptic', and 'awake' objects to the capture so // they stay alive until the closed callback is called; i.e., // for the lifespan of the notficiation - b.set_closed_callback([appointment, snooze, ok, sound, awake, haptic] + b.set_closed_callback([appointment, alarm, snooze, ok, sound, awake, haptic] (const std::string& action){ if (action == "snooze") - snooze(appointment); + snooze(appointment, alarm); else - ok(appointment); + ok(appointment, alarm); }); const auto key = m_engine->show(b); @@ -180,12 +181,12 @@ private: && (accounts_service_sound_get_silent_mode(m_accounts_service_sound_proxy)); } - std::string get_alarm_uri(const Appointment& appointment, + std::string get_alarm_uri(const Alarm& alarm, const std::shared_ptr& settings) const { const char* FALLBACK {"/usr/share/sounds/ubuntu/ringtones/Suru arpeggio.ogg"}; - const std::string candidates[] = { appointment.audio_url, + const std::string candidates[] = { alarm.audio_url, settings->alarm_sound.get(), FALLBACK }; @@ -236,10 +237,11 @@ Snap::~Snap() void Snap::operator()(const Appointment& appointment, + const Alarm& alarm, appointment_func show, appointment_func ok) { - (*impl)(appointment, show, ok); + (*impl)(appointment, alarm, show, ok); } /*** -- cgit v1.2.3 From 8c7daeeb87abd0be1b96169da18baf018c4859c9 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Fri, 3 Apr 2015 13:11:39 -0500 Subject: add the new Alarm class as an argument to the alarm queue class --- src/alarm-queue-simple.cpp | 226 ++++++++++++++++++++++++++------------------- src/date-time.cpp | 10 ++ src/main.cpp | 8 +- src/planner-snooze.cpp | 16 ++-- 4 files changed, 157 insertions(+), 103 deletions(-) (limited to 'src') diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp index f45e61a..db0fd21 100644 --- a/src/alarm-queue-simple.cpp +++ b/src/alarm-queue-simple.cpp @@ -20,134 +20,174 @@ #include #include +#include namespace unity { namespace indicator { namespace datetime { /*** -**** Public API +**** ***/ -SimpleAlarmQueue::SimpleAlarmQueue(const std::shared_ptr& clock, - const std::shared_ptr& planner, - const std::shared_ptr& timer): - m_clock(clock), - m_planner(planner), - m_timer(timer), - m_datetime(clock->localtime()) +class SimpleAlarmQueue::Impl { - m_planner->appointments().changed().connect([this](const std::vector&){ - g_debug("AlarmQueue %p calling requeue() due to appointments changed", this); - requeue(); - }); - - m_clock->minute_changed.connect([=]{ - const auto now = m_clock->localtime(); - constexpr auto skew_threshold_usec = int64_t{90} * G_USEC_PER_SEC; - const bool clock_jumped = std::abs(now - m_datetime) > skew_threshold_usec; - m_datetime = now; - if (clock_jumped) { - g_debug("AlarmQueue %p calling requeue() due to clock skew", this); +public: + + Impl(const std::shared_ptr& clock, + const std::shared_ptr& planner, + const std::shared_ptr& timer): + m_clock{clock}, + m_planner{planner}, + m_timer{timer}, + m_datetime{clock->localtime()} + { + m_planner->appointments().changed().connect([this](const std::vector&){ + g_debug("AlarmQueue %p calling requeue() due to appointments changed", this); requeue(); - } - }); + }); + + m_clock->minute_changed.connect([=]{ + const auto now = m_clock->localtime(); + constexpr auto skew_threshold_usec = int64_t{90} * G_USEC_PER_SEC; + const bool clock_jumped = std::abs(now - m_datetime) > skew_threshold_usec; + m_datetime = now; + if (clock_jumped) { + g_debug("AlarmQueue %p calling requeue() due to clock skew", this); + requeue(); + } + }); + + m_timer->timeout().connect([this](){ + g_debug("AlarmQueue %p calling requeue() due to timeout", this); + requeue(); + }); - m_timer->timeout().connect([this](){ - g_debug("AlarmQueue %p calling requeue() due to timeout", this); requeue(); - }); - - requeue(); -} + } -SimpleAlarmQueue::~SimpleAlarmQueue() -{ -} + ~Impl() + { + } -core::Signal& SimpleAlarmQueue::alarm_reached() -{ - return m_alarm_reached; -} + core::Signal& alarm_reached() + { + return m_alarm_reached; + } -/*** -**** -***/ +private: -void SimpleAlarmQueue::requeue() -{ - // kick any current alarms - for (auto current : find_current_alarms()) + void requeue() { - const std::pair trig {current.uid, current.begin}; - m_triggered.insert(trig); - m_alarm_reached(current); + // kick any current alarms + for (const auto& appointment : m_planner->appointments().get()) + { + Alarm alarm; + if (appointment_get_current_alarm(appointment, alarm)) + { + m_triggered.insert(std::make_pair(appointment.uid, alarm.time)); + m_alarm_reached(appointment, alarm); + } + } + + // idle until the next alarm + Alarm next; + if (find_next_alarm(next)) + { + g_debug ("setting timer to wake up for next appointment '%s' at %s", + next.text.c_str(), + next.time.format("%F %T").c_str()); + + m_timer->set_wakeup_time(next.time); + } } - // idle until the next alarm - Appointment next; - if (find_next_alarm(next)) + // find the next alarm that will kick now or in the future + bool find_next_alarm(Alarm& setme) const { - g_debug ("setting timer to wake up for next appointment '%s' at %s", - next.summary.c_str(), - next.begin.format("%F %T").c_str()); + bool found = false; + Alarm best; + const auto now = m_clock->localtime(); + const auto beginning_of_minute = now.start_of_minute(); - m_timer->set_wakeup_time(next.begin); - } -} + const auto appointments = m_planner->appointments().get(); + g_debug ("planner has %zu appointments in it", (size_t)appointments.size()); -// find the next alarm that will kick now or in the future -bool SimpleAlarmQueue::find_next_alarm(Appointment& setme) const -{ - bool found = false; - Appointment tmp; - const auto now = m_clock->localtime(); - const auto beginning_of_minute = now.start_of_minute(); + for(const auto& appointment : appointments) + { + for(const auto& alarm : appointment.alarms) + { + const std::pair trig{appointment.uid, alarm.time}; + if (m_triggered.count(trig)) + continue; - const auto appointments = m_planner->appointments().get(); - g_debug ("planner has %zu appointments in it", (size_t)appointments.size()); + if (alarm.time < beginning_of_minute) // has this one already passed? + continue; - for(const auto& walk : appointments) - { - const std::pair trig {walk.uid, walk.begin}; - if (m_triggered.count(trig)) - continue; + if (found && (best.time < alarm.time)) // do we already have a better match? + continue; - if (walk.begin < beginning_of_minute) // has this one already passed? - continue; + best = alarm; + found = true; + } + } - if (found && (tmp.begin < walk.begin)) // do we already have a better match? - continue; + if (found) + setme = best; - tmp = walk; - found = true; + return found; } - if (found) - setme = tmp; - return found; -} + bool appointment_get_current_alarm(const Appointment& appointment, Alarm& setme) const + { + const auto now = m_clock->localtime(); -// find the alarm(s) that should kick right now -std::vector SimpleAlarmQueue::find_current_alarms() const -{ - std::vector appointments; + for (const auto& alarm : appointment.alarms) + { + const auto trig = std::make_pair(appointment.uid, alarm.time); + if (m_triggered.count(trig)) // did we already use this one? + continue; + + if (DateTime::is_same_minute(now, alarm.time)) + { + setme = alarm; + return true; + } + } - const auto now = m_clock->localtime(); + return false; + } - for(const auto& walk : m_planner->appointments().get()) - { - const std::pair trig {walk.uid, walk.begin}; - if (m_triggered.count(trig)) // did we already use this one? - continue; - if (!DateTime::is_same_minute(now, walk.begin)) - continue; - appointments.push_back(walk); - } + std::set> m_triggered; + const std::shared_ptr m_clock; + const std::shared_ptr m_planner; + const std::shared_ptr m_timer; + core::Signal m_alarm_reached; + DateTime m_datetime; +}; + +/*** +**** Public API +***/ + - return appointments; +SimpleAlarmQueue::SimpleAlarmQueue(const std::shared_ptr& clock, + const std::shared_ptr& planner, + const std::shared_ptr& timer): + impl{new Impl{clock, planner, timer}} +{ +} + +SimpleAlarmQueue::~SimpleAlarmQueue() +{ +} + +core::Signal& +SimpleAlarmQueue::alarm_reached() +{ + return impl->alarm_reached(); } /*** diff --git a/src/date-time.cpp b/src/date-time.cpp index 689688c..ecfc971 100644 --- a/src/date-time.cpp +++ b/src/date-time.cpp @@ -55,6 +55,16 @@ DateTime& DateTime::operator=(const DateTime& that) return *this; } +DateTime& DateTime::operator+=(const std::chrono::minutes& minutes) +{ + return (*this = add_full(0, 0, 0, 0, minutes.count(), 0)); +} + +DateTime& DateTime::operator+=(const std::chrono::seconds& seconds) +{ + return (*this = add_full(0, 0, 0, 0, 0, seconds.count())); +} + DateTime::DateTime(time_t t) { auto gtz = g_time_zone_new_local(); diff --git a/src/main.cpp b/src/main.cpp index 38e5caa..907d49f 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -138,11 +138,11 @@ main(int /*argc*/, char** /*argv*/) auto notification_engine = std::make_shared("indicator-datetime-service"); std::unique_ptr snap (new Snap(notification_engine, state->settings)); auto alarm_queue = create_simple_alarm_queue(state->clock, snooze_planner, engine, timezone_); - auto on_snooze = [snooze_planner](const Appointment& appointment, const Alarm&) {snooze_planner->add(appointment);}; + 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_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& appointment) { -#warning placeholder; next step is to have AlarmQueue pass an appointment and alarm - Alarm alarm; + 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); }; diff --git a/src/planner-snooze.cpp b/src/planner-snooze.cpp index 29d5f06..e4062d2 100644 --- a/src/planner-snooze.cpp +++ b/src/planner-snooze.cpp @@ -51,14 +51,18 @@ public: return m_appointments; } - void add(const Appointment& appt_in) + void add(const Appointment& appt_in, const Alarm& alarm) { + // make a copy of the appointment with only this alarm Appointment appt = appt_in; + appt.alarms.clear(); + appt.alarms.push_back(alarm); // reschedule the alarm to go off N minutes from now - const auto alarm_duration_secs = appt.end - appt.begin; - appt.begin = m_clock->localtime().add_full(0,0,0,0,m_settings->snooze_duration.get(),0); - appt.end = appt.begin.add_full(0,0,0,0,0,alarm_duration_secs); + const auto offset = std::chrono::minutes(m_settings->snooze_duration.get()); + appt.begin += offset; + appt.end += offset; + appt.alarms[0].time += offset; // give it a new ID gchar* uid = e_uid_new(); @@ -95,9 +99,9 @@ SnoozePlanner::~SnoozePlanner() } void -SnoozePlanner::add(const Appointment& appointment) +SnoozePlanner::add(const Appointment& appointment, const Alarm& alarm) { - impl->add(appointment); + impl->add(appointment, alarm); } core::Property>& -- cgit v1.2.3 From e1aba742725c76257bd6845c93d3ac9a14d32089 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Fri, 3 Apr 2015 13:57:46 -0500 Subject: in EdsEngine, use empty initializer lists in the new valarm code --- src/engine-eds.cpp | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) (limited to 'src') diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 820d9d4..ecbee59 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -444,8 +444,7 @@ private: e_cal_component_alarm_get_action(alarm, &action); if (action == E_CAL_COMPONENT_ALARM_DISPLAY) { - ECalComponentText text; - text.value = nullptr; + ECalComponentText text {}; e_cal_component_alarm_get_description(alarm, &text); if (text.value) ret = text.value; @@ -527,8 +526,7 @@ private: ECalComponentAlarmAction omit[] = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 Appointment appointment; - ECalComponentText text; - text.value = nullptr; + ECalComponentText text {}; e_cal_component_get_summary(component, &text); if (text.value) appointment.summary = text.value; @@ -579,8 +577,8 @@ private: e_cal_component_alarms_free(e_alarms); } - // hm, no trigger. if this came from ubuntu-clock-app, - // manually add a single trigger for the todo event's time + // hm, no alarms? if this came from ubuntu-clock-app, + // manually add a single alarm for the todo event's time else if (appointment.is_ubuntu_alarm()) { Alarm tmp; @@ -684,10 +682,10 @@ private: std::set m_sources; std::map m_clients; std::map m_views; - GCancellable* m_cancellable = nullptr; - ESourceRegistry* m_source_registry = nullptr; - guint m_rebuild_tag = 0; - time_t m_rebuild_deadline = 0; + GCancellable* m_cancellable {}; + ESourceRegistry* m_source_registry {}; + guint m_rebuild_tag {}; + time_t m_rebuild_deadline {}; }; /*** -- cgit v1.2.3 From 62d68e6453c0ad69ff4d71099441a8151e9a9bea Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Sun, 5 Apr 2015 17:27:52 -0500 Subject: fix misuse of ECalComponentAlarmInstance's fields. --- src/appointment.cpp | 3 +-- src/engine-eds.cpp | 4 +--- 2 files changed, 2 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/appointment.cpp b/src/appointment.cpp index 236c5f4..1edd93c 100644 --- a/src/appointment.cpp +++ b/src/appointment.cpp @@ -31,8 +31,7 @@ bool Alarm::operator==(const Alarm& that) const { return (text==that.text) && (audio_url==that.audio_url) - && (this->time==that.time) - && (duration==that.duration); + && (this->time==that.time); } bool Appointment::operator==(const Appointment& that) const diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index ecbee59..856f190 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -559,7 +559,7 @@ private: if (a != nullptr) { - const DateTime alarm_begin{ai->occur_start}; + const DateTime alarm_begin{ai->trigger}; auto& alarm = alarms[alarm_begin]; if (alarm.text.empty()) @@ -568,8 +568,6 @@ private: alarm.audio_url = get_alarm_sound_url(a); if (!alarm.time.is_set()) alarm.time = alarm_begin; - if (alarm.duration == std::chrono::seconds::zero()) - alarm.duration = std::chrono::seconds(ai->occur_end - ai->occur_start); e_cal_component_alarm_free(a); } -- cgit v1.2.3 From 32de6c5e866527c03e015f2c691837ea7800290e Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Sun, 5 Apr 2015 18:26:37 -0500 Subject: make DateTime::is_same_day() faster --- src/date-time.cpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/date-time.cpp b/src/date-time.cpp index ecfc971..54601d0 100644 --- a/src/date-time.cpp +++ b/src/date-time.cpp @@ -254,10 +254,12 @@ bool DateTime::is_same_day(const DateTime& a, const DateTime& b) if (!a.m_dt || !b.m_dt) return false; - const auto adt = a.get(); - const auto bdt = b.get(); - return (g_date_time_get_year(adt) == g_date_time_get_year(bdt)) - && (g_date_time_get_day_of_year(adt) == g_date_time_get_day_of_year(bdt)); + int ay, am, ad; + int by, bm, bd; + g_date_time_get_ymd(a.get(), &ay, &am, &ad); + g_date_time_get_ymd(b.get(), &by, &bm, &bd); + + return (ay==by) && (am==bm) && (ad==bd); } bool DateTime::is_same_minute(const DateTime& a, const DateTime& b) -- cgit v1.2.3 From 242bab5395d808b0c25b2df8971c11a5f8932001 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Sun, 5 Apr 2015 18:27:08 -0500 Subject: in SimpleAlarmQueue, use references instead of copies when copies aren't necessary --- src/alarm-queue-simple.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp index db0fd21..ae7722c 100644 --- a/src/alarm-queue-simple.cpp +++ b/src/alarm-queue-simple.cpp @@ -110,14 +110,14 @@ private: const auto now = m_clock->localtime(); const auto beginning_of_minute = now.start_of_minute(); - const auto appointments = m_planner->appointments().get(); + const auto& appointments = m_planner->appointments().get(); g_debug ("planner has %zu appointments in it", (size_t)appointments.size()); for(const auto& appointment : appointments) { for(const auto& alarm : appointment.alarms) { - const std::pair trig{appointment.uid, alarm.time}; + const std::pair trig{appointment.uid, alarm.time}; if (m_triggered.count(trig)) continue; @@ -145,7 +145,7 @@ private: for (const auto& alarm : appointment.alarms) { - const auto trig = std::make_pair(appointment.uid, alarm.time); + const std::pair trig{appointment.uid, alarm.time}; if (m_triggered.count(trig)) // did we already use this one? continue; -- cgit v1.2.3 From 453a09477ec1eb238d214f61f695a09a0d84949d Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 09:27:01 -0500 Subject: in new code, use std::array rather than C style arrays --- src/engine-eds.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 856f190..2b62fd1 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -25,6 +25,7 @@ #include #include // std::sort() +#include #include // time() #include #include @@ -523,7 +524,7 @@ private: (status != ICAL_STATUS_COMPLETED) && (status != ICAL_STATUS_CANCELLED)) { - ECalComponentAlarmAction omit[] = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 + std::array omit = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 Appointment appointment; ECalComponentText text {}; @@ -543,7 +544,7 @@ private: auto e_alarms = e_cal_util_generate_alarms_for_comp(component, subtask->begin, subtask->end, - omit, + omit.data(), e_cal_client_resolve_tzid_cb, subtask->client, subtask->default_timezone); -- cgit v1.2.3 From 4438c3a50d4c10d7516d736cb31ded01c57c791e Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 13:16:24 -0500 Subject: in DateTime class, make it harder to accidentally mix local and nonlocal timezones by replacing DateTime::DateTime(time_t) with two methods, DateTime::Local(time_t) and DateTime(GTimeZone*, time_t) --- src/date-time.cpp | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/date-time.cpp b/src/date-time.cpp index 54601d0..4930bf6 100644 --- a/src/date-time.cpp +++ b/src/date-time.cpp @@ -65,13 +65,13 @@ DateTime& DateTime::operator+=(const std::chrono::seconds& seconds) return (*this = add_full(0, 0, 0, 0, 0, seconds.count())); } -DateTime::DateTime(time_t t) +DateTime::DateTime(GTimeZone* gtz, time_t t) { - auto gtz = g_time_zone_new_local(); - auto gdt = g_date_time_new_from_unix_local(t); + auto utc = g_date_time_new_from_unix_utc(t); + auto gdt = g_date_time_to_timezone (utc, gtz); reset(gtz, gdt); - g_time_zone_unref(gtz); g_date_time_unref(gdt); + g_date_time_unref(utc); } DateTime DateTime::NowLocal() @@ -84,6 +84,16 @@ DateTime DateTime::NowLocal() return dt; } +DateTime DateTime::Local(time_t t) +{ + auto gtz = g_time_zone_new_local(); + auto gdt = g_date_time_new_from_unix_local(t); + DateTime dt(gtz, gdt); + g_time_zone_unref(gtz); + g_date_time_unref(gdt); + return dt; +} + DateTime DateTime::Local(int year, int month, int day, int hour, int minute, double seconds) { auto gtz = g_time_zone_new_local(); -- cgit v1.2.3 From 7e9b4645721cc76322198df3b55f4cdedc55c200 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 13:17:39 -0500 Subject: in new EDS code, use timezones consistently --- src/engine-eds.cpp | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 2b62fd1..073b39d 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -497,11 +497,16 @@ private: auto status = ICAL_STATUS_NONE; e_cal_component_get_status(component, &status); - const auto begin_dt = DateTime(begin); - const auto end_dt = DateTime(end); + // get the timezone we want to use for generated Appointments/Alarms + const char * location = icaltimezone_get_location(subtask->default_timezone); + auto gtz = g_time_zone_new(location); + g_debug("timezone abbreviation is %s", g_time_zone_get_abbreviation (gtz, 0)); + + const DateTime begin_dt { gtz, begin }; + const DateTime end_dt { gtz, end }; g_debug ("got appointment from %s to %s, uid %s status %d", - begin_dt.format("%F %T").c_str(), - end_dt.format("%F %T").c_str(), + begin_dt.format("%F %T %z").c_str(), + end_dt.format("%F %T %z").c_str(), uid, (int)status); @@ -560,7 +565,7 @@ private: if (a != nullptr) { - const DateTime alarm_begin{ai->trigger}; + const DateTime alarm_begin{gtz, ai->trigger}; auto& alarm = alarms[alarm_begin]; if (alarm.text.empty()) @@ -608,6 +613,8 @@ private: subtask->task->appointments.push_back(appointment); } + + g_time_zone_unref(gtz); } return G_SOURCE_CONTINUE; -- cgit v1.2.3 From 9977f16b1f6e76fc3ac79383a1259340497af4a2 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 13:18:44 -0500 Subject: in Actions, sync DateTime API use by calling DateTime::Local(time_t) instead of DateTime::DateTime(time_t) --- src/actions.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/actions.cpp b/src/actions.cpp index 839c9cd..930e100 100644 --- a/src/actions.cpp +++ b/src/actions.cpp @@ -43,7 +43,7 @@ DateTime datetime_from_timet_variant(GVariant* v) t = g_variant_get_int64(v); if (t != 0) - return DateTime(t); + return DateTime::Local(t); else return DateTime::NowLocal(); } @@ -143,7 +143,7 @@ void on_calendar_activated(GSimpleAction * /*action*/, g_return_if_fail(t != 0); - auto dt = DateTime(t).start_of_day(); + auto dt = DateTime::Local(t).start_of_day(); static_cast(gself)->set_calendar_date(dt); } -- cgit v1.2.3 From 006858f8955ebeda75ce6cca152bbf42af7da3da Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 13:29:07 -0500 Subject: in SimpleAlarmQueue, reduce a lambda capture to only the fields it needs --- src/alarm-queue-simple.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp index ae7722c..d04c0fc 100644 --- a/src/alarm-queue-simple.cpp +++ b/src/alarm-queue-simple.cpp @@ -47,7 +47,7 @@ public: requeue(); }); - m_clock->minute_changed.connect([=]{ + m_clock->minute_changed.connect([this]{ const auto now = m_clock->localtime(); constexpr auto skew_threshold_usec = int64_t{90} * G_USEC_PER_SEC; const bool clock_jumped = std::abs(now - m_datetime) > skew_threshold_usec; -- cgit v1.2.3 From 81f4d9916f4915365e7e271354771b71e0ef2c38 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 14:17:26 -0500 Subject: in SimpleAlarmQueue, make the signature for find_next_alarm() and appointment_get_current_alarm() suck less. --- src/alarm-queue-simple.cpp | 50 +++++++++++++++++++--------------------------- 1 file changed, 21 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp index d04c0fc..19e5208 100644 --- a/src/alarm-queue-simple.cpp +++ b/src/alarm-queue-simple.cpp @@ -79,38 +79,37 @@ private: void requeue() { + const auto appointments = m_planner->appointments().get(); + const Alarm* alarm; + // kick any current alarms - for (const auto& appointment : m_planner->appointments().get()) + for (const auto& appointment : appointments) { - Alarm alarm; - if (appointment_get_current_alarm(appointment, alarm)) + if ((alarm = appointment_get_current_alarm(appointment))) { - m_triggered.insert(std::make_pair(appointment.uid, alarm.time)); - m_alarm_reached(appointment, alarm); + m_triggered.insert(std::make_pair(appointment.uid, alarm->time)); + m_alarm_reached(appointment, *alarm); } } // idle until the next alarm - Alarm next; - if (find_next_alarm(next)) + if ((alarm = find_next_alarm(appointments))) { g_debug ("setting timer to wake up for next appointment '%s' at %s", - next.text.c_str(), - next.time.format("%F %T").c_str()); + alarm->text.c_str(), + alarm->time.format("%F %T").c_str()); - m_timer->set_wakeup_time(next.time); + m_timer->set_wakeup_time(alarm->time); } } - // find the next alarm that will kick now or in the future - bool find_next_alarm(Alarm& setme) const + // return the next Alarm (if any) that will kick now or in the future + const Alarm* find_next_alarm(const std::vector& appointments) const { - bool found = false; - Alarm best; + const Alarm* best {}; const auto now = m_clock->localtime(); const auto beginning_of_minute = now.start_of_minute(); - const auto& appointments = m_planner->appointments().get(); g_debug ("planner has %zu appointments in it", (size_t)appointments.size()); for(const auto& appointment : appointments) @@ -124,22 +123,18 @@ private: if (alarm.time < beginning_of_minute) // has this one already passed? continue; - if (found && (best.time < alarm.time)) // do we already have a better match? + if (best && (best->time < alarm.time)) // do we already have a better match? continue; - best = alarm; - found = true; + best = &alarm; } } - if (found) - setme = best; - - return found; + return best; } - - bool appointment_get_current_alarm(const Appointment& appointment, Alarm& setme) const + // return the Appointment's current Alarm (if any) + const Alarm* appointment_get_current_alarm(const Appointment& appointment) const { const auto now = m_clock->localtime(); @@ -150,13 +145,10 @@ private: continue; if (DateTime::is_same_minute(now, alarm.time)) - { - setme = alarm; - return true; - } + return &alarm; } - return false; + return nullptr; } -- cgit v1.2.3 From 392788b1db2d60cd73cac12e58fbc4e6ce304d9e Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 14:26:24 -0500 Subject: in SimpleAlarmQueue, add a new method 'bool already_triggered() const' to reduce code overlapl between find_next_alarm() and appointment_get_current_alarm() --- src/alarm-queue-simple.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp index 19e5208..921e8d2 100644 --- a/src/alarm-queue-simple.cpp +++ b/src/alarm-queue-simple.cpp @@ -103,6 +103,12 @@ private: } } + bool already_triggered (const Appointment& appt, const Alarm& alarm) const + { + const std::pair key{appt.uid, alarm.time}; + return m_triggered.count(key) != 0; + } + // return the next Alarm (if any) that will kick now or in the future const Alarm* find_next_alarm(const std::vector& appointments) const { @@ -116,8 +122,7 @@ private: { for(const auto& alarm : appointment.alarms) { - const std::pair trig{appointment.uid, alarm.time}; - if (m_triggered.count(trig)) + if (already_triggered(appointment, alarm)) continue; if (alarm.time < beginning_of_minute) // has this one already passed? @@ -139,14 +144,8 @@ private: const auto now = m_clock->localtime(); for (const auto& alarm : appointment.alarms) - { - const std::pair trig{appointment.uid, alarm.time}; - if (m_triggered.count(trig)) // did we already use this one? - continue; - - if (DateTime::is_same_minute(now, alarm.time)) + if (!already_triggered(appointment, alarm) && DateTime::is_same_minute(now, alarm.time)) return &alarm; - } return nullptr; } -- cgit v1.2.3 From 7feb72952529269b9d6e8be2e04e992acb8812c7 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 14:35:29 -0500 Subject: in EngineEds, make the ECalComponentAlarmAction 'omit' array a constexpr. --- src/engine-eds.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 073b39d..4435bdf 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -529,7 +529,7 @@ private: (status != ICAL_STATUS_COMPLETED) && (status != ICAL_STATUS_CANCELLED)) { - std::array omit = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 + constexpr std::array omit = { (ECalComponentAlarmAction)-1 }; // list of action types to omit, terminated with -1 Appointment appointment; ECalComponentText text {}; @@ -549,7 +549,7 @@ private: auto e_alarms = e_cal_util_generate_alarms_for_comp(component, subtask->begin, subtask->end, - omit.data(), + const_cast(omit.data()), e_cal_client_resolve_tzid_cb, subtask->client, subtask->default_timezone); -- cgit v1.2.3 From aa3ee9ce63f3fb92b548593d03dd427f59c33ce5 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 6 Apr 2015 14:58:34 -0500 Subject: in the EDS engine, give a better explanation in the comments how we handle alarms with no triggers, and why --- src/engine-eds.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/engine-eds.cpp b/src/engine-eds.cpp index 4435bdf..474bac5 100644 --- a/src/engine-eds.cpp +++ b/src/engine-eds.cpp @@ -581,8 +581,10 @@ private: e_cal_component_alarms_free(e_alarms); } - // hm, no alarms? if this came from ubuntu-clock-app, - // manually add a single alarm for the todo event's time + // Hm, no alarm triggers? + // That's a bug in alarms created by some versions of ubuntu-ui-toolkit. + // If that's what's happening here, let's handle those alarms anyway + // by effectively injecting a TRIGGER;VALUE=DURATION;RELATED=START:PT0S else if (appointment.is_ubuntu_alarm()) { Alarm tmp; -- cgit v1.2.3