# HG changeset patch # User Guido Berhoerster # Date 1526808777 -7200 # Node ID 6884bb8130cacb54dc936da6c100d880e2b59a2c Initial revision diff -r 000000000000 -r 6884bb8130ca Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Makefile Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,204 @@ +# +# Copyright (C) 2018 Guido Berhoerster +# +# 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. +# + +PACKAGE = package-update-indicator +APPLICATION_ID = org.guido-berhoerster.code.package-update-indicator +VERSION = 1 +DISTNAME = $(PACKAGE)-$(VERSION) +AUTHOR = Guido Berhoerster +BUG_ADDRESS = guido+pui@berhoerster.name + +# gcc, clang, icc, Sun/Solaris Studio +CC := $(CC) -std=c99 +COMPILE.c = $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(XCPPFLAGS) $(TARGET_ARCH) -c +# gcc, clang, icc +MAKEDEPEND.c = $(CC) -MM $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(XCPPFLAGS) +# Sun/Solaris Studio +#MAKEDEPEND.c = $(CC) -xM1 $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(XCPPFLAGS) +# X makedepend +#MAKEDEPEND.c = makedepend -f- -Y -- $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(XCPPFLAGS) -- +LINK.c = $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(XCPPFLAGS) $(LDFLAGS) $(XLDFLAGS) $(TARGET_ARCH) +LINK.o = $(CC) $(LDFLAGS) $(XLDFLAGS) $(TARGET_ARCH) +CP := cp +INSTALL := install +INSTALL.exec := $(INSTALL) -D -m 0755 +INSTALL.data := $(INSTALL) -D -m 0644 +INSTALL.link := $(CP) -f -P +PAX := pax +GZIP := gzip +SED := sed +GLIB_COMPILE_SCHEMAS := $(shell pkg-config --variable=glib_compile_schemas gio-2.0) +XSLTPROC := xsltproc +DOCBOOK5_MANPAGES_STYLESHEET = http://docbook.sourceforge.net/release/xsl-ns/current/manpages/docbook.xsl +DOCBOOK5_MANPAGES_FLAGS = --stringparam man.authors.section.enabled 0 \ + --stringparam man.copyright.section.enabled 0 +MSGFMT = msgfmt +MSGMERGE = msgmerge +XGETTEXT = xgettext +XGETTEXT_OPTIONS = --copyright-holder "$(AUTHOR)" \ + --package-name '$(PACKAGE)' \ + --package-version '$(VERSION)' \ + --msgid-bugs-address '$(BUG_ADDRESS)' \ + --default-domain '$(PACKAGE)' \ + --from-code UTF-8 \ + --keyword=_ \ + --keyword=N_ \ + --keyword=C_:1c,2 \ + --keyword=NC_:1c,2 \ + --keyword=g_dngettext:2,3 \ + --add-comments + +define generate-manpage-rule = +%.$1: %.$(addsuffix .xml,$1) docbook-update-source-data.xsl + $$(XSLTPROC) \ + --xinclude \ + --stringparam package $$(PACKAGE) \ + --stringparam version $$(VERSION) \ + docbook-update-source-data.xsl $$< | \ + $$(XSLTPROC) \ + --xinclude \ + --output $$@ \ + $$(DOCBOOK5_MANPAGES_FLAGS) \ + $$(DOCBOOK5_MANPAGES_STYLESHEET) \ + - +endef + +DESTDIR ?= +prefix ?= /usr/local +bindir ?= $(prefix)/bin +datadir ?= $(prefix)/share +mandir ?= $(datadir)/man +localedir ?= $(datadir)/locale +sysconfdir ?= /etc +xdgautostartdir ?= $(sysconfdir)/xdg/autostart + +OS_NAME := $(shell uname -s) +OS_RELEASE := $(shell uname -r) + +OBJS = package-update-indicator.o \ + pui-application.o \ + pui-backend.o \ + pui-get-updates.o \ + pui-types.o + +GSETTINGS_SCHEMAS = $(APPLICATION_ID).gschema.xml + +AUTOSTART_FILES = $(APPLICATION_ID).desktop + +LINGUAS := $(shell sed 's/\#.*//' po/LINGUAS) +MOFILES := $(patsubst %,po/%.mo,$(LINGUAS)) +POTFILES_IN := $(shell sed 's/\#.*//' po/POTFILES.in) +POTFILE = po/$(PACKAGE).pot + +MANPAGES = $(PACKAGE).1 + +.DEFAULT_TARGET = all + +.PHONY: all pot update-po clean clobber dist install + +all: $(PACKAGE) $(AUTOSTART_FILES) $(MOFILES) $(MANPAGES) + +$(PACKAGE): XCPPFLAGS = -DPACKAGE=\"$(PACKAGE)\" \ + -DAPPLICATION_ID=\"$(APPLICATION_ID)\" \ + -DVERSION=\"$(VERSION)\" \ + -DG_LOG_DOMAIN=\"$(PACKAGE)\" \ + -DPACKAGE_LOCALE_DIR="\"$(localedir)\"" \ + -DGETTEXT_PACKAGE=\"$(PACKAGE)\" \ + -DI_KNOW_THE_PACKAGEKIT_GLIB2_API_IS_SUBJECT_TO_CHANGE +$(PACKAGE): XCFLAGS = $(shell pkg-config --cflags gtk+-3.0 \ + appindicator3-0.1 packagekit-glib2) +$(PACKAGE): LDLIBS = $(shell pkg-config --libs gtk+-3.0 \ + appindicator3-0.1 packagekit-glib2) + +ifneq ($(findstring $(OS_NAME),FreeBSD DragonFly OpenBSD),) + $(PACKAGE): XCPPFLAGS += -I/usr/local/include + $(PACKAGE): XLDFLAGS += -L/usr/local/lib +else ifeq ($(OS_NAME),NetBSD) + $(PACKAGE): XCPPFLAGS += -I/usr/pkg/include + $(PACKAGE): XLDFLAGS += -L/usr/pkg/lib +endif +ifeq ($(findstring $(OS_NAME),FreeBSD DragonFly NetBSD OpenBSD),) + $(PACKAGE): XCPPFLAGS += -D_XOPEN_SOURCE=600 +endif + +$(PACKAGE): $(OBJS) + $(LINK.o) $^ $(LDLIBS) -o $@ + +$(POTFILE): po/POTFILES.in $(POTFILES_IN) + $(XGETTEXT) $(XGETTEXT_OPTIONS) --files-from $< --output $@ + +pot: $(POTFILE) + +update-po: $(POTFILE) + for pofile in $(patsubst %.mo,%.po,$(MOFILES)); do \ + $(MSGMERGE) --update --backup off $$pofile $<; \ + done + +%.mo: %.po + $(MSGFMT) --output $@ $< + +%.desktop: %.desktop.in + $(MSGFMT) --desktop --template $< -d po --output $@ + +$(foreach section,1 2 3 4 5 6 7 8 9,$(eval $(call generate-manpage-rule,$(section)))) + +%.o: %.c + $(MAKEDEPEND.c) $< | $(SED) -f deps.sed >$*.d + $(COMPILE.c) -o $@ $< + +install: all + $(INSTALL.exec) $(PACKAGE) "$(DESTDIR)$(bindir)/$(PACKAGE)" + for schema in $(GSETTINGS_SCHEMAS); do \ + $(INSTALL.data) $${schema} \ + $(DESTDIR)$(datadir)/glib-2.0/schemas/$${schema}; \ + done + [ -n "$(GSETTINGS_SCHEMAS)" ] && \ + $(GLIB_COMPILE_SCHEMAS) $(datadir)/glib-2.0/schemas + for desktop_file in $(AUTOSTART_FILES); do \ + $(INSTALL.data) $${desktop_file} \ + $(DESTDIR)$(xdgautostartdir)/$${desktop_file}; \ + done + for lang in $(LINGUAS); do \ + $(INSTALL.data) po/$${lang}.mo \ + $(DESTDIR)$(localedir)/$${lang}/LC_MESSAGES/$(PACKAGE).mo; \ + done + for manpage in $(MANPAGES); do \ + $(INSTALL.data) $${manpage} \ + "$(DESTDIR)$(mandir)/man$${manpage##*.}/$${manpage##*/}"; \ + done + +clean: + rm -f $(PACKAGE) $(OBJS) $(AUTOSTART_FILES) $(POTFILE) $(MOFILES) \ + $(MANPAGES) + +clobber: clean + rm -f $(patsubst %.o,%.d,$(OBJS)) + +dist: clobber + $(PAX) -w -x ustar -s ',.*/\..*,,' -s ',./[^/]*\.tar\.gz,,' \ + -s ',^\.$$,,' -s ',\./,$(DISTNAME)/,' . | \ + $(GZIP) > $(DISTNAME).tar.gz + +-include local.mk + +-include $(patsubst %.o,%.d,$(OBJS)) diff -r 000000000000 -r 6884bb8130ca README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/README Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,107 @@ +package-update-indicator +======================== + +Description +----------- + +The package-update-indicator utility regularly checks for software updates and +notifies the user about available updates using desktop notifications and +either a status notifier icon or a system tray icon. + +Build Instructions +------------------ + +package-update-indicator requires a POSIX:2004 compatible operating system, it +has been tested to work on Linux distributions. The following tools and +shared libraries are required to build package-update-indicator: + +- GNU make 3.81 or later +- pkg-config +- GNU gettext 0.19 or later +- GNU or BSD install +- GLib version 2.48 or later +- GTK+ version 3.18 or later +- libappindicator 12.10.0 or later +- PackageKit-glib2 0.8.17 or later +- the xsltproc tool from libxml2 + +Before building package-update-indicator check the commented macros in the +Makefile for any macros you may need to override depending on the used +toolchain and operating system. + +By default, all files will be installed under the "/usr/local" directory, a +different installation path prefix can be set via the `prefix` macro. In +addition, a second path prefix can be specified via the `DESTDIR` macro which +will be prepended to any path, incuding the `prefix` macro path prefix. In +contrast to `prefix`, the path specified via the `DESTDIR` macro will only be +prepended to paths during installation and not be used for constructing +internal paths. + +The following instructions assume that `make` is GNU make, on some platforms +it may be installed under a different name or a non-default path. In order to +start the build process run `make all`. After a successful build, run `make +install` to install the program, any associated data files and the +documentation. + +Previously built binaries, object files, generated data files and +documentation can be removed by running `make clean`, any additional, +generated files which are not removed by the `clean` target can be removed by +running `make clobber`. + +Contact +------- + +Please send any feedback, translations or bug reports via email to +. + +Bug Reports +----------- + +When sending bug reports, please always mention the exact version of +package-update-indicator with which the issue occurs as well as the version of +the operating system you are using and make sure that you provide sufficient +information to reproduce the issue and include any input, output, any error +messages. + +In case of build issues, please also specify the implementations and versions +of the tools and shared libraries used to build the program, in particular the +compiler. + +In case of crashes, please generate a stack trace with a suitable debugger +such as gdb, lldb, dbx, or debug after a crash has occurred either by +examining the resulting core file or by running the program from the debugger +and attach it to the bug report. In order to generate a meaningful stack +trace the program as well as any dynamically linked libraries need to be built +with debugging information, see the documentation of the used compiler for the +required compiler flags. If any of the dynamically linked shared libraries do +not contain debugging information, please either install debugging information +for these libraries using mechanisms provided by your operating system or +rebuild the libraries accordingly. Please refer to the documentation of the +debugger for detailed instructions on generating backtraces. + +License +------- + +Except otherwise noted, all files are Copyright (C) 2018 Guido Berhoerster and +distributed under the following license terms: + +Copyright (C) 2018 Guido Berhoerster + +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. diff -r 000000000000 -r 6884bb8130ca deps.sed --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/deps.sed Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,26 @@ +/^[^:]\{1,\}:.*\\$/{ + h + s/\([^:]\{1,\}:\).*/\1/ + x + s/[^:]\{1,\}:// +} +/\\$/,/^$/bgen +/\\$/,/[^\\]$/{ +:gen + s/[[:blank:]]*\\$// + s/^[[:blank:]]*// + G + s/\(.*\)\n\(.*\)/\2 \1/ +} +/^[^:]\{1,\}:[[:blank:]]*$/d +/^[^:]\{1,\}\.o:/{ + s/[[:blank:]]*[^[:blank:]]\{1,\}\.[cC][[:blank:]]*/ /g + s/[[:blank:]]*[^[:blank:]]\{1,\}\.[cC]$//g + s/[[:blank:]]*[^[:blank:]]\{1,\}\.cc[[:blank:]]*/ /g + s/[[:blank:]]*[^[:blank:]]\{1,\}\.cc$//g + s/[[:blank:]]*[^[:blank:]]\{1,\}\.cpp[[:blank:]]*/ /g + s/[[:blank:]]*[^[:blank:]]\{1,\}\.cpp$//g + /^[^:]\{1,\}:[[:blank:]]*$/d + s/^\([^:]\{1,\}\)\.o[[:blank:]]*:[[:blank:]]*\(.*\)/\1.d: $(wildcard \2)\ +&/ +} diff -r 000000000000 -r 6884bb8130ca docbook-update-source-data.xsl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/docbook-update-source-data.xsl Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r 6884bb8130ca org.guido-berhoerster.code.package-update-indicator.desktop.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.guido-berhoerster.code.package-update-indicator.desktop.in Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,10 @@ +[Desktop Entry] +Name=Package Update Indicator +GenericName=Package Update Indicator +Comment=Notify about available software updates +Icon=system-software-update +Exec=package-update-indicator +Terminal=false +Type=Application +Categories=Utility;GTK;TrayIcon; +NotShowIn=GNOME; diff -r 000000000000 -r 6884bb8130ca org.guido-berhoerster.code.package-update-indicator.gschema.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/org.guido-berhoerster.code.package-update-indicator.gschema.xml Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,17 @@ + + + + "" + Update command + Command for installing updates. + + + 86400 + Refresh interval + The interval in seconds for refreshing + metadata. + + + diff -r 000000000000 -r 6884bb8130ca package-update-indicator.1.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/package-update-indicator.1.xml Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,130 @@ + + + + + + + Guido + Berhoerster + + guido+pui@berhoerster.name + + + 25 May, 2018 + + + package-update-indicator + 1 + + + User Commands + + + package-update-indicator + notify about available software updates + + + + package-update-indicator + + + + + + + + + + + + + + + + + + + + Description + The package-update-indicator utility regularly + checks for software updates and notifies the user about available updates + using desktop notifications and either a status notifier icon or a system + tray icon. + + + Options + The following options are supported: + + + + + + + + + + Quit the running instance of + package-update-indicator. + + + + + + + + + + + Print the version number and exit. + + + + + + Exit Status + The following exit values are returned: + + + 0 + + Command successfully executed. + + + + 1 + + An unspecified error has occured. + + + + 2 + + Invalid command line options were specified. + + + + + diff -r 000000000000 -r 6884bb8130ca package-update-indicator.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/package-update-indicator.c Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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 +#include +#include +#include +#include +#include + +#include "pui-application.h" + +gboolean restart; + +int +main(int argc, char *argv[]) +{ + int status; + gchar *program; + PuiApplication *application; + + /* try to obtain the name of the executable for safe re-execution */ + if (argv[0] == NULL) { + g_error("unable to locate %s executable", PACKAGE); + } + if (argv[0][0] != '/') { + program = g_find_program_in_path(argv[0]); + if (program == NULL) { + g_error("unable to locate %s executable", PACKAGE); + } + argv[0] = program; + } + + bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); + setlocale(LC_ALL, ""); + bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); + textdomain(GETTEXT_PACKAGE); + + g_set_application_name(_("Package Update Indicator")); + + gtk_init(&argc, &argv); + + application = pui_application_new(); + status = g_application_run(G_APPLICATION(application), argc, argv); + g_object_unref(application); + + if (restart) { + /* application restart requested */ + if (execv(argv[0], argv) == -1) { + g_error("exec: %s", g_strerror(errno)); + } + } + + exit(status); +} diff -r 000000000000 -r 6884bb8130ca po/LINGUAS diff -r 000000000000 -r 6884bb8130ca po/POTFILES.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/po/POTFILES.in Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,7 @@ +org.guido-berhoerster.code.package-update-indicator.desktop.in +org.guido-berhoerster.code.package-update-indicator.gschema.xml +package-update-indicator.c +pui-application.c +pui-backend.c +pui-get-updates.c +pui-types.c diff -r 000000000000 -r 6884bb8130ca pui-application.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-application.c Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,680 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#define G_SETTINGS_ENABLE_BACKEND +#include +#include +#include +#include +#include + +#include "pui-common.h" +#include "pui-application.h" +#include "pui-types.h" +#include "pui-backend.h" + +#define SETTINGS_ROOT_PATH \ + "/org/guido-berhoerster/code/package-update-indicator/" +#define SETTINGS_ROOT_GROUP "General" + +struct _PuiApplication { + GApplication parent_instance; + GSettings *settings; + GCancellable *cancellable; + PuiBackend *backend; + AppIndicator *indicator; + GtkWidget *about_dialog; + GIcon *icons[PUI_STATE_LAST]; + PuiState state; + gchar *update_command; + gchar *error_message; +}; + +G_DEFINE_TYPE(PuiApplication, pui_application, G_TYPE_APPLICATION) + +enum { + PROP_0, + PROP_UPDATE_COMMAND, + PROP_LAST +}; + +extern gboolean restart; + +static GParamSpec *properties[PROP_LAST] = { NULL }; + +static const gchar *icon_names[PUI_STATE_LAST] = { + [PUI_STATE_INITIAL] = "system-software-update", + [PUI_STATE_UP_TO_DATE] = "system-software-update", + [PUI_STATE_NORMAL_UPDATES_AVAILABLE] = "software-update-available", + [PUI_STATE_IMPORTANT_UPDATES_AVAILABLE] = "software-update-urgent", + [PUI_STATE_ERROR] = "dialog-warning" +}; + +static const GOptionEntry cmd_options[] = { + { "debug", '\0', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL, + N_("Enable debugging messages"), NULL }, + { "quit", 'q', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL, + N_("Quit running instance of Package Update Indicator"), NULL }, + { "version", 'V', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, NULL, + N_("Print the version number and quit"), NULL }, + { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, NULL, NULL, NULL }, + { NULL } +}; + +static void pui_application_show_about_dialog(GSimpleAction *, GVariant *, + gpointer); +static void pui_application_quit(GSimpleAction *, GVariant *, gpointer); +static void pui_application_install_updates(GSimpleAction *, GVariant *, + gpointer); + +static const GActionEntry pui_application_actions[] = { + { "about", pui_application_show_about_dialog }, + { "quit", pui_application_quit }, + { "install-updates", pui_application_install_updates } +}; + +static gboolean +program_exists(const gchar *command_line) +{ + gboolean is_program_in_path; + gchar **argv = NULL; + gchar *program_path; + + if (!g_shell_parse_argv(command_line, NULL, &argv, NULL)) { + return (FALSE); + } + program_path = g_find_program_in_path(argv[0]); + is_program_in_path = (program_path != NULL) ? TRUE : FALSE; + g_free(program_path); + g_strfreev(argv); + + return (is_program_in_path); +} + +static void +pui_application_show_about_dialog(GSimpleAction *simple, GVariant *parameter, + gpointer user_data) +{ + PuiApplication *self = user_data; + const gchar *translators; + + if (self->about_dialog == NULL) { + translators = _("Translators"); + if (strcmp(translators, "Translators") == 0) { + translators = NULL; + } + + self->about_dialog = gtk_about_dialog_new(); + g_object_set(G_OBJECT(self->about_dialog), + "authors", (gchar *[]){ "Guido Berhoerster", NULL }, + "comments", _("Notify about available software updates"), + "copyright", "Copyright \xc2\xa9 2018 Guido Berhoerster", + "license-type", GTK_LICENSE_MIT_X11, + "logo-icon-name", "system-software-update", + "translator-credits", translators, + "version", VERSION, + "website", "https://code.guido-berhoerster.org/projects/" + "package-update-indicator/", + "wrap-license", TRUE, + NULL); + } + + gtk_dialog_run(GTK_DIALOG(self->about_dialog)); + gtk_widget_hide(self->about_dialog); +} + +static void +pui_application_quit(GSimpleAction *simple, GVariant *parameter, + gpointer user_data) +{ + PuiApplication *self = user_data; + + /* quit the GTK main loop if the about dialog is running */ + if (self->about_dialog != NULL) { + gtk_widget_hide(self->about_dialog); + } + + g_application_quit(G_APPLICATION(self)); +} + +static void +pui_application_install_updates(GSimpleAction *simple, GVariant *parameter, + gpointer user_data) +{ + PuiApplication *self = user_data; + GError *error = NULL; + + if (!g_spawn_command_line_async(self->update_command, &error)) { + g_warning("failed to run update command: %s", error->message); + g_error_free(error); + } +} + +static void +update_ui(PuiApplication *self) +{ + GSimpleAction *install_updates_action; + guint important_updates = 0; + guint normal_updates = 0; + gchar *title = NULL; + gchar *body = NULL; + GApplication *application = G_APPLICATION(self); + GNotification *notification = NULL; + + install_updates_action = + G_SIMPLE_ACTION(g_action_map_lookup_action(G_ACTION_MAP(self), + "install-updates")); + + if ((self->state == PUI_STATE_NORMAL_UPDATES_AVAILABLE) || + (self->state == PUI_STATE_IMPORTANT_UPDATES_AVAILABLE)) { + g_object_get(self->backend, + "important-updates", &important_updates, + "normal-updates", &normal_updates, NULL); + } + + /* actions */ + switch (self->state) { + case PUI_STATE_INITIAL: /* FALLTHGROUGH */ + case PUI_STATE_UP_TO_DATE: /* FALLTHGROUGH */ + case PUI_STATE_ERROR: + g_simple_action_set_enabled(install_updates_action, FALSE); + break; + case PUI_STATE_NORMAL_UPDATES_AVAILABLE: /* FALLTHROUGH */ + case PUI_STATE_IMPORTANT_UPDATES_AVAILABLE: + g_simple_action_set_enabled(install_updates_action, + program_exists(self->update_command)); + break; + } + + /* title and body for indicator and notification */ + switch (self->state) { + case PUI_STATE_INITIAL: + title = g_strdup(""); + body = g_strdup(""); + break; + case PUI_STATE_UP_TO_DATE: + title = g_strdup(_("Up to Date")); + body = g_strdup(_("The system is up to date.")); + break; + case PUI_STATE_NORMAL_UPDATES_AVAILABLE: + title = g_strdup(g_dngettext(NULL, "Software Update", + "Software Updates", (gulong)normal_updates)); + if (normal_updates == 1) { + body = g_strdup(_("There is a software update " + "avaliable.")); + } else { + body = g_strdup_printf(_("There are %u " + "software updates avaliable."), normal_updates); + } + break; + case PUI_STATE_IMPORTANT_UPDATES_AVAILABLE: + title = g_strdup(g_dngettext(NULL, "Important Software Update", + "Important Software Updates", (gulong)important_updates)); + if ((normal_updates == 0) && (important_updates == 1)) { + body = g_strdup(_("There is an important " + "software update available.")); + } else if ((normal_updates == 0) && (important_updates > 1)) { + body = g_strdup_printf(_("There are %u " + "important software updates available."), + important_updates); + } else if ((normal_updates > 0) && (important_updates == 1)) { + body = g_strdup_printf(_("There are %u " + "software updates available, " + "one of them is important."), + normal_updates + important_updates); + } else { + body = g_strdup_printf(_("There are %u " + "software updates available, " + "%u of them are important."), + normal_updates + important_updates, + important_updates); + } + break; + case PUI_STATE_ERROR: + title = g_strdup(self->error_message); + break; + } + + /* indicator */ + switch (self->state) { + case PUI_STATE_INITIAL: + app_indicator_set_status(self->indicator, + APP_INDICATOR_STATUS_PASSIVE); + break; + case PUI_STATE_UP_TO_DATE: /* FALLTHGROUGH */ + case PUI_STATE_NORMAL_UPDATES_AVAILABLE: /* FALLTHGROUGH */ + case PUI_STATE_IMPORTANT_UPDATES_AVAILABLE: /* FALLTHGROUGH */ + case PUI_STATE_ERROR: + app_indicator_set_status(self->indicator, + APP_INDICATOR_STATUS_ACTIVE); + break; + } + app_indicator_set_icon_full(self->indicator, icon_names[self->state], + title); + + /* notification */ + switch (self->state) { + case PUI_STATE_INITIAL: /* FALLTHGROUGH */ + case PUI_STATE_UP_TO_DATE: /* FALLTHGROUGH */ + case PUI_STATE_ERROR: + /* withdraw exisiting notification */ + g_application_withdraw_notification(application, + "package-updates"); + break; + case PUI_STATE_NORMAL_UPDATES_AVAILABLE: /* FALLTHGROUGH */ + case PUI_STATE_IMPORTANT_UPDATES_AVAILABLE: + /* create notification */ + notification = g_notification_new(title); + g_notification_set_body(notification, body); + g_notification_set_icon(notification, self->icons[self->state]); + g_notification_set_priority(notification, + G_NOTIFICATION_PRIORITY_NORMAL); + if (g_action_get_enabled(G_ACTION(install_updates_action))) { + g_notification_add_button(notification, + _("Install Updates"), + "app.install-updates"); + } + g_application_send_notification(application, "package-updates", + notification); + break; + } + + if (notification != NULL) { + g_object_unref(notification); + } + + g_debug("indicator icon: %s, notification title: \"%s\", " + "notification body: \"%s\"", icon_names[self->state], title, body); + + g_free(body); + g_free(title); +} + +static void +transition_state(PuiApplication *self) +{ + PuiState state = self->state; + guint important_updates; + guint normal_updates; + gchar *old_state; + gchar *new_state; + + switch (self->state) { + case PUI_STATE_INITIAL: /* FALLTHROUGH */ + case PUI_STATE_UP_TO_DATE: /* FALLTHROUGH */ + case PUI_STATE_NORMAL_UPDATES_AVAILABLE: /* FALLTHROUGH */ + case PUI_STATE_IMPORTANT_UPDATES_AVAILABLE: + if (self->error_message != NULL) { + state = PUI_STATE_ERROR; + break; + } + + g_object_get(self->backend, + "important-updates", &important_updates, + "normal-updates", &normal_updates, NULL); + if (important_updates > 0) { + state = PUI_STATE_IMPORTANT_UPDATES_AVAILABLE; + } else if (normal_updates > 0) { + state = PUI_STATE_NORMAL_UPDATES_AVAILABLE; + } else { + state = PUI_STATE_UP_TO_DATE; + } + break; + case PUI_STATE_ERROR: + break; + } + + if (state != self->state) { + old_state = pui_types_enum_to_string(PUI_TYPE_STATE, + self->state); + new_state = pui_types_enum_to_string(PUI_TYPE_STATE, state); + g_debug("state %s -> %s", old_state, new_state); + + self->state = state; + update_ui(self); + + g_free(new_state); + g_free(old_state); + } +} + +static void +on_backend_restart_required(PuiBackend *backend, gpointer user_data) +{ + PuiApplication *self = user_data; + + restart = TRUE; + g_action_group_activate_action(G_ACTION_GROUP(G_APPLICATION(self)), + "quit", NULL); +} + +static void +on_backend_state_changed(PuiBackend *backend, gpointer user_data) +{ + PuiApplication *self = user_data; + + transition_state(self); +} + +static void +on_pui_backend_finished(GObject *source_object, GAsyncResult *result, + gpointer user_data) +{ + PuiApplication *self = user_data; + GError *error = NULL; + + self->backend = pui_backend_new_finish(result, &error); + if (self->backend == NULL) { + g_warning("failed to instantiate backend: %s", error->message); + g_free(self->error_message); + g_error_free(error); + self->error_message = g_strdup(_("Update notifications " + "are not supported.")); + transition_state(self); + return; + } + + g_settings_bind(self->settings, "refresh-interval", self->backend, + "refresh-interval", G_SETTINGS_BIND_GET); + + transition_state(self); + + g_signal_connect(self->backend, "restart-required", + G_CALLBACK(on_backend_restart_required), self); + g_signal_connect(self->backend, "state-changed", + G_CALLBACK(on_backend_state_changed), self); +} + +static void +pui_application_startup(GApplication *application) +{ + PuiApplication *self = PUI_APPLICATION(application); + gsize i; + gchar *settings_filename; + GSettingsBackend *settings_backend; + GtkWidget *menu; + GtkWidget *menu_item; + + G_APPLICATION_CLASS(pui_application_parent_class)->startup(application); + + /* create actions */ + g_action_map_add_action_entries(G_ACTION_MAP(self), + pui_application_actions, G_N_ELEMENTS(pui_application_actions), + self); + + /* load icons */ + for (i = 0; i < G_N_ELEMENTS(self->icons); i++) { + self->icons[i] = g_themed_icon_new(icon_names[i]); + } + + /* create settings */ + settings_filename = g_build_filename(g_get_user_config_dir(), PACKAGE, + PACKAGE ".conf", NULL); + settings_backend = g_keyfile_settings_backend_new(settings_filename, + SETTINGS_ROOT_PATH, SETTINGS_ROOT_GROUP); + self->settings = g_settings_new_with_backend(APPLICATION_ID, + settings_backend); + g_settings_bind(self->settings, "update-command", self, + "update-command", G_SETTINGS_BIND_GET); + + /* start instantiating backend */ + pui_backend_new_async(self->cancellable, on_pui_backend_finished, self); + + /* create indicator */ + self->indicator = app_indicator_new(APPLICATION_ID, + "system-software-update", + APP_INDICATOR_CATEGORY_APPLICATION_STATUS); + + /* build menu */ + menu = gtk_menu_new(); + gtk_widget_insert_action_group(GTK_WIDGET(menu), "app", + G_ACTION_GROUP(self)); + + menu_item = gtk_menu_item_new_with_label(_("Install " + "Updates\342\200\246")); + gtk_actionable_set_action_name(GTK_ACTIONABLE(menu_item), + "app.install-updates"); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); + + menu_item = gtk_menu_item_new_with_label(_("About\342\200\246")); + gtk_actionable_set_action_name(GTK_ACTIONABLE(menu_item), + "app.about"); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); + + gtk_widget_show_all(menu); + app_indicator_set_menu(self->indicator, GTK_MENU(menu)); + + update_ui(self); + + /* keep GApplication running */ + g_application_hold(application); + + g_object_unref(settings_backend); + g_free(settings_filename); +} + +static void +pui_application_shutdown(GApplication *application) +{ + GApplicationClass *application_class = + G_APPLICATION_CLASS(pui_application_parent_class); + + application_class->shutdown(application); +} + +static gint +pui_application_handle_local_options(GApplication *application, + GVariantDict *options) +{ + gchar *messages_debug; + gchar **args = NULL; + GError *error = NULL; + + /* filename arguments are not allowed */ + if (g_variant_dict_lookup(options, G_OPTION_REMAINING, "^a&ay", + &args)) { + g_printerr("invalid argument: \"%s\"\n", args[0]); + g_free(args); + return (1); + } + + if (g_variant_dict_contains(options, "version")) { + g_print("%s %s\n", PACKAGE, VERSION); + + /* quit */ + return (0); + } + + if (g_variant_dict_contains(options, "debug")) { + /* enable debug logging */ + messages_debug = g_strjoin(":", G_LOG_DOMAIN, + g_getenv("G_MESSAGES_DEBUG"), NULL); + g_setenv("G_MESSAGES_DEBUG", messages_debug, TRUE); + g_free(messages_debug); + } + + /* + * register with the session bus so that it is possible to discern + * between remote and primary instance and that remote actions can be + * invoked, this causes the startup signal to be emitted which, in case + * of the primary instance, starts to instantiate the + * backend with the given values + */ + if (!g_application_register(application, NULL, &error)) { + g_critical("g_application_register: %s", error->message); + g_error_free(error); + return (1); + } + + if (g_variant_dict_contains(options, "quit")) { + /* only valid if a remote instance is running */ + if (!g_application_get_is_remote(application)) { + g_printerr("%s is not running\n", g_get_prgname()); + return (1); + } + + /* signal remote instance to quit */ + g_action_group_activate_action(G_ACTION_GROUP(application), + "quit", NULL); + + /* quit local instance */ + return (0); + } + + /* proceed with default command line processing */ + return (-1); +} + +static void +pui_application_activate(GApplication *application) { + GApplicationClass *application_class = + G_APPLICATION_CLASS(pui_application_parent_class); + + /* do nothing, implementation required by GApplication */ + + application_class->activate(application); +} + +static void +pui_application_set_property(GObject *object, guint property_id, + const GValue *value, GParamSpec *pspec) +{ + PuiApplication *self = PUI_APPLICATION(object); + + switch (property_id) { + case PROP_UPDATE_COMMAND: + g_free(self->update_command); + self->update_command = g_value_dup_string(value); + g_debug("property \"update-command\" set to \"%s\"", + self->update_command); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void +pui_application_get_property(GObject *object, guint property_id, GValue *value, + GParamSpec *pspec) +{ + PuiApplication *self = PUI_APPLICATION(object); + + switch (property_id) { + case PROP_UPDATE_COMMAND: + g_value_set_string(value, self->update_command); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void +pui_application_dispose(GObject *object) +{ + PuiApplication *self = PUI_APPLICATION(object); + gsize i; + + if (self->settings != NULL) { + g_signal_handlers_disconnect_by_data(self->settings, self); + g_clear_object(&self->settings); + } + + if (self->cancellable != NULL) { + g_cancellable_cancel(self->cancellable); + g_clear_object(&self->cancellable); + } + + if (self->backend != NULL) { + g_clear_object(&self->backend); + } + + if (self->indicator != NULL) { + g_clear_object(&self->indicator); + } + + if (self->about_dialog != NULL) { + g_clear_pointer(&self->about_dialog, + (GDestroyNotify)(gtk_widget_destroy)); + } + + for (i = 0; i < G_N_ELEMENTS(self->icons); i++) { + if (self->icons[i] != NULL) { + g_clear_object(&self->icons[i]); + } + } + + G_OBJECT_CLASS(pui_application_parent_class)->dispose(object); +} + +static void +pui_application_finalize(GObject *object) +{ + PuiApplication *self = PUI_APPLICATION(object); + + g_free(self->update_command); + g_free(self->error_message); + + G_OBJECT_CLASS(pui_application_parent_class)->finalize(object); +} + +static void +pui_application_class_init(PuiApplicationClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GApplicationClass *application_class = G_APPLICATION_CLASS(klass); + + object_class->set_property = pui_application_set_property; + object_class->get_property = pui_application_get_property; + object_class->dispose = pui_application_dispose; + object_class->finalize = pui_application_finalize; + + properties[PROP_UPDATE_COMMAND] = g_param_spec_string("update-command", + "Update command", "Command for installing updates", NULL, + G_PARAM_READWRITE); + + g_object_class_install_properties(object_class, PROP_LAST, properties); + + application_class->startup = pui_application_startup; + application_class->shutdown = pui_application_shutdown; + application_class->handle_local_options = + pui_application_handle_local_options; + application_class->activate = pui_application_activate; +} + +static void +pui_application_init(PuiApplication *self) +{ + g_application_add_main_option_entries(G_APPLICATION(self), + cmd_options); + + self->cancellable = g_cancellable_new(); +} + +PuiApplication * +pui_application_new(void) +{ + return (g_object_new(PUI_TYPE_APPLICATION, "application-id", + APPLICATION_ID, NULL)); +} diff -r 000000000000 -r 6884bb8130ca pui-application.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-application.h Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#ifndef PUI_APPLICATION_H +#define PUI_APPLICATION_H + +#include +#include + +G_BEGIN_DECLS + +#define PUI_TYPE_APPLICATION (pui_application_get_type()) + +G_DECLARE_FINAL_TYPE(PuiApplication, pui_application, PUI, APPLICATION, + GApplication) + +PuiApplication * pui_application_new(void); + +G_END_DECLS + +#endif /* !PUI_APPLICATION_H */ diff -r 000000000000 -r 6884bb8130ca pui-backend.c --- /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 + * + * 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 +#include +#include +#include +#include +#include +#include + +#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); +} diff -r 000000000000 -r 6884bb8130ca pui-backend.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-backend.h Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#ifndef PUI_BACKEND_H +#define PUI_BACKEND_H + +#include +#include + +G_BEGIN_DECLS + +#define PUI_TYPE_BACKEND (pui_backend_get_type()) + +#define PUI_BACKEND_ERROR (pui_backend_error_quark()) + +G_DECLARE_FINAL_TYPE(PuiBackend, pui_backend, PUI, BACKEND, GObject) + +enum { + PUI_BACKEND_ERROR_GET_UPDATES_NOT_IMPLEMENTED +}; + +GQuark pui_backend_error_quark(void); +void pui_backend_new_async(GCancellable *, GAsyncReadyCallback, + gpointer); +PuiBackend * pui_backend_new_finish(GAsyncResult *, GError **); + +G_END_DECLS + +#endif /* !PUI_BACKEND_H */ diff -r 000000000000 -r 6884bb8130ca pui-common.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-common.h Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#ifndef PUI_COMMON_H +#define PUI_COMMON_H + +G_BEGIN_DECLS + +#ifndef PUI_STARTUP_DELAY +#define PUI_STARTUP_DELAY (3 * 60) +#endif /* !PUI_STARTUP_DELAY */ + +#ifndef PUI_CHECK_UPDATES_INTERVAL +#define PUI_CHECK_UPDATES_INTERVAL (60 * 60) +#endif /* !PUI_CHECK_UPDATES_INTERVAL */ + +#ifndef PUI_DEFAULT_REFRESH_INTERVAL +#define PUI_DEFAULT_REFRESH_INTERVAL (24 * 60 * 60) +#endif /* !PUI_DEFAULT_REFRESH_INTERVAL */ + +G_END_DECLS + +#endif /* !PUI_COMMON_H */ diff -r 000000000000 -r 6884bb8130ca pui-get-updates.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-get-updates.c Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,227 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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 "pui-get-updates.h" + +typedef struct { + PkControl *pk_control; + PkTask *pk_task; + guint refresh_interval; +} PuiGetUpdates; + +GQuark +pui_get_updates_error_quark(void) +{ + return (g_quark_from_static_string("pui-get-updates-error-quark")); +} + +static void +on_get_updates_finished(GObject *source_object, GAsyncResult *async_result, + gpointer user_data) +{ + GTask *task = user_data; + PuiGetUpdates *get_updates; + PkResults *results = NULL; + PkError *pk_error = NULL; + GError *error = NULL; + gint error_code; + GPtrArray *package_list; + + get_updates = g_task_get_task_data(task); + + g_debug("get updates transaction finished"); + results = pk_client_generic_finish(PK_CLIENT(get_updates->pk_task), + async_result, &error); + if (results == NULL) { + /* pass the error on */ + g_task_return_error(task, error); + goto out; + } + + pk_error = pk_results_get_error_code(results); + if (pk_error != NULL) { + /* transaction failed, return error */ + g_debug("failed to refresh the cache: %s", + pk_error_get_details(pk_error)); + if (pk_error_get_code(pk_error) == + PK_ERROR_ENUM_TRANSACTION_CANCELLED) { + error_code = PUI_GET_UPDATES_ERROR_CANCELLED; + } else { + error_code = + PUI_GET_UPDATES_ERROR_GET_UPDATES_FAILED; + } + error = g_error_new(PUI_GET_UPDATES_ERROR, error_code, + "Failed to get package updates: %s", + pk_error_get_details(pk_error)); + g_task_return_error(task, error); + g_object_unref(pk_error); + goto out; + } + + /* return results */ + package_list = pk_results_get_package_array(results); + g_assert(package_list != NULL); + g_task_return_pointer(task, package_list, + (GDestroyNotify)g_ptr_array_unref); + +out: + if (results != NULL) { + g_object_unref(results); + } + g_object_unref(task); +} + +static void +on_refresh_cache_finished(GObject *source_object, GAsyncResult *async_result, + gpointer user_data) +{ + GTask *task = user_data; + PuiGetUpdates *get_updates; + PkResults *results = NULL; + PkClient *pk_client; + GError *error = NULL; + PkError *pk_error = NULL; + gint error_code; + + get_updates = g_task_get_task_data(task); + pk_client = PK_CLIENT(get_updates->pk_task); + + g_debug("refresh cache transaction finished"); + results = pk_client_generic_finish(pk_client, async_result, &error); + if (results == NULL) { + g_task_return_error(task, error); + goto out; + } + + pk_error = pk_results_get_error_code(results); + if (pk_error != NULL) { + /* transaction failed, return error */ + g_debug("failed to refresh the cache: %s", + pk_error_get_details(pk_error)); + if (pk_error_get_code(pk_error) == + PK_ERROR_ENUM_TRANSACTION_CANCELLED) { + error_code = PUI_GET_UPDATES_ERROR_CANCELLED; + } else { + error_code = PUI_GET_UPDATES_ERROR_REFRESH_FAILED; + } + error = g_error_new(PUI_GET_UPDATES_ERROR, error_code, + "Failed to refresh the cache: %s", + pk_error_get_details(pk_error)); + g_task_return_error(task, error); + g_object_unref(pk_error); + goto out; + } + + /* cache is up to date, get updates */ + pk_client_get_updates_async(pk_client, + pk_bitfield_value(PK_FILTER_ENUM_NONE), + g_task_get_cancellable(task), NULL, NULL, on_get_updates_finished, + task); + +out: + if (results != NULL) { + g_object_unref(results); + } +} + +static void +on_get_time_since_refresh_finished(GObject *source_object, + GAsyncResult *async_result, gpointer user_data) +{ + GTask *task = user_data; + PuiGetUpdates *get_updates; + guint last_refresh; + GError *error = NULL; + PkClient *pk_client; + + get_updates = g_task_get_task_data(task); + pk_client = PK_CLIENT(get_updates->pk_task); + + last_refresh = + pk_control_get_time_since_action_finish(get_updates->pk_control, + async_result, &error); + if (last_refresh == 0) { + g_task_return_error(task, error); + g_object_unref(task); + return; + } + g_debug("time since last cache refresh: %us", last_refresh); + + if (last_refresh > get_updates->refresh_interval) { + /* cache is out of date, refresh first */ + g_debug("refreshing the cache"); + pk_client_refresh_cache_async(pk_client, FALSE, + g_task_get_cancellable(task), NULL, NULL, + on_refresh_cache_finished, task); + } else { + /* cache is up to date, get updates */ + g_debug("getting updates"); + pk_client_get_updates_async(pk_client, + pk_bitfield_value(PK_FILTER_ENUM_NONE), + g_task_get_cancellable(task), NULL, NULL, + on_get_updates_finished, task); + } +} + +static void +pui_get_updates_free(gpointer data) +{ + PuiGetUpdates *get_updates = data; + + g_object_unref(get_updates->pk_control); + g_object_unref(get_updates->pk_task); + g_slice_free(PuiGetUpdates, data); +} + +void +pui_get_updates_async(PkControl *pk_control, guint refresh_interval, + GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) +{ + PuiGetUpdates *get_updates; + GTask *task; + PkClient *pk_client; + + get_updates = g_slice_new0(PuiGetUpdates); + get_updates->pk_control = g_object_ref(pk_control); + get_updates->pk_task = pk_task_new(); + get_updates->refresh_interval = refresh_interval; + + pk_client = PK_CLIENT(get_updates->pk_task); + pk_client_set_cache_age(pk_client, refresh_interval); + pk_client_set_background(pk_client, TRUE); + + task = g_task_new(NULL, cancellable, callback, user_data); + g_task_set_task_data(task, get_updates, pui_get_updates_free); + + /* check whether to refresh the cache before checking for updates */ + g_debug("getting the time since the cache was last refreshed"); + pk_control_get_time_since_action_async(pk_control, + PK_ROLE_ENUM_REFRESH_CACHE, cancellable, + on_get_time_since_refresh_finished, task); +} + +GPtrArray * +pui_get_updates_finish(GAsyncResult *result, GError **errorp) +{ + return (g_task_propagate_pointer(G_TASK(result), errorp)); +} diff -r 000000000000 -r 6884bb8130ca pui-get-updates.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-get-updates.h Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#ifndef PUI_GET_UPDATES_H +#define PUI_GET_UPDATES_H + +#include +#include +#include + +G_BEGIN_DECLS + +#define PUI_GET_UPDATES_ERROR (pui_get_updates_error_quark()) + +enum { + PUI_GET_UPDATES_ERROR_REFRESH_FAILED, + PUI_GET_UPDATES_ERROR_GET_UPDATES_FAILED, + PUI_GET_UPDATES_ERROR_CANCELLED +}; + +GQuark pui_get_updates_error_quark(void); +void pui_get_updates_async(PkControl *, guint, GCancellable *, + GAsyncReadyCallback, gpointer); +GPtrArray * pui_get_updates_finish(GAsyncResult *, GError **); + +G_END_DECLS + +#endif /* !PUI_GET_UPDATES_H */ diff -r 000000000000 -r 6884bb8130ca pui-types.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-types.c Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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 "pui-types.h" + +#define PUI_DEFINE_ENUM_VALUE(valuename, valuenick) \ + { valuename, #valuename, #valuenick }, +#define PUI_DEFINE_ENUM_TYPE(EnumName, enum_name, values) \ + GType \ + enum_name##_get_type(void) \ + { \ + static volatile gsize g_define_type_id__volatile = 0; \ + static const GEnumValue v[] = { \ + values \ + { 0 } \ + }; \ + GType g_define_type_id; \ + if (g_once_init_enter(&g_define_type_id__volatile)) { \ + g_define_type_id = \ + g_enum_register_static(g_intern_static_string(#EnumName), \ + v); \ + g_once_init_leave(&g_define_type_id__volatile, \ + g_define_type_id); \ + } \ + return (g_define_type_id__volatile); \ + } + +PUI_DEFINE_ENUM_TYPE(PuiState, pui_state, + PUI_DEFINE_ENUM_VALUE(PUI_STATE_UP_TO_DATE, "up-to-date") + PUI_DEFINE_ENUM_VALUE(PUI_STATE_NORMAL_UPDATES_AVAILABLE, + "normal-updates-available") + PUI_DEFINE_ENUM_VALUE(PUI_STATE_IMPORTANT_UPDATES_AVAILABLE, + "important-updates-available") + PUI_DEFINE_ENUM_VALUE(PUI_STATE_ERROR, "error")) + +gchar * +pui_types_enum_to_string(GType type, gint value) +{ + GTypeClass *type_class; + GEnumValue *enum_value; + + type_class = g_type_class_ref(type); + + g_return_val_if_fail(G_IS_ENUM_CLASS(type_class), NULL); + + enum_value = g_enum_get_value(G_ENUM_CLASS(type_class), value); + if (enum_value == NULL) { + return (g_strdup_printf("%d", value)); + } + + return (g_strdup(enum_value->value_nick)); +} diff -r 000000000000 -r 6884bb8130ca pui-types.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pui-types.h Sun May 20 11:32:57 2018 +0200 @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2018 Guido Berhoerster + * + * 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. + */ + +#ifndef PUI_TYPES_H +#define PUI_TYPES_H + +#include + +G_BEGIN_DECLS + +#define PUI_TYPE_STATE (pui_state_get_type()) + +typedef enum { + PUI_STATE_INITIAL, + PUI_STATE_UP_TO_DATE, + PUI_STATE_NORMAL_UPDATES_AVAILABLE, + PUI_STATE_IMPORTANT_UPDATES_AVAILABLE, + PUI_STATE_ERROR, + PUI_STATE_LAST +} PuiState; + +GType pui_state_get_type(void); +gchar * pui_types_enum_to_string(GType, gint); + +G_END_DECLS + +#endif /* !PUI_TYPES_H */