--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pui-backend.c	Sun May 20 11:32:57 2018 +0200
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2018 Guido Berhoerster <guido+pui@berhoerster.name>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <packagekit-glib2/packagekit.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <utime.h>
+
+#include "pui-common.h"
+#include "pui-backend.h"
+#include "pui-get-updates.h"
+
+struct _PuiBackend {
+	GObject		parent_instance;
+	PkControl	*pk_control;
+	GCancellable	*cancellable;
+	gint64		last_check;
+	PkNetworkEnum	network_state;
+	guint		periodic_check_id;
+	guint		refresh_interval;
+	guint		important_updates;
+	guint		normal_updates;
+};
+
+static void	pui_backend_async_initable_iface_init(gpointer, gpointer);
+
+G_DEFINE_TYPE_WITH_CODE(PuiBackend, pui_backend, G_TYPE_OBJECT,
+    G_IMPLEMENT_INTERFACE(G_TYPE_ASYNC_INITABLE,
+    pui_backend_async_initable_iface_init))
+
+enum {
+    STATE_CHANGED,
+    RESTART_REQUIRED,
+    SIGNAL_LAST
+};
+
+enum {
+    PROP_0,
+    PROP_IMPORTANT_UPDATES,
+    PROP_NORMAL_UPDATES,
+    PROP_REFRESH_INTERVAL,
+    PROP_LAST
+};
+
+static guint	signals[SIGNAL_LAST] = { 0 };
+static GParamSpec *properties[PROP_LAST] = { NULL };
+
+static gboolean	periodic_check(gpointer);
+
+GQuark
+pui_backend_error_quark(void)
+{
+	return (g_quark_from_static_string("pui-backend-error-quark"));
+}
+
+static void
+process_pk_package(gpointer data, gpointer user_data)
+{
+	PkPackage	*package = data;
+	PuiBackend	*self = user_data;
+	PkInfoEnum	type_info = pk_package_get_info(package);
+
+	switch (type_info) {
+	case PK_INFO_ENUM_LOW:		/* FALLTHROUGH */
+	case PK_INFO_ENUM_ENHANCEMENT:	/* FALLTHROUGH */
+	case PK_INFO_ENUM_NORMAL:
+		self->normal_updates++;
+		break;
+	case PK_INFO_ENUM_BUGFIX:	/* FALLTHROUGH */
+	case PK_INFO_ENUM_IMPORTANT:	/* FALLTHROUGH */
+	case PK_INFO_ENUM_SECURITY:
+		self->important_updates++;
+		break;
+	default:
+		break;
+	}
+}
+
+static void
+on_get_updates_finished(GObject *source_object, GAsyncResult *async_result,
+    gpointer user_data)
+{
+	PuiBackend	*self = user_data;
+	GPtrArray	*package_list = NULL;
+	GError		*error = NULL;
+	guint		prev_normal_updates = self->normal_updates;
+	guint		prev_important_updates = self->important_updates;
+
+	package_list = pui_get_updates_finish(async_result, &error);
+	if (package_list == NULL) {
+		if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
+		    g_error_matches(error, PUI_GET_UPDATES_ERROR,
+		    PUI_GET_UPDATES_ERROR_CANCELLED)) {
+			/* cancelled */
+			g_debug("cancelled checking for updates");
+		} else {
+			g_warning("failed to check for updates: %s",
+			    error->message);
+		}
+		g_error_free(error);
+		goto out;
+	}
+
+	self->normal_updates = 0;
+	self->important_updates = 0;
+	g_ptr_array_foreach(package_list, process_pk_package, self);
+	g_debug("normal updates: %u, important updates: %u",
+	    self->normal_updates, self->important_updates);
+	if (self->normal_updates != prev_normal_updates) {
+		g_object_notify_by_pspec(G_OBJECT(self),
+		    properties[PROP_NORMAL_UPDATES]);
+	}
+	if (self->important_updates != prev_important_updates) {
+		g_object_notify_by_pspec(G_OBJECT(self),
+		    properties[PROP_IMPORTANT_UPDATES]);
+	}
+	if ((self->normal_updates != prev_normal_updates) ||
+	    (self->important_updates != prev_important_updates)) {
+		g_debug("emitting signal state-changed");
+		g_signal_emit(self, signals[STATE_CHANGED], 0);
+	}
+
+	/* last successful check */
+	self->last_check = g_get_monotonic_time();
+
+out:
+	/* reschedule periodic check */
+	if (self->network_state != PK_NETWORK_ENUM_OFFLINE) {
+		self->periodic_check_id =
+		    g_timeout_add_seconds(PUI_CHECK_UPDATES_INTERVAL,
+		    periodic_check, self);
+	}
+
+	if (package_list != NULL) {
+		g_ptr_array_unref(package_list);
+	}
+}
+
+static gboolean
+periodic_check(gpointer user_data)
+{
+	PuiBackend	*self = user_data;
+
+	g_debug("running periodic check");
+
+	pui_get_updates_async(self->pk_control, self->refresh_interval,
+	    self->cancellable, on_get_updates_finished, self);
+
+	/* next periodic check will be scheduled after completion */
+	self->periodic_check_id = 0;
+
+	return (G_SOURCE_REMOVE);
+}
+
+static void
+pui_backend_set_property(GObject *object, guint property_id,
+    const GValue *value, GParamSpec *pspec)
+{
+	PuiBackend	*self = PUI_BACKEND(object);
+
+	switch (property_id) {
+	case PROP_REFRESH_INTERVAL:
+		self->refresh_interval = g_value_get_uint(value);
+		g_debug("property \"refresh-interval\" set to %u",
+		    self->refresh_interval);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+pui_backend_get_property(GObject *object, guint property_id, GValue *value,
+    GParamSpec *pspec)
+{
+	PuiBackend	*self = PUI_BACKEND(object);
+
+	switch (property_id) {
+	case PROP_IMPORTANT_UPDATES:
+		g_value_set_uint(value, self->important_updates);
+		break;
+	case PROP_NORMAL_UPDATES:
+		g_value_set_uint(value, self->normal_updates);
+		break;
+	case PROP_REFRESH_INTERVAL:
+		g_value_set_uint(value, self->refresh_interval);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+pui_backend_dispose(GObject *object)
+{
+	PuiBackend	*self = PUI_BACKEND(object);
+
+	if (self->periodic_check_id != 0) {
+		g_source_remove(self->periodic_check_id);
+		self->periodic_check_id = 0;
+	}
+
+	if (self->cancellable != NULL) {
+		g_cancellable_cancel(self->cancellable);
+		g_clear_object(&self->cancellable);
+	}
+
+	if (self->pk_control != NULL) {
+		g_clear_object(&self->pk_control);
+	}
+
+	G_OBJECT_CLASS(pui_backend_parent_class)->dispose(object);
+}
+
+static void
+pui_backend_class_init(PuiBackendClass *klass)
+{
+	GObjectClass	*object_class = G_OBJECT_CLASS(klass);
+
+	object_class->set_property = pui_backend_set_property;
+	object_class->get_property = pui_backend_get_property;
+	object_class->dispose = pui_backend_dispose;
+
+	properties[PROP_IMPORTANT_UPDATES] =
+	    g_param_spec_uint("important-updates", "Important updates",
+	    "Number of available important updates", 0, G_MAXUINT, 0,
+	    G_PARAM_READABLE);
+
+	properties[PROP_NORMAL_UPDATES] =
+	    g_param_spec_uint("normal-updates", "Normal updates",
+	    "Number of available normal updates", 0, G_MAXUINT, 0,
+	    G_PARAM_READABLE);
+
+	properties[PROP_REFRESH_INTERVAL] =
+	    g_param_spec_uint("refresh-interval", "Refresh interval",
+	    "Interval in seconds for refreshing the package cache", 0,
+	    G_MAXUINT, PUI_DEFAULT_REFRESH_INTERVAL, G_PARAM_READWRITE);
+
+	g_object_class_install_properties(object_class, PROP_LAST, properties);
+
+	signals[STATE_CHANGED] = g_signal_new("state-changed",
+	    G_TYPE_FROM_CLASS(object_class),
+	    G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS, 0,
+	    NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+	signals[RESTART_REQUIRED] = g_signal_new("restart-required",
+	    G_TYPE_FROM_CLASS(object_class),
+	    G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS, 0,
+	    NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+static void
+pui_backend_init(PuiBackend *self)
+{
+	self->cancellable = g_cancellable_new();
+	self->pk_control = pk_control_new();
+}
+
+static void
+on_get_properties_finished(GObject *object, GAsyncResult *result,
+    gpointer user_data)
+{
+	PkControl	*control = PK_CONTROL(object);
+	PuiBackend	*self;
+	GTask		*task = user_data;
+	GError		*error = NULL;
+	gchar		*backend_name = NULL;
+	PkBitfield	roles = 0;
+	gchar		*roles_str = NULL;
+
+	self = g_task_get_task_data(task);
+
+	if (!pk_control_get_properties_finish(control, result, &error)) {
+		g_task_return_error(task, error);
+		goto out;
+	}
+
+	/* check whether the backend supports GetUpdates */
+	g_object_get(control, "backend-name", &backend_name, "roles", &roles,
+	    "network-state", &self->network_state, NULL);
+	g_debug("backend: %s", backend_name);
+	roles_str = pk_role_bitfield_to_string(roles);
+	g_debug("roles: %s", roles_str);
+	g_debug("network-state: %s",
+	    pk_network_enum_to_string(self->network_state));
+	if (!pk_bitfield_contain(roles, PK_ROLE_ENUM_GET_UPDATES)) {
+		error = g_error_new(PUI_BACKEND_ERROR,
+		    PUI_BACKEND_ERROR_GET_UPDATES_NOT_IMPLEMENTED,
+		    "Getting updates is not implemented in the %s PackageKit "
+		    "backend", backend_name);
+		g_task_return_error(task, error);
+		goto out;
+	}
+
+	g_task_return_boolean(task, TRUE);
+out:
+	g_free(roles_str);
+	g_free(backend_name);
+	g_object_unref(task);
+}
+
+static void
+on_notify_network_state(PkControl *pk_control, GParamSpec *pspec,
+    gpointer user_data)
+{
+	PuiBackend	*self = user_data;
+	PkNetworkEnum	network_state;
+	guint		elapsed_time;
+	guint		remaining_time;
+
+	g_object_get(pk_control, "network-state", &network_state, NULL);
+	g_debug("network state changed: %s",
+	    pk_network_enum_to_string(network_state));
+	if ((self->network_state == PK_NETWORK_ENUM_OFFLINE) &&
+	    (network_state != PK_NETWORK_ENUM_OFFLINE)) {
+		/* schedule periodic checks when coming back online */
+		elapsed_time = (g_get_monotonic_time() - self->last_check) /
+		    G_USEC_PER_SEC;
+		/*
+		 * if more time that the check interval has passed since the
+		 * last check, schedule a check after a short delay, otherwise
+		 * wait until the interval has passed
+		 */
+		remaining_time = (elapsed_time < PUI_CHECK_UPDATES_INTERVAL) ?
+		    PUI_CHECK_UPDATES_INTERVAL - elapsed_time :
+		    PUI_STARTUP_DELAY;
+		self->periodic_check_id = g_timeout_add_seconds(remaining_time,
+		    periodic_check, self);
+	} else if ((self->network_state != PK_NETWORK_ENUM_OFFLINE) &&
+	    (network_state == PK_NETWORK_ENUM_OFFLINE)) {
+		/* cancel periodic checks while offline */
+		if (self->periodic_check_id != 0) {
+			g_source_remove(self->periodic_check_id);
+		}
+	}
+	self->network_state = network_state;
+}
+
+static void
+on_updates_changed(PkControl *control, gpointer user_data)
+{
+	PuiBackend	*self = user_data;
+
+	/*
+	 * schedule a check after a short delay so that a rapid succession of
+	 * signals is coalesced
+	 */
+	if (self->network_state != PK_NETWORK_ENUM_OFFLINE) {
+		if (self->periodic_check_id != 0) {
+			g_source_remove(self->periodic_check_id);
+		}
+		self->periodic_check_id =
+		    g_timeout_add_seconds(PUI_STARTUP_DELAY, periodic_check,
+		    self);
+	}
+}
+
+static void
+on_restart_schedule(PkControl *control, gpointer user_data)
+{
+	PuiBackend	*self = user_data;
+
+	g_debug("emitting signal restart-required");
+	g_signal_emit(self, signals[RESTART_REQUIRED], 0);
+}
+
+static void
+pui_backend_init_async(GAsyncInitable *initable, int io_priority,
+    GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
+{
+	PuiBackend	*self = PUI_BACKEND(initable);
+	GTask		*task;
+
+	task = g_task_new(G_OBJECT(initable), cancellable, callback, user_data);
+	g_task_set_priority(task, io_priority);
+	g_task_set_task_data(task, g_object_ref(self),
+	    (GDestroyNotify)g_object_unref);
+
+	pk_control_get_properties_async(self->pk_control, cancellable,
+	    on_get_properties_finished, task);
+}
+
+static gboolean
+pui_backend_init_finish(GAsyncInitable *initable, GAsyncResult *result,
+    GError **errorp)
+{
+	PuiBackend	*self = PUI_BACKEND(initable);
+	GTask		*task = G_TASK(result);
+
+	if (!g_task_propagate_boolean(task, errorp)) {
+		return (FALSE);
+	}
+
+	/* get notification when the network state changes */
+	g_signal_connect(self->pk_control, "notify::network-state",
+	    G_CALLBACK(on_notify_network_state), self);
+	/* get notifications when the available package updates change */
+	g_signal_connect(self->pk_control, "updates-changed",
+	    G_CALLBACK(on_updates_changed), self);
+	/* get notifications when an application restart is required */
+	g_signal_connect(self->pk_control, "restart-schedule",
+	    G_CALLBACK(on_restart_schedule), self);
+	/* schedule first check after a small delay */
+	self->periodic_check_id = g_timeout_add_seconds(PUI_STARTUP_DELAY,
+	    periodic_check, self);
+
+	return (TRUE);
+}
+
+static void
+pui_backend_async_initable_iface_init(gpointer g_iface, gpointer iface_data)
+{
+	GAsyncInitableIface	*iface = g_iface;
+
+	iface->init_async = pui_backend_init_async;
+	iface->init_finish = pui_backend_init_finish;
+}
+
+void
+pui_backend_new_async(GCancellable *cancellable, GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+	g_async_initable_new_async(PUI_TYPE_BACKEND, G_PRIORITY_DEFAULT,
+	    cancellable, callback, user_data, NULL);
+}
+
+PuiBackend *
+pui_backend_new_finish(GAsyncResult *result, GError **errorp)
+{
+	GObject	*object;
+	GObject	*source_object;
+
+	source_object = g_async_result_get_source_object(result);
+	object = g_async_initable_new_finish(G_ASYNC_INITABLE(source_object),
+	    result, errorp);
+	g_object_unref(source_object);
+
+	return ((object != NULL) ? PUI_BACKEND(object) : NULL);
+}