Adjust our floating alarms when the local timezone changes.

 Fixes: 1332095
Approved by: Ted Gould, PS Jenkins bot

6 files changed, 56 insertions, 40 deletions

diff --git a/include/datetime/clock.h b/include/datetime/clock.h
index 0b2a543..64d275b 100644
--- a/include/datetime/clock.h
+++ b/include/datetime/clock.h
@@ -68,7 +68,7 @@ private:
 ****
 ***/
 
-class Timezones;
+class Timezone;
 
 /**
  * \brief A live #Clock that provides the actual system time.
@@ -76,7 +76,7 @@ class Timezones;
 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;
 
diff --git a/src/clock-live.cpp b/src/clock-live.cpp
index 21a18a3..68a8a8b 100644
--- a/src/clock-live.cpp
+++ b/src/clock-live.cpp
@@ -18,7 +18,7 @@
  */
 
 #include <datetime/clock.h>
-#include <datetime/timezones.h>
+#include <datetime/timezone.h>
 
 namespace unity {
 namespace indicator {
@@ -59,14 +59,15 @@ class LiveClock::Impl
 {
 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 @@ public:
     {
         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 @@ private:
 
     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 @@ private:
 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_))
 {
 }
 
diff --git a/src/main.cpp b/src/main.cpp
index 54517c9..aa8f829 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -63,20 +63,20 @@ namespace
     }
 
     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 @@ main(int /*argc*/, char** /*argv*/)
     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 @@ main(int /*argc*/, char** /*argv*/)
     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);};
diff --git a/src/planner-range.cpp b/src/planner-range.cpp
index 41b0f56..c223665 100644
--- a/src/planner-range.cpp
+++ b/src/planner-range.cpp
@@ -28,7 +28,7 @@ namespace datetime {
 ***/
 
 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 @@ SimpleRangePlanner::SimpleRangePlanner(const std::shared_ptr<Engine>& engine,
         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();
diff --git a/tests/manual b/tests/manual
index 2b16841..87ad674 100644
--- a/tests/manual
+++ b/tests/manual
@@ -40,6 +40,15 @@ Test-case indicator-datetime/new-alarm-wakeup
 		<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>
diff --git a/tests/test-clock.cpp b/tests/test-clock.cpp
index 62281fb..5601d35 100644
--- a/tests/test-clock.cpp
+++ b/tests/test-clock.cpp
@@ -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 @@ class ClockFixture: public TestDBusFixture
 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, MinuteChangedSignalShouldTriggerOncePerMinute)
 
 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 @@ TEST_F(ClockFixture, TimezoneChangeTriggersSkew)
                    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 @@ namespace
  */
 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;