Use powerd's hardware wakeup API instead of of using the u_hardware_alarm_*() API directly.

Approved by: Antti Kaijanmäki, PS Jenkins bot

7 files changed, 318 insertions, 219 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9b4987e..4d2fd95 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,12 +44,6 @@ pkg_check_modules (SERVICE_DEPS REQUIRED
                    properties-cpp>=0.0.1)
 include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
-CHECK_INCLUDE_FILE(ubuntu/hardware/alarm.h HAVE_UBUNTU_HW_ALARM_H)
-if (HAVE_UBUNTU_HW_ALARM_H)
-  set (SERVICE_DEPS_LIBRARIES -lubuntu_platform_hardware_api ${SERVICE_DEPS_LIBRARIES})
-  add_definitions(-DHAVE_UBUNTU_HW_ALARM_H)
-endif ()
-
 ##
 ##  custom targets
 ##
diff --git a/debian/control b/debian/control
index 9e7133e..4b5f893 100644
--- a/debian/control
+++ b/debian/control
@@ -22,8 +22,6 @@ Build-Depends: cmake,
                libedataserver1.2-dev (>= 3.5),
                liburl-dispatcher1-dev,
                libproperties-cpp-dev,
-               libubuntu-platform-hardware-api-headers [armhf i386 amd64],
-               libubuntu-platform-hardware-api-dev [armhf i386 amd64],
                libdbustest1-dev,
                locales,
 Standards-Version: 3.9.3
diff --git a/include/datetime/wakeup-timer-uha.h b/include/datetime/wakeup-timer-powerd.h
index 093548b..6adbbb8 100644
--- a/include/datetime/wakeup-timer-uha.h
+++ b/include/datetime/wakeup-timer-powerd.h
@@ -17,8 +17,8 @@
  *   Charles Kerr <charles.kerr@canonical.com>
  */
 
-#ifndef INDICATOR_DATETIME_WAKEUP_TIMER_UHA_H
-#define INDICATOR_DATETIME_WAKEUP_TIMER_UHA_H
+#ifndef INDICATOR_DATETIME_WAKEUP_TIMER_POWERD_H
+#define INDICATOR_DATETIME_WAKEUP_TIMER_POWERD_H
 
 #include <datetime/clock.h>
 #include <datetime/wakeup-timer.h>
@@ -34,21 +34,19 @@ namespace datetime {
 ***/
 
 /**
- * \brief a WakeupTimer implemented the UbuntuHardwareAlarm API
+ * \brief a WakeupTimer implemented with g_timeout_add() 
  */
-class UhaWakeupTimer: public WakeupTimer
+class PowerdWakeupTimer: public WakeupTimer
 {
 public:
-    UhaWakeupTimer(const std::shared_ptr<Clock>&);
-    ~UhaWakeupTimer();
-    void set_wakeup_time (const DateTime&);
+    PowerdWakeupTimer(const std::shared_ptr<Clock>&);
+    ~PowerdWakeupTimer();
+    void set_wakeup_time(const DateTime&);
     core::Signal<>& timeout();
 
-    static bool is_supported();
-
 private:
-    UhaWakeupTimer(const UhaWakeupTimer&) =delete;
-    UhaWakeupTimer& operator= (const UhaWakeupTimer&) =delete;
+    PowerdWakeupTimer(const PowerdWakeupTimer&) =delete;
+    PowerdWakeupTimer& operator=(const PowerdWakeupTimer&) =delete;
     class Impl;
     std::unique_ptr<Impl> p;
 };
@@ -61,4 +59,4 @@ private:
 } // namespace indicator
 } // namespace unity
 
-#endif // INDICATOR_DATETIME_WAKEUP_TIMER_UHA_H
+#endif // INDICATOR_DATETIME_WAKEUP_TIMER_MAINLOOP_H
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a466a48..e583334 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -35,10 +35,8 @@ set (SERVICE_CXX_SOURCES
      timezone-geoclue.cpp
      timezones-live.cpp
      utils.c
-     wakeup-timer-mainloop.cpp)
-if (HAVE_UBUNTU_HW_ALARM_H)
-  set (SERVICE_CXX_SOURCES ${SERVICE_CXX_SOURCES} wakeup-timer-uha.cpp)
-endif ()
+     wakeup-timer-mainloop.cpp
+     wakeup-timer-powerd.cpp)
 
 # generated sources
 include (GdbusCodegen)
diff --git a/src/main.cpp b/src/main.cpp
index eb90020..48d3d20 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -31,13 +31,9 @@
 #include <datetime/state.h>
 #include <datetime/timezone-file.h>
 #include <datetime/timezones-live.h>
-#include <datetime/wakeup-timer-mainloop.h>
+#include <datetime/wakeup-timer-powerd.h>
 #include <notifications/notifications.h>
 
-#ifdef HAVE_UBUNTU_HW_ALARM_H
-  #include <datetime/wakeup-timer-uha.h>
-#endif
-
 #include <glib/gi18n.h> // bindtextdomain()
 #include <gio/gio.h>
 
@@ -66,20 +62,6 @@ namespace
         return engine;
     }
 
-    std::shared_ptr<WakeupTimer> create_wakeup_timer(const std::shared_ptr<Clock>& clock)
-    {
-        std::shared_ptr<WakeupTimer> wakeup_timer;
-
-#ifdef HAVE_UBUNTU_HW_ALARM_H
-        if (UhaWakeupTimer::is_supported()) // prefer to use the platform API
-            wakeup_timer = std::make_shared<UhaWakeupTimer>(clock);
-        else
-#endif
-            wakeup_timer = std::make_shared<MainloopWakeupTimer>(clock);
-
-        return wakeup_timer;
-    }
-
     std::shared_ptr<State> create_state(const std::shared_ptr<Engine>& engine,
                                         const std::shared_ptr<Timezone>& tz)
     {
@@ -120,7 +102,7 @@ namespace
             upcoming_planner->date().set(now);
         });
 
-        auto wakeup_timer = create_wakeup_timer(clock);
+        auto wakeup_timer = std::make_shared<PowerdWakeupTimer>(clock);
         return std::make_shared<SimpleAlarmQueue>(clock, upcoming_planner, wakeup_timer);
     }
 }
diff --git a/src/wakeup-timer-powerd.cpp b/src/wakeup-timer-powerd.cpp
new file mode 100644
index 0000000..42d93e7
--- /dev/null
+++ b/src/wakeup-timer-powerd.cpp
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2014 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 <charles.kerr@canonical.com>
+ */
+
+#include <datetime/clock.h>
+#include <datetime/wakeup-timer-powerd.h>
+
+#include <notifications/dbus-shared.h> // BUS_POWERD_NAME
+
+#include <memory> // std::shared_ptr
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+/***
+****
+***/
+
+class PowerdWakeupTimer::Impl
+{
+public:
+
+    Impl(const std::shared_ptr<Clock>& clock):
+        m_clock(clock),
+        m_cancellable(g_cancellable_new())
+    {
+        g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_bus_ready, this);
+    }
+
+    ~Impl()
+    {
+        clear_current_cookie();
+
+        g_cancellable_cancel(m_cancellable);
+        g_clear_object(&m_cancellable);
+
+        if (m_sub_id)
+            g_dbus_connection_signal_unsubscribe(m_bus.get(), m_sub_id);
+
+        if (m_watch_tag)
+            g_bus_unwatch_name(m_watch_tag);
+    }
+
+    void set_wakeup_time(const DateTime& d)
+    {
+        m_wakeup_time = d;
+        update_cookie();
+    }
+
+    core::Signal<>& timeout() { return m_timeout; }
+
+private:
+
+    void emit_timeout() { return m_timeout(); }
+
+    static void on_bus_ready(GObject      * /*unused*/,
+                             GAsyncResult * res,
+                             gpointer       gself)
+    {
+        GError * error;
+        GDBusConnection * bus;
+
+        error = nullptr;
+        bus = g_bus_get_finish(res, &error);
+        if (bus == nullptr)
+        {
+            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                g_warning("%s Couldn't get system bus: %s", G_STRLOC, error->message);
+        }
+        else
+        {
+            static_cast<Impl*>(gself)->init_bus(bus);
+        }
+
+        g_clear_object(&bus);
+        g_clear_error(&error);
+    }
+
+    void init_bus(GDBusConnection* connection)
+    {
+        m_bus.reset(G_DBUS_CONNECTION(g_object_ref(G_OBJECT(connection))),
+                    [](GDBusConnection *c){g_object_unref(G_OBJECT(c));});
+
+        m_sub_id = g_dbus_connection_signal_subscribe(m_bus.get(),
+                                                      BUS_POWERD_NAME,
+                                                      BUS_POWERD_INTERFACE,
+                                                      "Wakeup",
+                                                      BUS_POWERD_PATH,
+                                                      nullptr,
+                                                      G_DBUS_SIGNAL_FLAGS_NONE,
+                                                      on_wakeup_signal,
+                                                      this, // userdata
+                                                      nullptr); // userdata free
+
+        m_watch_tag = g_bus_watch_name_on_connection(m_bus.get(),
+                                                     BUS_POWERD_NAME,
+                                                     G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                                     on_name_appeared_static,
+                                                     nullptr, // name-vanished,
+                                                     this, // userdata
+                                                     nullptr); // userdata free
+    }
+
+    static void
+    on_wakeup_signal(GDBusConnection * /*connection*/,
+                     const gchar     * sender_name,
+                     const gchar     * /*object_path*/,
+                     const gchar     * /*interface_name*/,
+                     const gchar     * /*signal_name*/,
+                     GVariant        * /*parameters*/,
+                     gpointer          gself)
+    {
+        g_debug("%s %s broadcast a hw wakeup signal", G_STRLOC, sender_name);
+        static_cast<Impl*>(gself)->emit_timeout();
+    }
+
+    static void
+    on_name_appeared_static(GDBusConnection * /*connection*/,
+                            const gchar     * name,
+                            const gchar     * name_owner,
+                            gpointer          gself)
+    {
+        g_debug("%s %s owns %s now; let's ask for a new cookie", G_STRLOC, name, name_owner);
+        static_cast<Impl*>(gself)->update_cookie();
+    }
+
+    /***
+    ****  requestWakeup
+    ***/
+
+    void update_cookie()
+    {
+        if (!m_bus)
+            return;
+
+        // if we've already got a cookie, clear it
+        clear_current_cookie();
+        g_warn_if_fail(m_cookie.empty());
+
+        // get a new cookie, if necessary
+        if (m_wakeup_time.is_set())
+        {
+            g_debug("%s calling %s::requestWakeup(%s)",
+                    G_STRLOC, BUS_POWERD_NAME,
+                    m_wakeup_time.format("%F %T").c_str());
+
+            auto args = g_variant_new("(st)",
+                                      GETTEXT_PACKAGE,
+                                      uint64_t(m_wakeup_time.to_unix()));
+
+            g_dbus_connection_call(m_bus.get(),
+                                   BUS_POWERD_NAME,
+                                   BUS_POWERD_PATH,
+                                   BUS_POWERD_INTERFACE,
+                                   "requestWakeup", // method_name
+                                   args,
+                                   G_VARIANT_TYPE("(s)"), // reply_type
+                                   G_DBUS_CALL_FLAGS_NONE,
+                                   -1, // use default timeout
+                                   m_cancellable,
+                                   on_request_wakeup_done,
+                                   this);
+        }
+    }
+
+    static void on_request_wakeup_done(GObject      * o,
+                                       GAsyncResult * res,
+                                       gpointer       gself)
+    {
+        GError * error;
+        GVariant * ret;
+
+        error = nullptr;
+        ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(o), res, &error);
+        if (ret == nullptr)
+        {
+            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                g_warning("%s Could not set hardware wakeup: %s", G_STRLOC, error->message);
+        }
+        else
+        {
+            const char* s = NULL;
+            g_variant_get(ret, "(&s)", &s);
+            g_debug("%s %s::requestWakeup() sent cookie %s",
+                    G_STRLOC, BUS_POWERD_NAME, s);
+
+            auto& cookie = static_cast<Impl*>(gself)->m_cookie;
+            if (s != nullptr)
+                cookie = s;
+            else
+                cookie.clear();
+        }
+
+        // cleanup
+        g_clear_pointer(&ret, g_variant_unref);
+        g_clear_error(&error);
+    }
+
+    /***
+    ****  clearWakeup
+    ***/
+
+    void clear_current_cookie()
+    {
+        if (!m_cookie.empty())
+        {
+            g_debug("%s calling %s::clearWakeup(%s)",
+                    G_STRLOC, BUS_POWERD_NAME, m_cookie.c_str());
+
+            g_dbus_connection_call(m_bus.get(),
+                                   BUS_POWERD_NAME,
+                                   BUS_POWERD_PATH,
+                                   BUS_POWERD_INTERFACE,
+                                   "clearWakeup", // method_name
+                                   g_variant_new("(s)", m_cookie.c_str()),
+                                   nullptr, // no response type
+                                   G_DBUS_CALL_FLAGS_NONE,
+                                   -1, // use default timeout
+                                   nullptr, // cancellable
+                                   on_clear_wakeup_done,
+                                   nullptr);
+            m_cookie.clear();
+        }
+    }
+
+    // this is only here to log errors
+    static void on_clear_wakeup_done(GObject      * o,
+                                     GAsyncResult * res,
+                                     gpointer       /*unused*/)
+    {
+        GError * error;
+        GVariant * ret;
+
+        error = nullptr;
+        ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(o), res, &error);
+        if (!ret && !g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+            g_warning("%s Couldn't clear hardware wakeup: %s", G_STRLOC, error->message);
+
+        // cleanup
+        g_clear_pointer(&ret, g_variant_unref);
+        g_clear_error(&error);
+    }
+
+    /***
+    ****
+    ***/
+
+    core::Signal<> m_timeout;
+    const std::shared_ptr<Clock>& m_clock;
+    DateTime m_wakeup_time;
+
+    std::shared_ptr<GDBusConnection> m_bus;
+    GCancellable * m_cancellable = nullptr;
+    std::string m_cookie;
+    guint m_watch_tag = 0;
+    guint m_sub_id = 0;
+};
+
+/***
+****
+***/
+
+PowerdWakeupTimer::PowerdWakeupTimer(const std::shared_ptr<Clock>& clock):
+    p(new Impl(clock))
+{
+}
+
+PowerdWakeupTimer::~PowerdWakeupTimer()
+{
+}
+
+void PowerdWakeupTimer::set_wakeup_time(const DateTime& d)
+{
+    p->set_wakeup_time(d);
+}
+
+core::Signal<>& PowerdWakeupTimer::timeout()
+{
+    return p->timeout();
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
diff --git a/src/wakeup-timer-uha.cpp b/src/wakeup-timer-uha.cpp
deleted file mode 100644
index 437eda2..0000000
--- a/src/wakeup-timer-uha.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright 2014 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 <charles.kerr@canonical.com>
- */
-
-#include <datetime/wakeup-timer-uha.h>
-
-#include <ubuntu/hardware/alarm.h>
-
-#include <glib.h>
-
-#include <unistd.h>
-
-#include <ctime> // struct timespec
-#include <mutex>
-#include <thread>
-
-namespace unity {
-namespace indicator {
-namespace datetime {
-
-/***
-****
-***/
-
-class UhaWakeupTimer::Impl
-{
-
-public:
-
-    Impl(const std::shared_ptr<Clock>& clock):
-        m_clock(clock),
-        m_hardware_alarm(u_hardware_alarm_create())
-    {
-        // fire up a worker thread that initially just sleeps
-        set_wakeup_time_to_the_distant_future();
-        m_thread = std::move(std::thread([&](){threadfunc();}));
-    }
-
-    ~Impl()
-    {
-        // tell the worker thread to wake up and exit
-        m_yielding = true;
-        set_wakeup_time(m_clock->localtime().add_full(0,0,0,0,0,0.1));
-
-        // wait for it to happen
-        if (m_thread.joinable())
-            m_thread.join();
-
-        g_idle_remove_by_data(this);
-
-        u_hardware_alarm_unref(m_hardware_alarm);
-    }
-
-    void set_wakeup_time(const DateTime& d)
-    {
-        g_debug("%s %s", G_STRLOC, G_STRFUNC);
-        std::lock_guard<std::recursive_mutex> lg(m_mutex);
-
-        const auto wakeup_time = d.to_unix();
-
-        // simple sanity check: don't try to wait for something that's already passed
-        const auto now = m_clock->localtime().to_unix();
-        g_return_if_fail (wakeup_time >= now);
-
-        struct timespec sleep_interval;
-        sleep_interval.tv_sec = wakeup_time;
-        sleep_interval.tv_nsec = 0;
-        g_debug("%s %s setting hardware wakeup time to %s (%zu seconds from now)",
-                G_STRLOC, G_STRFUNC,
-                d.format("%F %T").c_str(),
-                (size_t)(wakeup_time - now));
-        u_hardware_alarm_set_relative_to_with_behavior(m_hardware_alarm,
-                                                       U_HARDWARE_ALARM_TIME_REFERENCE_RTC,
-                                                       U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE,
-                                                       &sleep_interval);
-    }
-
-    core::Signal<>& timeout() { return m_timeout; }
-
-private:
-
-    void set_wakeup_time_to_the_distant_future()
-    {
-        const auto tomorrow = m_clock->localtime().add_full(0,0,1,0,0,0);
-        set_wakeup_time(tomorrow);
-    }
-
-    static gboolean kick_idle (gpointer gself)
-    {
-        static_cast<Impl*>(gself)->m_timeout();
-
-        return G_SOURCE_REMOVE;
-    }
-
-    void threadfunc()
-    {
-        while (!m_yielding)
-        {
-            // wait for the next hw alarm
-            UHardwareAlarmWaitResult wait_result;
-            g_debug ("calling wait_for_next_alarm");
-            auto rc = u_hardware_alarm_wait_for_next_alarm(m_hardware_alarm, &wait_result);
-            g_return_if_fail (rc == U_STATUS_SUCCESS);
-
-            // set a long wakeup interval for the next iteration of the loop.
-            // if there's another Appointment queued up by the Planner,
-            // our timeout() listener will call set_wakeup_time() to set the
-            // real wakeup interval.
-            set_wakeup_time_to_the_distant_future();
-
-            // delegate the kick back to the main thread
-            g_idle_add (kick_idle, this);
-        }
-    }
-
-    core::Signal<> m_timeout;
-    std::recursive_mutex m_mutex;
-    bool m_yielding = false;
-    const std::shared_ptr<Clock>& m_clock;
-    UHardwareAlarm m_hardware_alarm = nullptr;
-    std::thread m_thread;
-};
-
-/***
-****
-***/
-
-UhaWakeupTimer::UhaWakeupTimer(const std::shared_ptr<Clock>& clock):
-    p(new Impl(clock))
-{
-}
-
-UhaWakeupTimer::~UhaWakeupTimer()
-{
-}
-
-bool UhaWakeupTimer::is_supported()
-{
-    auto hw_alarm = u_hardware_alarm_create();
-    g_debug ("%s hardware alarm %p", G_STRFUNC, hw_alarm);
-    return hw_alarm != nullptr;
-}
-
-void UhaWakeupTimer::set_wakeup_time(const DateTime& d)
-{
-    p->set_wakeup_time(d);
-}
-
-core::Signal<>& UhaWakeupTimer::timeout()
-{
-    return p->timeout();
-}
-
-/***
-****
-***/
-
-} // namespace datetime
-} // namespace indicator
-} // namespace unity