~ubuntu-core-dev/update-notifier/ubuntu

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <libnotify/notify.h>

#include <dbus/dbus-glib.h>

#include <dbus/dbus.h>

#include "update-notifier.h"

#include "update.h"

static GtkBuilder *builder;

static gboolean

show_notification (TrayApplet *ta)

{

	NotifyNotification *n;

	GdkRectangle area;

	gtk_status_icon_get_geometry(ta->tray_icon, NULL, &area, NULL);

	// no usefull coordiante yet, do another timeout

	if(area.x <= 0 || area.y <= 0 || area.width <= 0 || area.height <= 0)

	   return TRUE;

	// only show once the icon is realy availabe

	if(!gtk_status_icon_get_visible(ta->tray_icon))

	   return TRUE;

	/* Create and show the notification */

	n = notify_notification_new_with_status_icon(

				     _("System restart required"),

				     _("To complete the update of your system, "

				       "please restart it.\n\n"

				       "Click on the notification icon for "

				       "details."),

				     GTK_STOCK_DIALOG_WARNING,

				     ta->tray_icon);

	notify_notification_set_timeout (n, 60000);

	notify_notification_show (n, NULL);

	g_object_set_data (G_OBJECT(ta->tray_icon), "notification", n);

	return FALSE;

}

static gboolean

gdm_action_reboot()

{

   DBusGConnection *connection;

   GError *error;

   DBusGProxy *proxy;

   error = NULL;

   connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

   if (connection == NULL) {

      g_error_free (error);

      return FALSE;

   }

  proxy = dbus_g_proxy_new_for_name (connection,

                                     "org.gnome.SessionManager",

				     "/org/gnome/SessionManager",

				     "org.gnome.SessionManager");

  if (proxy == NULL)

     return FALSE;

  error = NULL;

  if (!dbus_g_proxy_call (proxy, "RequestReboot", &error, 

			  G_TYPE_INVALID, G_TYPE_INVALID)) {

     g_error_free (error);

     return FALSE;

  }

  return TRUE;

}

static gboolean

ck_action_reboot()

{

   DBusGConnection *connection;

   GError *error;

   DBusGProxy *proxy;

   error = NULL;

   connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);

   if (connection == NULL) {

      g_error_free (error);

      return FALSE;

   }

  proxy = dbus_g_proxy_new_for_name (connection,

                                     "org.freedesktop.ConsoleKit",

                                     "/org/freedesktop/ConsoleKit/Manager",

                                     "org.freedesktop.ConsoleKit.Manager");

  if (proxy == NULL)

     return FALSE;

  error = NULL;

  if (!dbus_g_proxy_call (proxy, "Restart", &error,

                          G_TYPE_INVALID, G_TYPE_INVALID)) {

     g_error_free (error);

     return FALSE;

  }

  return TRUE;

}

static void

request_reboot (void)

{

   if(!gdm_action_reboot() && !ck_action_reboot()) {

      const char *fmt, *msg, *details;

      fmt = "<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s\n";

      msg = _("Reboot failed");

      details = _("Failed to request reboot, please shutdown manually");

      GtkWidget *dlg = gtk_message_dialog_new_with_markup(NULL, 0,

							  GTK_MESSAGE_ERROR,

							  GTK_BUTTONS_CLOSE,

							  fmt, msg, details);

      gtk_dialog_run(GTK_DIALOG(dlg));

      gtk_widget_destroy(dlg);

   }

}

static void

ask_reboot_required(TrayApplet *ta, gboolean focus_on_map)

{

   GtkWidget *dia;

   dia = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_reboot"));

   gtk_window_set_focus_on_map(GTK_WINDOW(dia), focus_on_map);

   if (gtk_dialog_run (GTK_DIALOG(dia)) == GTK_RESPONSE_OK)

      request_reboot ();

   gtk_widget_hide (dia);

}

static gboolean

is_aptdaemon_on_the_system_bus ()

{

   DBusConnection *connection;

   DBusError *dbus_error = NULL;

   DBusMessage *message, *reply;

   const char *aptdaemon_bus_name = "org.debian.apt";

   gboolean res;

   connection = dbus_bus_get(DBUS_BUS_SYSTEM, dbus_error);

   if (dbus_error != NULL) {

      g_warning("failed to connect to the system bus");

      return FALSE;

   }

   message = dbus_message_new_method_call(DBUS_SERVICE_DBUS, 

                                          DBUS_PATH_DBUS,

                                          DBUS_INTERFACE_DBUS,

                                          "GetNameOwner");

   if (message == NULL) {

      g_warning ("failed to create dbus message");

      return FALSE;

   }

   dbus_message_append_args(message,

                            DBUS_TYPE_STRING, &aptdaemon_bus_name,

                            DBUS_TYPE_INVALID);

   reply = dbus_connection_send_with_reply_and_block(connection,

                                                     message,

                                                     -1,

                                                     dbus_error);

   dbus_message_unref(message);

   if (reply) {

      dbus_message_unref(reply);

      res = TRUE;

   } else {

      res =  FALSE;

   }

   g_debug("aptdaemon on bus: %i", res);

   return res;

}

static gboolean

aptdaemon_pending_transactions ()

{

   DBusGConnection *connection;

   GError *error;

   DBusGProxy *proxy;

   char *current = NULL;

   char **pending = NULL;

   if (!is_aptdaemon_on_the_system_bus())

      return FALSE;

   error = NULL;

   connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);

   if (connection == NULL) {

      g_debug ("Failed to open connection to bus: %s\n", error->message);

      g_error_free (error);

      return FALSE;

   }

  proxy = dbus_g_proxy_new_for_name (connection,

                                     "org.debian.apt",

				     "/org/debian/apt",

				     "org.debian.apt");

  error = NULL;

  if (!dbus_g_proxy_call (proxy, "GetActiveTransactions", &error, 

			  G_TYPE_INVALID,

                          G_TYPE_STRING, &current, 

			  G_TYPE_STRV, &pending,

			  G_TYPE_INVALID)) {

     g_debug ("error during dbus call: %s\n", error->message);

     g_error_free (error);

     g_object_unref (proxy);

     return FALSE;

  }

  gboolean has_pending = FALSE;

  if ((current && strcmp(current,"") != 0) || g_strv_length(pending) > 0)

     has_pending = TRUE;

  g_object_unref (proxy);

  g_free (current);

  g_strfreev (pending);

  return has_pending;

}

static void

do_reboot_check (TrayApplet *ta)

{

	struct stat statbuf;

	// if we are not supposed to show the reboot notification

	// just skip it 

	if(gconf_client_get_bool((GConfClient*) ta->user_data,

				 GCONF_KEY_HIDE_REBOOT, NULL))

	   return;

	// no auto-open of this dialog 

	if(gconf_client_get_bool((GConfClient*) ta->user_data,

				 GCONF_KEY_AUTO_LAUNCH, NULL)) {

           g_debug ("Skipping reboot required");

	   return;

	}

	/* If the file doesn't exist, we don't need to reboot */

	if (stat (REBOOT_FILE, &statbuf)) {

		NotifyNotification *n;

		gtk_status_icon_set_visible (ta->tray_icon, FALSE);

		/* Hide any notification popup */

		n = g_object_get_data (G_OBJECT(ta->tray_icon), "notification");

		if (n)

			notify_notification_close (n, NULL);

		g_object_set_data (G_OBJECT(ta->tray_icon), "notification", NULL);

		return;

	}

	/* Skip the rest if the icon is already visible */

	if (gtk_status_icon_get_visible (ta->tray_icon))

	   return;

	gtk_status_icon_set_tooltip (ta->tray_icon,  

				     _("System restart required"));

	gtk_status_icon_set_visible (ta->tray_icon, TRUE);

	/* Check whether the user doesn't like notifications */

	if (gconf_client_get_bool ((GConfClient*) ta->user_data,

				   GCONF_KEY_NO_UPDATE_NOTIFICATIONS, NULL))

		return;

	/* Show the notification, after a delay so it doesn't look ugly

	 * if we've just logged in */

	g_timeout_add(5000, (GSourceFunc)(show_notification), ta);

}

gboolean

reboot_check (TrayApplet *ta)

{

   if (aptdaemon_pending_transactions())

      g_timeout_add_seconds (5, (GSourceFunc)reboot_check, ta);

   else

      do_reboot_check(ta);

   return FALSE;

}

static gboolean

button_release_cb (GtkWidget *widget,

		   TrayApplet *ta)

{

   ask_reboot_required(ta, TRUE);

   return TRUE;

}

void

reboot_tray_icon_init (TrayApplet *ta)

{

	GtkWidget *widget;

	GError* error = NULL;

	builder = gtk_builder_new ();

	if (!gtk_builder_add_from_file (builder, UIDIR"reboot-dialog.ui", &error)) {

		g_warning ("Couldn't load builder file: %s", error->message);

		g_error_free (error);

	}

	widget = GTK_WIDGET (gtk_builder_get_object (builder, "image"));

	GtkIconTheme* icon_theme = gtk_icon_theme_get_default();

	GdkPixbuf *pixbuf = gtk_icon_theme_load_icon (icon_theme, "un-reboot",

						      48, 0,NULL);

	gtk_status_icon_set_from_pixbuf (ta->tray_icon, pixbuf);

	ta->user_data = gconf_client_get_default();

        g_signal_connect (G_OBJECT(ta->tray_icon),

			  "activate",

			  G_CALLBACK (button_release_cb),

			  ta);

	gtk_image_set_from_pixbuf(GTK_IMAGE(widget), pixbuf);

	/* Check for updates for the first time */

	reboot_check (ta);

}