aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CMakeLists.txt3
-rw-r--r--src/awake.cpp250
-rw-r--r--src/main.cpp9
-rw-r--r--src/notifications.cpp367
-rw-r--r--src/snap.cpp627
-rw-r--r--src/sound.cpp161
6 files changed, 841 insertions, 576 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index af09c71..754d537 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,6 +11,7 @@ set (SERVICE_CXX_SOURCES
actions.cpp
actions-live.cpp
alarm-queue-simple.cpp
+ awake.cpp
appointment.cpp
clock.cpp
clock-live.cpp
@@ -22,11 +23,13 @@ set (SERVICE_CXX_SOURCES
locations.cpp
locations-settings.cpp
menu.cpp
+ notifications.cpp
planner-month.cpp
planner-range.cpp
planner-upcoming.cpp
settings-live.cpp
snap.cpp
+ sound.cpp
timezone-file.cpp
timezone-geoclue.cpp
timezones-live.cpp
diff --git a/src/awake.cpp b/src/awake.cpp
new file mode 100644
index 0000000..19826ae
--- /dev/null
+++ b/src/awake.cpp
@@ -0,0 +1,250 @@
+/*
+ * 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 <notifications/awake.h>
+#include <notifications/dbus-shared.h>
+
+#include <gio/gio.h>
+
+#include <limits>
+
+namespace unity {
+namespace indicator {
+namespace notifications {
+
+/***
+****
+***/
+
+class Awake::Impl
+{
+public:
+
+ Impl(const std::string& app_name):
+ m_app_name(app_name),
+ m_cancellable(g_cancellable_new())
+ {
+ g_bus_get(G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this);
+ }
+
+ ~Impl()
+ {
+ g_cancellable_cancel (m_cancellable);
+ g_object_unref (m_cancellable);
+
+ if (m_system_bus != nullptr)
+ {
+ unforce_awake ();
+ unforce_screen ();
+ g_object_unref (m_system_bus);
+ }
+ }
+
+private:
+
+ static void on_system_bus_ready (GObject *, GAsyncResult *res, gpointer gself)
+ {
+ GError * error;
+ GDBusConnection * system_bus;
+
+ error = nullptr;
+ system_bus = g_bus_get_finish (res, &error);
+ if (error != nullptr)
+ {
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+ g_warning ("Unable to get bus: %s", error->message);
+
+ g_error_free (error);
+ }
+ else if (system_bus != nullptr)
+ {
+ auto self = static_cast<Impl*>(gself);
+
+ self->m_system_bus = G_DBUS_CONNECTION (g_object_ref (system_bus));
+
+ // ask powerd to keep the system awake
+ static constexpr int32_t POWERD_SYS_STATE_ACTIVE = 1;
+ g_dbus_connection_call (system_bus,
+ BUS_POWERD_NAME,
+ BUS_POWERD_PATH,
+ BUS_POWERD_INTERFACE,
+ "requestSysState",
+ g_variant_new("(si)", self->m_app_name.c_str(), POWERD_SYS_STATE_ACTIVE),
+ G_VARIANT_TYPE("(s)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ self->m_cancellable,
+ 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);
+
+ g_object_unref (system_bus);
+ }
+ }
+
+ static void on_force_awake_response (GObject * connection,
+ GAsyncResult * res,
+ gpointer gself)
+ {
+ GError * error;
+ GVariant * args;
+
+ error = nullptr;
+ args = g_dbus_connection_call_finish (G_DBUS_CONNECTION(connection), res, &error);
+ if (error != nullptr)
+ {
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+ !g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN))
+ {
+ g_warning ("Unable to inhibit sleep: %s", error->message);
+ }
+
+ g_error_free (error);
+ }
+ else
+ {
+ auto self = static_cast<Impl*>(gself);
+
+ g_clear_pointer (&self->m_awake_cookie, g_free);
+ g_variant_get (args, "(s)", &self->m_awake_cookie);
+ g_debug ("m_awake_cookie is now '%s'", self->m_awake_cookie);
+
+ g_variant_unref (args);
+ }
+ }
+
+ static void on_force_screen_response (GObject * connection,
+ GAsyncResult * res,
+ gpointer gself)
+ {
+ GError * error;
+ GVariant * args;
+
+ error = nullptr;
+ args = g_dbus_connection_call_finish (G_DBUS_CONNECTION(connection), res, &error);
+ if (error != nullptr)
+ {
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+ !g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN))
+ {
+ g_warning ("Unable to turn on the screen: %s", error->message);
+ }
+
+ g_error_free (error);
+ }
+ else
+ {
+ auto self = static_cast<Impl*>(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);
+
+ 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);
+ }
+ }
+
+ void unforce_screen ()
+ {
+ g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus));
+
+ if (m_screen_cookie != NO_SCREEN_COOKIE)
+ {
+ g_dbus_connection_call (m_system_bus,
+ BUS_SCREEN_NAME,
+ BUS_SCREEN_PATH,
+ BUS_SCREEN_INTERFACE,
+ "removeDisplayOnRequest",
+ g_variant_new("(i)", m_screen_cookie),
+ nullptr,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ nullptr,
+ nullptr,
+ nullptr);
+
+ m_screen_cookie = NO_SCREEN_COOKIE;
+ }
+ }
+
+ 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<int32_t>::min() };
+};
+
+/***
+****
+***/
+
+Awake::Awake(const std::string& app_name):
+ impl(new Impl (app_name))
+{
+}
+
+Awake::~Awake()
+{
+}
+
+/***
+****
+***/
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
diff --git a/src/main.cpp b/src/main.cpp
index cc81cd7..eb90020 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -32,6 +32,7 @@
#include <datetime/timezone-file.h>
#include <datetime/timezones-live.h>
#include <datetime/wakeup-timer-mainloop.h>
+#include <notifications/notifications.h>
#ifdef HAVE_UBUNTU_HW_ALARM_H
#include <datetime/wakeup-timer-uha.h>
@@ -45,6 +46,8 @@
#include <locale.h>
#include <cstdlib> // exit()
+namespace uin = unity::indicator::notifications;
+
using namespace unity::indicator::datetime;
namespace
@@ -141,7 +144,8 @@ main(int /*argc*/, char** /*argv*/)
MenuFactory factory(actions, state);
// set up the snap decisions
- Snap snap (state->clock, state->settings);
+ 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, engine, timezone);
alarm_queue->alarm_reached().connect([&snap](const Appointment& appt){
auto snap_show = [](const Appointment& a){
@@ -153,7 +157,7 @@ main(int /*argc*/, char** /*argv*/)
url_dispatch_send(url, nullptr, nullptr);
};
auto snap_dismiss = [](const Appointment&){};
- snap(appt, snap_show, snap_dismiss);
+ (*snap)(appt, snap_show, snap_dismiss);
});
// create the menus
@@ -170,6 +174,7 @@ main(int /*argc*/, char** /*argv*/)
});
exporter.publish(actions, menus);
g_main_loop_run(loop);
+
g_main_loop_unref(loop);
return 0;
}
diff --git a/src/notifications.cpp b/src/notifications.cpp
new file mode 100644
index 0000000..41ced42
--- /dev/null
+++ b/src/notifications.cpp
@@ -0,0 +1,367 @@
+/*
+ * 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 <notifications/notifications.h>
+
+#include <libnotify/notify.h>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace unity {
+namespace indicator {
+namespace notifications {
+
+static G_DEFINE_QUARK(NotificationKey, notification_key)
+
+static G_DEFINE_QUARK(NotificationAction, notification_action)
+
+/***
+****
+***/
+
+class Builder::Impl
+{
+public:
+ std::string m_title;
+ std::string m_body;
+ std::string m_icon_name;
+ std::chrono::seconds m_duration;
+ std::set<std::string> m_string_hints;
+ std::vector<std::pair<std::string,std::string>> m_actions;
+ std::function<void(const std::string&)> m_closed_callback;
+};
+
+Builder::Builder():
+ impl(new Impl())
+{
+}
+
+Builder::~Builder()
+{
+}
+
+void
+Builder::set_title (const std::string& title)
+{
+ impl->m_title = title;
+}
+
+void
+Builder::set_body (const std::string& body)
+{
+ impl->m_body = body;
+}
+
+void
+Builder::set_icon_name (const std::string& icon_name)
+{
+ impl->m_icon_name = icon_name;
+}
+
+void
+Builder::set_timeout (const std::chrono::seconds& duration)
+{
+ impl->m_duration = duration;
+}
+
+void
+Builder::add_hint (const std::string& name)
+{
+ impl->m_string_hints.insert (name);
+}
+
+void
+Builder::add_action (const std::string& action, const std::string& label)
+{
+ impl->m_actions.push_back(std::pair<std::string,std::string>(action,label));
+}
+
+void
+Builder::set_closed_callback (std::function<void (const std::string&)> cb)
+{
+ impl->m_closed_callback.swap (cb);
+}
+
+/***
+****
+***/
+
+class Engine::Impl
+{
+ struct notification_data
+ {
+ std::shared_ptr<NotifyNotification> nn;
+ std::function<void(const std::string&)> closed_callback;
+ };
+
+public:
+
+ Impl(const std::string& app_name):
+ m_app_name(app_name)
+ {
+ if (!notify_init(app_name.c_str()))
+ g_critical("Unable to initialize libnotify!");
+
+ // put the server capabilities into m_caps
+ auto caps_gl = notify_get_server_caps();
+ std::string caps_str;
+ for(auto l=caps_gl; l!=nullptr; l=l->next)
+ {
+ m_caps.insert((const char*)l->data);
+
+ caps_str += (const char*) l->data;;
+ if (l->next != nullptr)
+ caps_str += ", ";
+ }
+
+ g_debug("%s notify_get_server() returned [%s]", G_STRFUNC, caps_str.c_str());
+ g_list_free_full(caps_gl, g_free);
+ }
+
+ ~Impl()
+ {
+ close_all ();
+
+ notify_uninit ();
+ }
+
+ const std::string& app_name() const
+ {
+ return m_app_name;
+ }
+
+ bool supports_actions() const
+ {
+ return m_caps.count("actions") != 0;
+ }
+
+ bool close_all ()
+ {
+ bool all_closed = true;
+
+ // close() removes the item from m_notifications,
+ // so increment the iterator before it gets invalidated
+ for (auto it=m_notifications.begin(), end=m_notifications.end(); it!=end; )
+ {
+ const int key = it->first;
+ ++it;
+ if (!close (key))
+ all_closed = false;
+ }
+
+ return all_closed;
+ }
+
+ bool close (int key)
+ {
+ bool is_closed = true;
+
+ // if we've got this one...
+ auto it = m_notifications.find(key);
+ if (it != m_notifications.end())
+ {
+ GError * error = nullptr;
+ is_closed = notify_notification_close (it->second.nn.get(), &error);
+ if (!is_closed)
+ {
+ g_warning ("Unable to close notification %d: %s", key, error->message);
+ g_error_free (error);
+ }
+ on_closed (key);
+ }
+
+ return is_closed;
+ }
+
+ int show (const Builder& builder)
+ {
+ int ret = -1;
+ const auto& info = *builder.impl;
+
+ auto * nn = notify_notification_new (info.m_title.c_str(),
+ info.m_body.c_str(),
+ info.m_icon_name.c_str());
+
+ if (info.m_duration.count() != 0)
+ {
+ const auto& d= info.m_duration;
+ auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(d);
+
+ notify_notification_set_hint (nn,
+ HINT_TIMEOUT,
+ g_variant_new_int32(ms.count()));
+ }
+
+ for (const auto& hint : info.m_string_hints)
+ {
+ notify_notification_set_hint (nn,
+ hint.c_str(),
+ g_variant_new_boolean(true));
+ }
+
+ for (const auto& action : info.m_actions)
+ {
+ notify_notification_add_action (nn,
+ action.first.c_str(),
+ action.second.c_str(),
+ on_notification_clicked,
+ nullptr,
+ nullptr);
+ }
+
+ // if we can show it, keep it
+ GError * error = nullptr;
+ if (notify_notification_show(nn, &error))
+ {
+ static int next_key = 1;
+ const int key = next_key++;
+
+ g_signal_connect (nn, "closed",
+ G_CALLBACK(on_notification_closed), this);
+ g_object_set_qdata (G_OBJECT(nn),
+ notification_key_quark(),
+ GINT_TO_POINTER(key));
+
+ notification_data ndata;
+ ndata.closed_callback = info.m_closed_callback;
+ ndata.nn.reset(nn, [this](NotifyNotification * n) {
+ g_signal_handlers_disconnect_by_data(n, this);
+ g_object_unref (G_OBJECT(n));
+ });
+
+ m_notifications[key] = ndata;
+ ret = key;
+ }
+ else
+ {
+ g_critical ("Unable to show notification for '%s': %s", info.m_title.c_str(), error->message);
+ g_error_free (error);
+ g_object_unref (nn);
+ }
+
+ return ret;
+ }
+
+private:
+
+ static void on_notification_clicked (NotifyNotification * nn,
+ char * action,
+ gpointer)
+ {
+ g_object_set_qdata_full (G_OBJECT(nn),
+ notification_action_quark(),
+ g_strdup(action),
+ g_free);
+ }
+
+ static void on_notification_closed (NotifyNotification * nn, gpointer gself)
+ {
+ const GQuark q = notification_key_quark();
+ const int key = GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(nn), q));
+ static_cast<Impl*>(gself)->on_closed (key);
+ }
+
+ void on_closed (int key)
+ {
+ auto it = m_notifications.find(key);
+ g_return_if_fail (it != m_notifications.end());
+
+ const auto& ndata = it->second;
+ auto nn = ndata.nn.get();
+ if (ndata.closed_callback)
+ {
+ std::string action;
+
+ const auto q = notification_action_quark();
+ const auto p = g_object_get_qdata (G_OBJECT(nn), q);
+ if (p != nullptr)
+ action = static_cast<const char*>(p);
+
+ ndata.closed_callback (action);
+ }
+
+ g_signal_handlers_disconnect_by_data(nn, this);
+ m_notifications.erase(it);
+ }
+
+ /***
+ ****
+ ***/
+
+ const std::string m_app_name;
+ std::map<int,notification_data> m_notifications;
+ std::set<std::string> m_caps;
+
+ static constexpr char const * HINT_TIMEOUT {"x-canonical-snap-decisions-timeout"};
+};
+
+/***
+****
+***/
+
+Engine::Engine(const std::string& app_name):
+ impl(new Impl(app_name))
+{
+}
+
+Engine::~Engine()
+{
+}
+
+bool
+Engine::supports_actions() const
+{
+ return impl->supports_actions();
+}
+
+int
+Engine::show(const Builder& builder)
+{
+ return impl->show(builder);
+}
+
+bool
+Engine::close_all()
+{
+ return impl->close_all();
+}
+
+bool
+Engine::close(int key)
+{
+ return impl->close(key);
+}
+
+const std::string&
+Engine::app_name() const
+{
+ return impl->app_name();
+}
+
+/***
+****
+***/
+
+} // namespace notifications
+} // namespace indicator
+} // namespace unity
+
diff --git a/src/snap.cpp b/src/snap.cpp
index c21a398..4da4b45 100644
--- a/src/snap.cpp
+++ b/src/snap.cpp
@@ -17,25 +17,20 @@
* Charles Kerr <charles.kerr@canonical.com>
*/
-#include <datetime/appointment.h>
-#include <datetime/dbus-shared.h>
-#include <datetime/formatter.h>
#include <datetime/snap.h>
-#include <core/signal.h>
+#include <notifications/awake.h>
+#include <notifications/sound.h>
#include <gst/gst.h>
-#include <libnotify/notify.h>
#include <glib/gi18n.h>
-#include <glib.h>
#include <chrono>
-#include <limits>
-#include <mutex> // std::call_once()
-#include <set>
#include <string>
+namespace uin = unity::indicator::notifications;
+
namespace unity {
namespace indicator {
namespace datetime {
@@ -44,175 +39,8 @@ namespace datetime {
****
***/
-namespace
-{
-
-static constexpr char const * APP_NAME = {"indicator-datetime-service"};
-
-/**
- * Plays a sound, possibly looping.
- */
-class Sound
-{
- typedef Sound Self;
-
-public:
-
- Sound(const std::shared_ptr<Clock>& clock,
- const std::string& uri,
- unsigned int volume,
- unsigned int duration_minutes,
- bool loop):
- m_clock(clock),
- m_uri(uri),
- m_volume(volume),
- m_loop(loop),
- m_loop_end_time(clock->localtime().add_full(0, 0, 0, 0, (int)duration_minutes, 0.0))
- {
- // init GST once
- static std::once_flag once;
- std::call_once(once, [](){
- GError* error = nullptr;
- gst_init_check (nullptr, nullptr, &error);
- if (error)
- {
- g_critical("Unable to play alarm sound: %s", error->message);
- g_error_free(error);
- }
- });
-
- if (m_loop)
- {
- g_debug("Looping '%s' until cutoff time %s",
- m_uri.c_str(),
- m_loop_end_time.format("%F %T").c_str());
- }
- else
- {
- g_debug("Playing '%s' once", m_uri.c_str());
- }
-
- m_play = gst_element_factory_make("playbin", "play");
-
- auto bus = gst_pipeline_get_bus(GST_PIPELINE(m_play));
- m_watch_source = gst_bus_add_watch(bus, bus_callback, this);
- gst_object_unref(bus);
-
- play();
- }
-
- ~Sound()
- {
- stop();
-
- g_source_remove(m_watch_source);
-
- if (m_play != nullptr)
- {
- gst_element_set_state (m_play, GST_STATE_NULL);
- g_clear_pointer (&m_play, gst_object_unref);
- }
- }
-
-private:
-
- void stop()
- {
- if (m_play != nullptr)
- {
- gst_element_set_state (m_play, GST_STATE_PAUSED);
- }
- }
-
- void play()
- {
- g_return_if_fail(m_play != nullptr);
-
- g_object_set(G_OBJECT (m_play), "uri", m_uri.c_str(),
- "volume", get_volume(),
- nullptr);
- gst_element_set_state (m_play, GST_STATE_PLAYING);
- }
-
- // convert settings range [1..100] to gst playbin's range is [0...1.0]
- gdouble get_volume() const
- {
- constexpr int in_range_lo = 1;
- constexpr int in_range_hi = 100;
- const double in = CLAMP(m_volume, in_range_lo, in_range_hi);
- const double pct = (in - in_range_lo) / (in_range_hi - in_range_lo);
-
- constexpr double out_range_lo = 0.0;
- constexpr double out_range_hi = 1.0;
- return out_range_lo + (pct * (out_range_hi - out_range_lo));
- }
-
- static gboolean bus_callback(GstBus*, GstMessage* msg, gpointer gself)
- {
- auto self = static_cast<Sound*>(gself);
-
- if ((GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS) &&
- (self->m_loop) &&
- (self->m_clock->localtime() < self->m_loop_end_time))
- {
- gst_element_seek(self->m_play,
- 1.0,
- GST_FORMAT_TIME,
- GST_SEEK_FLAG_FLUSH,
- GST_SEEK_TYPE_SET,
- 0,
- GST_SEEK_TYPE_NONE,
- (gint64)GST_CLOCK_TIME_NONE);
- }
-
- return G_SOURCE_CONTINUE; // keep listening
- }
-
- /***
- ****
- ***/
-
- const std::shared_ptr<Clock> m_clock;
- const std::string m_uri;
- const unsigned int m_volume;
- const bool m_loop;
- const DateTime m_loop_end_time;
- guint m_watch_source = 0;
- GstElement* m_play = nullptr;
-};
-
-class SoundBuilder
-{
-public:
- void set_clock(const std::shared_ptr<Clock>& c) {m_clock = c;}
- void set_uri(const std::string& uri) {m_uri = uri;}
- void set_volume(const unsigned int v) {m_volume = v;}
- void set_duration_minutes(unsigned int i) {m_duration_minutes=i;}
- unsigned int duration_minutes() const {return m_duration_minutes;}
- void set_looping(bool b) {m_looping=b;}
-
- Sound* operator()() {
- return new Sound (m_clock,
- m_uri,
- m_volume,
- m_duration_minutes,
- m_looping);
- }
-
-private:
- std::shared_ptr<Clock> m_clock;
- std::string m_uri;
- unsigned int m_volume = 50;
- unsigned int m_duration_minutes = 30;
- bool m_looping = true;
-};
-
-/**
-*** libnotify -- snap decisions
-**/
-
-std::string get_alarm_uri(const Appointment& appointment,
- const std::shared_ptr<const Settings>& settings)
+static std::string get_alarm_uri(const Appointment& appointment,
+ const std::shared_ptr<const Settings>& settings)
{
const char* FALLBACK {"/usr/share/sounds/ubuntu/ringtones/Suru arpeggio.ogg"};
@@ -244,384 +72,21 @@ std::string get_alarm_uri(const Appointment& appointment,
return uri;
}
-int32_t n_existing_snaps = 0;
-
-} // unnamed namespace
-
-/**
- * A popup notification (with optional sound)
- * that emits a Response signal when done.
- */
-class Snap::Popup
-{
-public:
-
- Popup(const Appointment& appointment, const SoundBuilder& sound_builder):
- m_appointment(appointment),
- m_interactive(get_interactive()),
- m_sound_builder(sound_builder),
- m_cancellable(g_cancellable_new())
- {
- g_bus_get (G_BUS_TYPE_SYSTEM, m_cancellable, on_system_bus_ready, this);
-
- show();
- }
-
- ~Popup()
- {
- if (m_cancellable != nullptr)
- {
- g_cancellable_cancel (m_cancellable);
- g_clear_object (&m_cancellable);
- }
-
- if (m_system_bus != nullptr)
- {
- unforce_awake ();
- unforce_screen ();
- g_clear_object (&m_system_bus);
- }
-
- if (m_nn != nullptr)
- {
- notify_notification_clear_actions(m_nn);
- g_signal_handlers_disconnect_by_data(m_nn, this);
- g_clear_object(&m_nn);
- }
- }
-
- typedef enum
- {
- RESPONSE_SHOW,
- RESPONSE_DISMISS,
- RESPONSE_CLOSE
- }
- Response;
-
- core::Signal<Response>& response() { return m_response; }
-
-private:
-
- void show()
- {
- const Appointment& appointment = m_appointment;
-
- /// strftime(3) format string for an alarm's snap decision
- const auto timestr = appointment.begin.format(_("%a, %X"));
- auto title = g_strdup_printf(_("Alarm %s"), timestr.c_str());
- const auto body = appointment.summary;
- const gchar* icon_name = "alarm-clock";
-
- m_nn = notify_notification_new(title, body.c_str(), icon_name);
- if (m_interactive)
- {
- const auto duration = std::chrono::minutes(m_sound_builder.duration_minutes());
-
- notify_notification_set_hint(m_nn, HINT_SNAP,
- g_variant_new_boolean(true));
- notify_notification_set_hint(m_nn, HINT_TINT,
- g_variant_new_boolean(true));
- notify_notification_set_hint(m_nn, HINT_TIMEOUT,
- g_variant_new_int32(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()));
-
- /// alarm popup dialog's button to show the active alarm
- notify_notification_add_action(m_nn, "show", _("Show"),
- on_snap_show, this, nullptr);
- /// alarm popup dialog's button to shut up the alarm
- notify_notification_add_action(m_nn, "dismiss", _("Dismiss"),
- on_snap_dismiss, this, nullptr);
- g_signal_connect(m_nn, "closed", G_CALLBACK(on_snap_closed), this);
- }
-
- bool shown = true;
- GError* error = nullptr;
- notify_notification_show(m_nn, &error);
- if (error != NULL)
- {
- g_critical("Unable to show snap decision for '%s': %s",
- body.c_str(), error->message);
- g_error_free(error);
- shown = false;
- }
-
- // Loop the sound *only* if we're prompting the user for a response.
- // Otherwise, just play the sound once.
- m_sound_builder.set_looping (shown && m_interactive);
- m_sound.reset (m_sound_builder());
-
- // if showing the notification didn't work,
- // treat it as if the user clicked the 'show' button
- if (!shown)
- {
- on_snap_show(nullptr, nullptr, this);
- on_snap_dismiss(nullptr, nullptr, this);
- }
-
- g_free(title);
- }
-
- // user clicked 'show'
- static void on_snap_show(NotifyNotification*, gchar*, gpointer gself)
- {
- auto self = static_cast<Self*>(gself);
- self->m_response_value = RESPONSE_SHOW;
- self->m_sound.reset();
- }
-
- // user clicked 'dismiss'
- static void on_snap_dismiss(NotifyNotification*, gchar*, gpointer gself)
- {
- auto self = static_cast<Self*>(gself);
- self->m_response_value = RESPONSE_DISMISS;
- self->m_sound.reset();
- }
-
- // the popup was closed
- static void on_snap_closed(NotifyNotification*, gpointer gself)
- {
- auto self = static_cast<Self*>(gself);
- self->m_sound.reset();
- self->m_response(self->m_response_value);
- }
-
- /***
- **** Interactive
- ***/
-
- static std::set<std::string> get_server_caps()
- {
- std::set<std::string> caps_set;
- auto caps_gl = notify_get_server_caps();
- std::string caps_str;
- for(auto l=caps_gl; l!=nullptr; l=l->next)
- {
- caps_set.insert((const char*)l->data);
-
- caps_str += (const char*) l->data;;
- if (l->next != nullptr)
- caps_str += ", ";
- }
- g_debug("%s notify_get_server() returned [%s]", G_STRFUNC, caps_str.c_str());
- g_list_free_full(caps_gl, g_free);
- return caps_set;
- }
-
- static bool get_interactive()
- {
- static bool interactive;
-
- static std::once_flag once;
- std::call_once(once, [](){
- interactive = get_server_caps().count("actions") != 0;
- });
-
- return interactive;
- }
-
- /***
- ****
- ***/
-
- static void on_system_bus_ready (GObject *, GAsyncResult *res, gpointer gself)
- {
- GError * error;
- GDBusConnection * system_bus;
-
- error = nullptr;
- system_bus = g_bus_get_finish (res, &error);
- if (error != nullptr)
- {
- if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
- g_warning ("Unable to get bus: %s", error->message);
-
- g_error_free (error);
- }
- else if (system_bus != nullptr)
- {
- auto self = static_cast<Popup*>(gself);
-
- self->m_system_bus = G_DBUS_CONNECTION (g_object_ref (system_bus));
-
- // ask powerd to keep the system awake
- static constexpr int32_t POWERD_SYS_STATE_ACTIVE = 1;
- g_dbus_connection_call (system_bus,
- BUS_POWERD_NAME,
- BUS_POWERD_PATH,
- BUS_POWERD_INTERFACE,
- "requestSysState",
- g_variant_new("(si)", APP_NAME, POWERD_SYS_STATE_ACTIVE),
- G_VARIANT_TYPE("(s)"),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- self->m_cancellable,
- 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);
-
- g_object_unref (system_bus);
- }
- }
-
- static void on_force_awake_response (GObject * connection,
- GAsyncResult * res,
- gpointer gself)
- {
- GError * error;
- GVariant * args;
-
- error = nullptr;
- args = g_dbus_connection_call_finish (G_DBUS_CONNECTION(connection), res, &error);
- if (error != nullptr)
- {
- if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
- g_warning ("Unable to inhibit sleep: %s", error->message);
-
- g_error_free (error);
- }
- else
- {
- auto self = static_cast<Popup*>(gself);
-
- g_clear_pointer (&self->m_awake_cookie, g_free);
- g_variant_get (args, "(s)", &self->m_awake_cookie);
- g_debug ("m_awake_cookie is now '%s'", self->m_awake_cookie);
-
- g_variant_unref (args);
- }
- }
-
- static void on_force_screen_response (GObject * connection,
- GAsyncResult * res,
- gpointer gself)
- {
- GError * error;
- GVariant * args;
-
- error = nullptr;
- args = g_dbus_connection_call_finish (G_DBUS_CONNECTION(connection), res, &error);
- if (error != nullptr)
- {
- if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
- g_warning ("Unable to turn on the screen: %s", error->message);
-
- g_error_free (error);
- }
- else
- {
- auto self = static_cast<Popup*>(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);
-
- 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);
- }
- }
-
- void unforce_screen ()
- {
- g_return_if_fail (G_IS_DBUS_CONNECTION(m_system_bus));
-
- if (m_screen_cookie != NO_SCREEN_COOKIE)
- {
- g_dbus_connection_call (m_system_bus,
- BUS_SCREEN_NAME,
- BUS_SCREEN_PATH,
- BUS_SCREEN_INTERFACE,
- "removeDisplayOnRequest",
- g_variant_new("(i)", m_screen_cookie),
- nullptr,
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- nullptr,
- nullptr,
- nullptr);
-
- m_screen_cookie = NO_SCREEN_COOKIE;
- }
- }
-
- /***
- ****
- ***/
-
- typedef Popup Self;
-
- const Appointment m_appointment;
- const bool m_interactive;
- SoundBuilder m_sound_builder;
- std::unique_ptr<Sound> m_sound;
- core::Signal<Response> m_response;
- Response m_response_value = RESPONSE_CLOSE;
- NotifyNotification* m_nn = nullptr;
- 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<int32_t>::min() };
-
- static constexpr char const * HINT_SNAP {"x-canonical-snap-decisions"};
- static constexpr char const * HINT_TINT {"x-canonical-private-button-tint"};
- static constexpr char const * HINT_TIMEOUT {"x-canonical-snap-decisions-timeout"};
-};
-
/***
****
***/
-Snap::Snap(const std::shared_ptr<Clock>& clock,
+Snap::Snap(const std::shared_ptr<uin::Engine>& engine,
const std::shared_ptr<const Settings>& settings):
- m_clock(clock),
+ m_engine(engine),
m_settings(settings)
{
- if (!n_existing_snaps++ && !notify_init(APP_NAME))
- g_critical("libnotify initialization failed");
}
Snap::~Snap()
{
- for (auto popup : m_pending)
- delete popup;
-
- if (!--n_existing_snaps)
- notify_uninit();
+ for (const auto& key : m_notifications)
+ m_engine->close (key);
}
void Snap::operator()(const Appointment& appointment,
@@ -634,38 +99,52 @@ void Snap::operator()(const Appointment& appointment,
return;
}
- // create a popup...
- SoundBuilder sound_builder;
- sound_builder.set_uri(get_alarm_uri(appointment, m_settings));
- sound_builder.set_volume(m_settings->alarm_volume.get());
- sound_builder.set_clock(m_clock);
- sound_builder.set_duration_minutes(m_settings->alarm_duration.get());
- auto popup = new Popup(appointment, sound_builder);
-
- m_pending.insert(popup);
-
- // listen for it to finish...
- popup->response().connect([this,
- appointment,
- show,
- dismiss,
- popup](Popup::Response response){
-
- m_pending.erase(popup);
-
- // we can't delete the Popup inside its response() signal handler
- // because core::signal deadlocks, so push that to an idle func
- g_idle_add([](gpointer gdata){
- delete static_cast<Popup*>(gdata);
- return G_SOURCE_REMOVE;
- }, popup);
-
- // maybe notify the client code that the popup's done
- if (response == Popup::RESPONSE_SHOW)
+ // force the system to stay awake
+ auto awake = std::make_shared<uin::Awake>(m_engine->app_name());
+
+ // create the sound...,
+ const auto uri = get_alarm_uri(appointment, m_settings);
+ const auto volume = m_settings->alarm_volume.get();
+ const bool loop = m_engine->supports_actions();
+ auto sound = std::make_shared<uin::Sound>(uri, volume, loop);
+
+ // show a notification...
+ const auto minutes = m_settings->alarm_duration.get();
+ const bool interactive = m_engine->supports_actions();
+ uin::Builder notification_builder;
+ notification_builder.set_body (appointment.summary);
+ notification_builder.set_icon_name ("alarm-clock");
+ notification_builder.add_hint (uin::Builder::HINT_SNAP);
+ notification_builder.add_hint (uin::Builder::HINT_TINT);
+ const auto timestr = appointment.begin.format (_("%a, %X"));
+ auto title = g_strdup_printf (_("Alarm %s"), timestr.c_str());
+ notification_builder.set_title (title);
+ g_free (title);
+ notification_builder.set_timeout (std::chrono::duration_cast<std::chrono::seconds>(std::chrono::minutes(minutes)));
+ if (interactive) {
+ notification_builder.add_action ("show", _("Show"));
+ notification_builder.add_action ("dismiss", _("Dismiss"));
+ }
+
+ // add the 'sound' and 'awake' objects to the capture so that
+ // they stay alive until the closed callback is called; i.e.,
+ // for the lifespan of the notficiation
+ notification_builder.set_closed_callback([appointment,
+ show,
+ dismiss,
+ sound,
+ awake](const std::string& action){
+ if (action == "show")
show(appointment);
- else if (response == Popup::RESPONSE_DISMISS)
+ else
dismiss(appointment);
});
+
+ const auto key = m_engine->show (notification_builder);
+ if (key)
+ m_notifications.insert (key);
+ else
+ show(appointment);
}
/***
diff --git a/src/sound.cpp b/src/sound.cpp
new file mode 100644
index 0000000..bf2284e
--- /dev/null
+++ b/src/sound.cpp
@@ -0,0 +1,161 @@
+/*
+ * 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 <notifications/sound.h>
+
+#include <gst/gst.h>
+
+#include <mutex> // std::call_once()
+
+namespace unity {
+namespace indicator {
+namespace notifications {
+
+/***
+****
+***/
+
+/**
+ * Plays a sound, possibly looping.
+ */
+class Sound::Impl
+{
+public:
+
+ Impl(const std::string& uri,
+ unsigned int volume,
+ bool loop):
+ m_uri(uri),
+ m_volume(volume),
+ m_loop(loop)
+ {
+ // init GST once
+ static std::once_flag once;
+ std::call_once(once, [](){
+ GError* error = nullptr;
+ gst_init_check (nullptr, nullptr, &error);
+ if (error)
+ {
+ g_critical("Unable to play alarm sound: %s", error->message);
+ g_error_free(error);
+ }
+ });
+
+ m_play = gst_element_factory_make("playbin", "play");
+
+ auto bus = gst_pipeline_get_bus(GST_PIPELINE(m_play));
+ m_watch_source = gst_bus_add_watch(bus, bus_callback, this);
+ gst_object_unref(bus);
+
+ g_debug("Playing '%s'", m_uri.c_str());
+ play();
+ }
+
+ ~Impl()
+ {
+ stop();
+
+ g_source_remove(m_watch_source);
+
+ if (m_play != nullptr)
+ {
+ gst_element_set_state (m_play, GST_STATE_NULL);
+ g_clear_pointer (&m_play, gst_object_unref);
+ }
+ }
+
+private:
+
+ void stop()
+ {
+ if (m_play != nullptr)
+ {
+ gst_element_set_state (m_play, GST_STATE_PAUSED);
+ }
+ }
+
+ void play()
+ {
+ g_return_if_fail(m_play != nullptr);
+
+ g_object_set(G_OBJECT (m_play), "uri", m_uri.c_str(),
+ "volume", get_volume(),
+ nullptr);
+ gst_element_set_state (m_play, GST_STATE_PLAYING);
+ }
+
+ // convert settings range [1..100] to gst playbin's range is [0...1.0]
+ gdouble get_volume() const
+ {
+ constexpr int in_range_lo = 1;
+ constexpr int in_range_hi = 100;
+ const double in = CLAMP(m_volume, in_range_lo, in_range_hi);
+ const double pct = (in - in_range_lo) / (in_range_hi - in_range_lo);
+
+ constexpr double out_range_lo = 0.0;
+ constexpr double out_range_hi = 1.0;
+ return out_range_lo + (pct * (out_range_hi - out_range_lo));
+ }
+
+ static gboolean bus_callback(GstBus*, GstMessage* msg, gpointer gself)
+ {
+ auto self = static_cast<Impl*>(gself);
+
+ if ((GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS) && (self->m_loop))
+ {
+ gst_element_seek(self->m_play,
+ 1.0,
+ GST_FORMAT_TIME,
+ GST_SEEK_FLAG_FLUSH,
+ GST_SEEK_TYPE_SET,
+ 0,
+ GST_SEEK_TYPE_NONE,
+ (gint64)GST_CLOCK_TIME_NONE);
+ }
+
+ return G_SOURCE_CONTINUE; // keep listening
+ }
+
+ /***
+ ****
+ ***/
+
+ const std::string m_uri;
+ const unsigned int m_volume;
+ const bool m_loop;
+ guint m_watch_source = 0;
+ GstElement* m_play = nullptr;
+};
+
+Sound::Sound(const std::string& uri, unsigned int volume, bool loop):
+ impl (new Impl(uri, volume, loop))
+{
+}
+
+Sound::~Sound()
+{
+}
+
+/***
+****
+***/
+
+} // namespace notifications
+} // namespace indicator
+} // namespace unity