Merge lp:~charlesk/indicator-datetime/lp-1332095-refresh-floating-alarms-when-timezone-changes into lp:indicator-datetime/13.10

[Charles Kerr]

Adjust our floating alarms when the local timezone changes.

== Description of the Change

When our timezone changes, re-query EDS for alarms. This will keep the 'floating' (i.e., kick at 6:30 am, regardless of what timezone you're in) alarms in sync with the current timezone.

== Checklist

> Are there any related MPs required for this MP to build/function as expected? Please list.

No

> Is your branch in sync with latest trunk? (e.g. bzr pull lp:trunk -> no changes)

Yes

> Did the code build without warnings?

Yes

> Did the tests run successfully?

Yes

> Did you perform an exploratory manual test run of your code change and any related functionality?

Yes

> If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?

N/A

> What device (or emulator) has your component test plan been executed successfully on?

mako + RTM r41

> What manual tests are relevant for this MP?

indicator-datetime/alarm-timezone (added in this MP)

> Did you include a link to the MR Review Checklist Template to make your reviewer's life easier?

https://wiki.ubuntu.com/Process/Merges/Checklists/indicator-datetime

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:381
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/277/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-utopic-amd64-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-datetime-utopic-armhf-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/indicator-datetime-utopic-armhf-ci/51/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/277/rebuild

review: Approve (continuous-integration)

[Ted Gould (ted)]

Makes sense to me.

review: Approve

=== modified file 'include/datetime/clock.h'
--- include/datetime/clock.h	2014-09-13 18:12:04 +0000
+++ include/datetime/clock.h	2014-09-16 21:33:33 +0000
@@ -68,7 +68,7 @@
 ****
 ***/
 
-class Timezones;
+class Timezone;
 
 /**
  * \brief A live #Clock that provides the actual system time.
@@ -76,7 +76,7 @@
 class LiveClock: public Clock
 {
 public:
-    LiveClock (const std::shared_ptr<const Timezones>& zones);
+    LiveClock (const std::shared_ptr<const Timezone>& zones);
     virtual ~LiveClock();
     virtual DateTime localtime() const;
 

=== modified file 'src/clock-live.cpp'
--- src/clock-live.cpp	2014-01-31 00:33:14 +0000
+++ src/clock-live.cpp	2014-09-16 21:33:33 +0000
@@ -18,7 +18,7 @@
  */
 
 #include <datetime/clock.h>
-#include <datetime/timezones.h>
+#include <datetime/timezone.h>
 
 namespace unity {
 namespace indicator {
@@ -59,14 +59,15 @@
 {
 public:
 
-    Impl(LiveClock& owner, const std::shared_ptr<const Timezones>& tzd):
+    Impl(LiveClock& owner, const std::shared_ptr<const Timezone>& timezone_):
         m_owner(owner),
-        m_timezones(tzd)
+        m_timezone(timezone_)
     {
-        if (m_timezones)
+        if (m_timezone)
         {
-            m_timezones->timezone.changed().connect([this](const std::string& z) {setTimezone(z);});
-            setTimezone(m_timezones->timezone.get());
+            auto setter = [this](const std::string& z){setTimezone(z);};
+            m_timezone->timezone.changed().connect(setter);
+            setter(m_timezone->timezone.get());
         }
 
         restart_minute_timer();
@@ -76,14 +77,14 @@
     {
         clearTimer(m_timer);
 
-        g_clear_pointer(&m_timezone, g_time_zone_unref);
+        g_clear_pointer(&m_gtimezone, g_time_zone_unref);
     }
 
     DateTime localtime() const
     {
-        g_assert(m_timezone != nullptr);
+        g_assert(m_gtimezone != nullptr);
 
-        auto gdt = g_date_time_new_now(m_timezone);
+        auto gdt = g_date_time_new_now(m_gtimezone);
         DateTime ret(gdt);
         g_date_time_unref(gdt);
         return ret;
@@ -93,8 +94,8 @@
 
     void setTimezone(const std::string& str)
     {
-        g_clear_pointer(&m_timezone, g_time_zone_unref);
-        m_timezone = g_time_zone_new(str.c_str());
+        g_clear_pointer(&m_gtimezone, g_time_zone_unref);
+        m_gtimezone = g_time_zone_new(str.c_str());
         m_owner.minute_changed();
     }
 
@@ -134,15 +135,15 @@
 protected:
 
     LiveClock& m_owner;
-    GTimeZone* m_timezone = nullptr;
-    std::shared_ptr<const Timezones> m_timezones;
+    GTimeZone* m_gtimezone = nullptr;
+    std::shared_ptr<const Timezone> m_timezone;
 
     DateTime m_prev_datetime;
     unsigned int m_timer = 0;
 };
 
-LiveClock::LiveClock(const std::shared_ptr<const Timezones>& tzd):
-    p(new Impl(*this, tzd))
+LiveClock::LiveClock(const std::shared_ptr<const Timezone>& timezone_):
+    p(new Impl(*this, timezone_))
 {
 }
 

=== modified file 'src/main.cpp'
--- src/main.cpp	2014-09-02 16:16:01 +0000
+++ src/main.cpp	2014-09-16 21:33:33 +0000
@@ -63,20 +63,20 @@
     }
 
     std::shared_ptr<State> create_state(const std::shared_ptr<Engine>& engine,
-                                        const std::shared_ptr<Timezone>& tz)
+                                        const std::shared_ptr<Timezone>& timezone_)
     {
         // create the live objects
         auto live_settings = std::make_shared<LiveSettings>();
         auto live_timezones = std::make_shared<LiveTimezones>(live_settings, TIMEZONE_FILE);
-        auto live_clock = std::make_shared<LiveClock>(live_timezones);
+        auto live_clock = std::make_shared<LiveClock>(timezone_);
 
         // create a full-month planner currently pointing to the current month
         const auto now = live_clock->localtime();
-        auto range_planner = std::make_shared<SimpleRangePlanner>(engine, tz);
+        auto range_planner = std::make_shared<SimpleRangePlanner>(engine, timezone_);
         auto calendar_month = std::make_shared<MonthPlanner>(range_planner, now);
 
         // create an upcoming-events planner currently pointing to the current date
-        range_planner = std::make_shared<SimpleRangePlanner>(engine, tz);
+        range_planner = std::make_shared<SimpleRangePlanner>(engine, timezone_);
         auto calendar_upcoming = std::make_shared<UpcomingPlanner>(range_planner, now);
 
         // create the state
@@ -127,8 +127,8 @@
     textdomain(GETTEXT_PACKAGE);
 
     auto engine = create_engine();
-    auto timezone = std::make_shared<FileTimezone>(TIMEZONE_FILE);
-    auto state = create_state(engine, timezone);
+    auto timezone_ = std::make_shared<FileTimezone>(TIMEZONE_FILE);
+    auto state = create_state(engine, timezone_);
     auto actions = std::make_shared<LiveActions>(state);
     MenuFactory factory(actions, state);
 
@@ -136,7 +136,7 @@
     auto snooze_planner = std::make_shared<SnoozePlanner>(state->settings, state->clock);
     auto notification_engine = std::make_shared<uin::Engine>("indicator-datetime-service");
     std::unique_ptr<Snap> snap (new Snap(notification_engine, state->settings));
-    auto alarm_queue = create_simple_alarm_queue(state->clock, snooze_planner, engine, timezone);
+    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 = [&snap, &on_snooze, &on_ok](const Appointment& a) {(*snap)(a, on_snooze, on_ok);};

=== modified file 'src/planner-range.cpp'
--- src/planner-range.cpp	2014-04-25 03:34:42 +0000
+++ src/planner-range.cpp	2014-09-16 21:33:33 +0000
@@ -28,7 +28,7 @@
 ***/
 
 SimpleRangePlanner::SimpleRangePlanner(const std::shared_ptr<Engine>& engine,
-                                   const std::shared_ptr<Timezone>& timezone):
+                                       const std::shared_ptr<Timezone>& timezone):
     m_engine(engine),
     m_timezone(timezone),
     m_range(std::pair<DateTime,DateTime>(DateTime::NowLocal(), DateTime::NowLocal()))
@@ -38,6 +38,11 @@
         rebuild_soon();
     });
 
+    m_timezone->timezone.changed().connect([this](const std::string& s){
+        g_debug("RangePlanner %p rebuilding soon because the timezone changed to '%s'", this, s.c_str());
+        rebuild_soon();
+    });
+
     range().changed().connect([this](const std::pair<DateTime,DateTime>&){
         g_debug("rebuilding because the date range changed");
         rebuild_soon();

=== modified file 'tests/manual'
--- tests/manual	2014-09-15 17:02:50 +0000
+++ tests/manual	2014-09-16 21:33:33 +0000
@@ -40,6 +40,15 @@
 		<dd>If the device supports haptic feedback, confirm the alarm vibrates.</dd>
 </dl>
 
+Test-case indicator-datetime/alarm-timezone
+<dl>
+	<dt>In ubuntu-system-settings, change your timezone to a zone you're not in</dt>
+	<dt>In ubuntu-clock-app, create and save an upcoming alarm</dt>
+		<dd>The indicator's menu should show the alarm to click at the specified time</dd>
+	<dt>In ubuntu-system-settings, change back to your correct timezone</dt>
+		<dd>The indicator's menu should still show the alarm to click at the specified time</dd>
+</dl>
+
 Test-case indicator-datetime/snooze
 <dl>
 	<dt>Create and save an upcoming alarm in ubuntu-clock-app</dt>

=== modified file 'tests/test-clock.cpp'
--- tests/test-clock.cpp	2014-09-15 19:49:20 +0000
+++ tests/test-clock.cpp	2014-09-16 21:33:33 +0000
@@ -19,11 +19,12 @@
 
 #include <datetime/clock.h>
 #include <datetime/clock-mock.h>
-#include <datetime/timezones.h>
+#include <datetime/timezone.h>
 
 #include <notifications/dbus-shared.h>
 
 #include "test-dbus-fixture.h"
+#include "timezone-mock.h"
 
 /***
 ****
@@ -40,9 +41,9 @@
 TEST_F(ClockFixture, MinuteChangedSignalShouldTriggerOncePerMinute)
 {
     // start up a live clock
-    std::shared_ptr<Timezones> zones(new Timezones);
-    zones->timezone.set("America/New_York");
-    LiveClock clock(zones);
+    auto timezone_ = std::make_shared<MockTimezone>();
+    timezone_->timezone.set("America/New_York");
+    LiveClock clock(timezone_);
     wait_msec(500); // wait for the bus to set up
 
     // count how many times clock.minute_changed() is emitted over the next minute
@@ -65,17 +66,17 @@
 
 TEST_F(ClockFixture, HelloFixture)
 {
-    std::shared_ptr<Timezones> zones(new Timezones);
-    zones->timezone.set("America/New_York");
-    LiveClock clock(zones);
+    auto timezone_ = std::make_shared<MockTimezone>();
+    timezone_->timezone.set("America/New_York");
+    LiveClock clock(timezone_);
 }
 
 
 TEST_F(ClockFixture, TimezoneChangeTriggersSkew)
 {
-    std::shared_ptr<Timezones> zones(new Timezones);
-    zones->timezone.set("America/New_York");
-    LiveClock clock(zones);
+    auto timezone_ = std::make_shared<MockTimezone>();
+    timezone_->timezone.set("America/New_York");
+    LiveClock clock(timezone_);
 
     auto tz_nyc = g_time_zone_new("America/New_York");
     auto now_nyc = g_date_time_new_now(tz_nyc);
@@ -90,9 +91,9 @@
                    g_main_loop_quit(loop);
                });
     g_idle_add([](gpointer gs){
-                   static_cast<Timezones*>(gs)->timezone.set("America/Los_Angeles");
+                   static_cast<Timezone*>(gs)->timezone.set("America/Los_Angeles");
                    return G_SOURCE_REMOVE;
-               }, zones.get());
+               }, timezone_.get());
     g_main_loop_run(loop);
 
     auto tz_la = g_time_zone_new("America/Los_Angeles");
@@ -130,9 +131,9 @@
  */
 TEST_F(ClockFixture, SleepTriggersSkew)
 {
-    std::shared_ptr<Timezones> zones(new Timezones);
-    zones->timezone.set("America/New_York");
-    LiveClock clock(zones);
+    auto timezone_ = std::make_shared<MockTimezone>();
+    timezone_->timezone.set("America/New_York");
+    LiveClock clock(timezone_);
     wait_msec(250); // wait for the bus to set up
 
     bool skewed = false;