sync with trunk.

7 files changed, 575 insertions, 8 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a39b945..7a4a297 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -10,6 +10,7 @@ set(SERVICE_MANUAL_SOURCES
     ib-brightness-uscreen-control.c
     device-provider.c
     device.c
+    notifier.c
     service.c)
 
 # generated sources
@@ -19,6 +20,10 @@ add_gdbus_codegen_with_namespace(SERVICE_GENERATED_SOURCES dbus-upower
                                  org.freedesktop
                                  Dbus
                                  ${CMAKE_CURRENT_SOURCE_DIR}/org.freedesktop.UPower.xml)
+add_gdbus_codegen_with_namespace(SERVICE_GENERATED_SOURCES dbus-battery
+                                 com.canonical.indicator.power
+                                 Dbus
+                                 ${CMAKE_SOURCE_DIR}/data/com.canonical.indicator.power.Battery.xml)
 # add the bin dir to our include path so the code can find the generated header files
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
diff --git a/src/dbus-shared.h b/src/dbus-shared.h
new file mode 100644
index 0000000..bf54034
--- /dev/null
+++ b/src/dbus-shared.h
@@ -0,0 +1,28 @@
+/*
+ * 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>
+ *   Ted Gould <ted@canonical.com>
+ */
+
+#ifndef DBUS_SHARED_H
+#define DBUS_SHARED_H
+
+#define BUS_NAME "com.canonical.indicator.power"
+#define BUS_PATH "/com/canonical/indicator/power"
+
+#endif /* DBUS_SHARED_H */
+
diff --git a/src/device.h b/src/device.h
index 3a10f89..d867707 100644
--- a/src/device.h
+++ b/src/device.h
@@ -24,7 +24,7 @@ License along with this library. If not, see
 #ifndef __INDICATOR_POWER_DEVICE_H__
 #define __INDICATOR_POWER_DEVICE_H__
 
-#include <glib-object.h>
+#include <gio/gio.h> /* GIcon */
 
 G_BEGIN_DECLS
 
diff --git a/src/main.c b/src/main.c
index 7363284..d7953e6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -41,9 +41,9 @@ on_name_lost (gpointer instance G_GNUC_UNUSED, gpointer loop)
 int
 main (int argc G_GNUC_UNUSED, char ** argv G_GNUC_UNUSED)
 {
-  GMainLoop * loop;
-  IndicatorPowerService * service;
   IndicatorPowerDeviceProvider * device_provider;
+  IndicatorPowerService * service;
+  GMainLoop * loop;
 
   /* boilerplate i18n */
   setlocale (LC_ALL, "");
@@ -59,8 +59,8 @@ main (int argc G_GNUC_UNUSED, char ** argv G_GNUC_UNUSED)
   g_main_loop_run (loop);
 
   /* cleanup */
-  g_clear_object (&device_provider);
-  g_clear_object (&service);
   g_main_loop_unref (loop);
+  g_clear_object (&service);
+  g_clear_object (&device_provider);
   return 0;
 }
diff --git a/src/notifier.c b/src/notifier.c
new file mode 100644
index 0000000..81cd6f1
--- /dev/null
+++ b/src/notifier.c
@@ -0,0 +1,445 @@
+/*
+ * 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 "dbus-battery.h"
+#include "dbus-shared.h"
+#include "notifier.h"
+
+#include <libnotify/notify.h>
+
+#include <glib/gi18n.h>
+
+#define HINT_INTERACTIVE "x-canonical-switch-to-application"
+
+typedef enum
+{
+  POWER_LEVEL_CRITICAL,
+  POWER_LEVEL_VERY_LOW,
+  POWER_LEVEL_LOW,
+  POWER_LEVEL_OK
+}
+PowerLevel;
+
+/**
+***  GObject Properties
+**/
+
+enum
+{
+  PROP_0,
+  PROP_BATTERY,
+  LAST_PROP
+};
+
+#define PROP_BATTERY_NAME "battery"
+
+static GParamSpec * properties[LAST_PROP];
+
+static int instance_count = 0;
+
+/**
+***
+**/
+
+typedef struct
+{
+  /* The battery we're currently watching.
+     This may be a physical battery or it may be an aggregated
+     battery from multiple batteries present on the device.
+     See indicator_power_service_choose_primary_device() and
+     bug #880881 */
+  IndicatorPowerDevice * battery;
+  PowerLevel power_level;
+  gboolean discharging;
+
+  NotifyNotification * notify_notification;
+
+  GDBusConnection * bus;
+  DbusBattery * dbus_battery; /* com.canonical.indicator.power.Battery skeleton */
+}
+IndicatorPowerNotifierPrivate;
+
+typedef IndicatorPowerNotifierPrivate priv_t;
+
+G_DEFINE_TYPE_WITH_PRIVATE(IndicatorPowerNotifier,
+                           indicator_power_notifier,
+                           G_TYPE_OBJECT)
+
+#define get_priv(o) ((priv_t*)indicator_power_notifier_get_instance_private(o))
+
+/***
+****
+***/
+
+static const char *
+power_level_to_dbus_string (const PowerLevel power_level)
+{
+  switch (power_level)
+    {
+      case POWER_LEVEL_LOW:      return POWER_LEVEL_STR_LOW;
+      case POWER_LEVEL_VERY_LOW: return POWER_LEVEL_STR_VERY_LOW;
+      case POWER_LEVEL_CRITICAL: return POWER_LEVEL_STR_CRITICAL;
+      default:                   return POWER_LEVEL_STR_OK;
+    }
+}
+
+PowerLevel
+get_battery_power_level (IndicatorPowerDevice * battery)
+{
+  static const double percent_critical = 2.0;
+  static const double percent_very_low = 5.0;
+  static const double percent_low = 10.0;
+  gdouble p;
+  PowerLevel ret;
+
+  g_return_val_if_fail(battery != NULL, POWER_LEVEL_OK);
+  g_return_val_if_fail(indicator_power_device_get_kind(battery) == UP_DEVICE_KIND_BATTERY, POWER_LEVEL_OK);
+
+  p = indicator_power_device_get_percentage(battery);
+
+  if (p <= percent_critical)
+    ret = POWER_LEVEL_CRITICAL;
+  else if (p <= percent_very_low)
+    ret = POWER_LEVEL_VERY_LOW;
+  else if (p <= percent_low)
+    ret = POWER_LEVEL_LOW;
+  else
+    ret = POWER_LEVEL_OK;
+
+  return ret;
+}
+
+/***
+****  Notifications
+***/
+
+static void
+on_notify_notification_finalized (gpointer gself, GObject * dead)
+{
+  IndicatorPowerNotifier * const self = INDICATOR_POWER_NOTIFIER(gself);
+  priv_t * const p = get_priv(self);
+  g_return_if_fail ((void*)(p->notify_notification) == (void*)dead);
+  p->notify_notification = NULL;
+  dbus_battery_set_is_warning (p->dbus_battery, FALSE);
+}
+
+static void
+notification_clear (IndicatorPowerNotifier * self)
+{
+  priv_t * const p = get_priv(self);
+  NotifyNotification * nn;
+
+  if ((nn = p->notify_notification))
+    {
+      GError * error = NULL;
+
+      g_object_weak_unref(G_OBJECT(nn), on_notify_notification_finalized, self);
+
+      if (!notify_notification_close(nn, &error))
+        {
+          g_warning("Unable to close notification: %s", error->message);
+          g_error_free(error);
+        }
+
+      p->notify_notification = NULL;
+      dbus_battery_set_is_warning (p->dbus_battery, FALSE);
+    }
+}
+
+static void
+notification_show(IndicatorPowerNotifier * self)
+{
+  priv_t * const p = get_priv(self);
+  gdouble pct;
+  char * body;
+  NotifyNotification * nn;
+  GError * error;
+
+  notification_clear(self);
+
+  /* create the notification */
+  pct = indicator_power_device_get_percentage(p->battery);
+  body = g_strdup_printf(_("%.0f%% charge remaining"), pct);
+  nn = notify_notification_new(_("Battery Low"), body, NULL);
+  g_free (body);
+  /*notify_notification_set_hint(nn, HINT_INTERACTIVE, g_variant_new_boolean(TRUE));*/
+
+  /* if we can show it, keep it */
+  error = NULL;
+  if (notify_notification_show(nn, &error))
+    {
+      p->notify_notification = nn;
+      g_signal_connect(nn, "closed", G_CALLBACK(g_object_unref), NULL);
+      g_object_weak_ref(G_OBJECT(nn), on_notify_notification_finalized, self);
+      dbus_battery_set_is_warning (p->dbus_battery, TRUE);
+    }
+  else
+    {
+      g_critical("Unable to show snap decision for '%s': %s", body, error->message);
+      g_error_free(error);
+      g_object_unref(nn);
+    }
+}
+
+/***
+****
+***/
+
+static void
+on_battery_property_changed (IndicatorPowerNotifier * self)
+{
+  priv_t * p;
+  PowerLevel old_power_level;
+  PowerLevel new_power_level;
+  gboolean old_discharging;
+  gboolean new_discharging;
+
+  g_return_if_fail(INDICATOR_IS_POWER_NOTIFIER(self));
+  p = get_priv (self);
+  g_return_if_fail(INDICATOR_IS_POWER_DEVICE(p->battery));
+
+  old_power_level = p->power_level;
+  new_power_level = get_battery_power_level (p->battery);
+
+  old_discharging = p->discharging;
+  new_discharging = indicator_power_device_get_state(p->battery) == UP_DEVICE_STATE_DISCHARGING;
+
+  /* pop up a 'low battery' notification if either:
+     a) it's already discharging, and its PowerLevel worsens, OR
+     b) it's already got a bad PowerLevel and its state becomes 'discharging */
+  if ((new_discharging && (old_power_level > new_power_level)) ||
+      ((new_power_level != POWER_LEVEL_OK) && new_discharging && !old_discharging))
+    {
+      notification_show (self);
+    }
+  else if (!new_discharging || (new_power_level == POWER_LEVEL_OK))
+    {
+      notification_clear (self);
+    }
+
+  dbus_battery_set_power_level (p->dbus_battery, power_level_to_dbus_string (new_power_level));
+  p->power_level = new_power_level;
+  p->discharging = new_discharging;
+}
+
+/***
+****  GObject virtual functions
+***/
+
+static void
+my_get_property (GObject     * o,
+                 guint         property_id,
+                 GValue      * value,
+                 GParamSpec  * pspec)
+{
+  IndicatorPowerNotifier * const self = INDICATOR_POWER_NOTIFIER (o);
+  priv_t * const p = get_priv (self);
+
+  switch (property_id)
+    {
+      case PROP_BATTERY:
+        g_value_set_object (value, p->battery);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (o, property_id, pspec);
+    }
+}
+
+static void
+my_set_property (GObject       * o,
+                 guint           property_id,
+                 const GValue  * value,
+                 GParamSpec    * pspec)
+{
+  IndicatorPowerNotifier * const self = INDICATOR_POWER_NOTIFIER (o);
+
+  switch (property_id)
+    {
+      case PROP_BATTERY:
+        indicator_power_notifier_set_battery (self, g_value_get_object(value));
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (o, property_id, pspec);
+    }
+}
+
+static void
+my_dispose (GObject * o)
+{
+  IndicatorPowerNotifier * const self = INDICATOR_POWER_NOTIFIER(o);
+  priv_t * const p = get_priv (self);
+
+  indicator_power_notifier_set_bus (self, NULL);
+  notification_clear (self);
+  indicator_power_notifier_set_battery (self, NULL);
+  g_clear_object (&p->dbus_battery);
+
+  G_OBJECT_CLASS (indicator_power_notifier_parent_class)->dispose (o);
+}
+
+static void
+my_finalize (GObject * o G_GNUC_UNUSED)
+{
+  /* FIXME: This is an awkward place to put this. 
+     Ordinarily something like this would go in main(), but we need libnotify
+     to clean itself up before shutting down the bus in the unit tests as well. */
+  if (!--instance_count)
+    notify_uninit();
+}
+
+/***
+****  Instantiation
+***/
+
+static void
+indicator_power_notifier_init (IndicatorPowerNotifier * self)
+{
+  priv_t * const p = get_priv (self);
+
+  /* bind the read-only properties so they'll get pushed to the bus */
+
+  p->dbus_battery = dbus_battery_skeleton_new ();
+
+  p->power_level = POWER_LEVEL_OK;
+
+  if (!instance_count++)
+    {
+      if (!notify_init("indicator-power-service"))
+        {
+          g_critical("Unable to initialize libnotify! Notifications might not be shown.");
+        }
+    }
+}
+
+static void
+indicator_power_notifier_class_init (IndicatorPowerNotifierClass * klass)
+{
+  GObjectClass * object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = my_dispose;
+  object_class->finalize = my_finalize;
+  object_class->get_property = my_get_property;
+  object_class->set_property = my_set_property;
+
+  properties[PROP_BATTERY] = g_param_spec_object (
+    PROP_BATTERY_NAME,
+    "Battery",
+    "The current battery",
+    G_TYPE_OBJECT,
+    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, LAST_PROP, properties);
+}
+
+/***
+****  Public API
+***/
+
+IndicatorPowerNotifier *
+indicator_power_notifier_new (void)
+{
+  GObject * o = g_object_new (INDICATOR_TYPE_POWER_NOTIFIER, NULL);
+
+  return INDICATOR_POWER_NOTIFIER (o);
+}
+
+void
+indicator_power_notifier_set_battery (IndicatorPowerNotifier * self,
+                                      IndicatorPowerDevice   * battery)
+{
+  priv_t * p;
+
+  g_return_if_fail(INDICATOR_IS_POWER_NOTIFIER(self));
+  g_return_if_fail((battery == NULL) || INDICATOR_IS_POWER_DEVICE(battery));
+  g_return_if_fail((battery == NULL) || (indicator_power_device_get_kind(battery) == UP_DEVICE_KIND_BATTERY));
+
+  p = get_priv (self);
+
+  if (p->battery == battery)
+    return;
+
+  if (p->battery != NULL)
+    {
+      g_signal_handlers_disconnect_by_data (p->battery, self);
+      g_clear_object (&p->battery);
+      dbus_battery_set_power_level (p->dbus_battery, power_level_to_dbus_string (POWER_LEVEL_OK));
+      notification_clear (self);
+    }
+
+  if (battery != NULL)
+    {
+      p->battery = g_object_ref (battery);
+      g_signal_connect_swapped (p->battery, "notify::"INDICATOR_POWER_DEVICE_PERCENTAGE,
+                                G_CALLBACK(on_battery_property_changed), self);
+      g_signal_connect_swapped (p->battery, "notify::"INDICATOR_POWER_DEVICE_STATE,
+                                G_CALLBACK(on_battery_property_changed), self);
+      on_battery_property_changed (self);
+    }
+}
+
+void
+indicator_power_notifier_set_bus (IndicatorPowerNotifier * self,
+                                  GDBusConnection        * bus)
+{
+  priv_t * p;
+  GDBusInterfaceSkeleton * skel;
+
+  g_return_if_fail(INDICATOR_IS_POWER_NOTIFIER(self));
+  g_return_if_fail((bus == NULL) || G_IS_DBUS_CONNECTION(bus));
+
+  p = get_priv (self);
+
+  if (p->bus == bus)
+    return;
+
+  skel = G_DBUS_INTERFACE_SKELETON(p->dbus_battery);
+
+  if (p->bus != NULL)
+    {
+      if (skel != NULL)
+        g_dbus_interface_skeleton_unexport (skel);
+
+      g_clear_object (&p->bus);
+    }
+
+  if (bus != NULL)
+    {
+      GError * error;
+
+      p->bus = g_object_ref (bus);
+
+      error = NULL;
+      if (!g_dbus_interface_skeleton_export(skel,
+                                            bus,
+                                            BUS_PATH"/Battery",
+                                            &error))
+        {
+          g_warning ("Unable to export LowBattery properties: %s", error->message);
+          g_error_free (error);
+        }
+    }
+}
+
+const char *
+indicator_power_notifier_get_power_level (IndicatorPowerDevice * battery)
+{
+  return power_level_to_dbus_string (get_battery_power_level (battery));
+}
diff --git a/src/notifier.h b/src/notifier.h
new file mode 100644
index 0000000..18e25d7
--- /dev/null
+++ b/src/notifier.h
@@ -0,0 +1,74 @@
+/*
+ * 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>
+ */
+
+#ifndef __INDICATOR_POWER_NOTIFIER_H__
+#define __INDICATOR_POWER_NOTIFIER_H__
+
+#include <gio/gio.h>
+
+#include "device.h"
+
+G_BEGIN_DECLS
+
+/* standard GObject macros */
+#define INDICATOR_POWER_NOTIFIER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), INDICATOR_TYPE_POWER_NOTIFIER, IndicatorPowerNotifier))
+#define INDICATOR_TYPE_POWER_NOTIFIER         (indicator_power_notifier_get_type())
+#define INDICATOR_IS_POWER_NOTIFIER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), INDICATOR_TYPE_POWER_NOTIFIER))
+#define INDICATOR_POWER_NOTIFIER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),  INDICATOR_TYPE_POWER_NOTIFIER, IndicatorPowerNotifierClass))
+
+typedef struct _IndicatorPowerNotifier         IndicatorPowerNotifier;
+typedef struct _IndicatorPowerNotifierClass    IndicatorPowerNotifierClass;
+
+/**
+ * The Indicator Power Notifier.
+ */
+struct _IndicatorPowerNotifier
+{
+  /*< private >*/
+  GObject parent;
+};
+
+struct _IndicatorPowerNotifierClass
+{
+  GObjectClass parent_class;
+};
+
+/***
+****
+***/
+
+GType indicator_power_notifier_get_type (void);
+
+IndicatorPowerNotifier * indicator_power_notifier_new (void);
+
+void indicator_power_notifier_set_bus (IndicatorPowerNotifier  * self,
+                                       GDBusConnection         * connection);
+
+void indicator_power_notifier_set_battery (IndicatorPowerNotifier  * self,
+                                           IndicatorPowerDevice    * battery);
+
+#define POWER_LEVEL_STR_OK "ok"
+#define POWER_LEVEL_STR_LOW "low"
+#define POWER_LEVEL_STR_VERY_LOW "very_low"
+#define POWER_LEVEL_STR_CRITICAL "critical"
+const char * indicator_power_notifier_get_power_level (IndicatorPowerDevice * battery);
+
+G_END_DECLS
+
+#endif /* __INDICATOR_POWER_NOTIFIER_H__ */
diff --git a/src/service.c b/src/service.c
index 7478d0f..0cd448b 100644
--- a/src/service.c
+++ b/src/service.c
@@ -22,8 +22,10 @@
 #include <gio/gio.h>
 #include <url-dispatcher.h>
 
+#include "dbus-shared.h"
 #include "device.h"
 #include "device-provider.h"
+#include "notifier.h"
 #include "ib-brightness-control.h"
 #include "ib-brightness-uscreen-control.h"
 #include "service.h"
@@ -120,6 +122,7 @@ struct _IndicatorPowerServicePrivate
   GList * devices; /* IndicatorPowerDevice */
 
   IndicatorPowerDeviceProvider * device_provider;
+  IndicatorPowerNotifier * notifier;
 };
 
 typedef IndicatorPowerServicePrivate priv_t;
@@ -592,14 +595,14 @@ rebuild_now (IndicatorPowerService * self, guint sections)
   struct ProfileMenuInfo * desktop = &p->menus[PROFILE_DESKTOP];
   struct ProfileMenuInfo * greeter = &p->menus[PROFILE_DESKTOP_GREETER];
 
-  if (p->conn == NULL) /* we haven't built the menus yet */
-    return;
-
   if (sections & SECTION_HEADER)
     {
       g_simple_action_set_state (p->header_action, create_header_state (self));
     }
 
+  if (p->conn == NULL) /* we haven't built the menus yet */
+    return;
+
   if (sections & SECTION_DEVICES)
     {
       rebuild_section (desktop->submenu, 0, create_desktop_devices_section (self, PROFILE_DESKTOP));
@@ -821,6 +824,9 @@ on_bus_acquired (GDBusConnection * connection,
 
   p->conn = g_object_ref (G_OBJECT (connection));
 
+  /* export the battery properties */
+  indicator_power_notifier_set_bus (p->notifier, connection);
+
   /* export the actions */
   if ((id = g_dbus_connection_export_action_group (connection,
                                                    BUS_PATH,
@@ -920,6 +926,12 @@ on_devices_changed (IndicatorPowerService * self)
   g_clear_object (&p->primary_device);
   p->primary_device = indicator_power_service_choose_primary_device (p->devices);
 
+  /* update the notifier's battery */
+  if ((p->primary_device != NULL) && (indicator_power_device_get_kind(p->primary_device) == UP_DEVICE_KIND_BATTERY))
+    indicator_power_notifier_set_battery (p->notifier, p->primary_device);
+  else
+    indicator_power_notifier_set_battery (p->notifier, NULL);
+
   /* update the battery-level action's state */
   if (p->primary_device == NULL)
     battery_level = 0;
@@ -1001,6 +1013,7 @@ my_dispose (GObject * o)
       g_clear_object (&p->settings);
     }
 
+  g_clear_object (&p->notifier);
   g_clear_object (&p->brightness_action);
   g_clear_object (&p->battery_level_action);
   g_clear_object (&p->header_action);
@@ -1035,6 +1048,8 @@ indicator_power_service_init (IndicatorPowerService * self)
 
   p->settings = g_settings_new ("com.canonical.indicator.power");
 
+  p->notifier = indicator_power_notifier_new ();
+
   uscreen_proxy = uscreen_get_proxy(&brightness_params);
   if (uscreen_proxy != NULL)
     {