Background portal implementation

data/pantheon.portal

@@ -1,4 +1,4 @@
 [portal]
 DBusName=org.freedesktop.impl.portal.desktop.pantheon
-Interfaces=org.freedesktop.impl.portal.Access;org.freedesktop.impl.portal.AppChooser;
+Interfaces=org.freedesktop.impl.portal.Access;org.freedesktop.impl.portal.AppChooser;org.freedesktop.impl.portal.Background;
 UseIn=pantheon

src/Background/NotificationHandler.vala

@@ -0,0 +1,109 @@
+public class NotificationHandler : Object {
+    public const string ACTION_ALLOW_BACKGROUND = "background.allow";
+    public const string ACTION_FORBID_BACKGROUND = "background.forbid";
+
+    private DBusConnection connection;
+    private HashTable<uint32, NotificationRequest> notification_by_id;
+    private Notifications notifications;
+
+    private enum NotifyBackgroundResult {
+        FORBID,
+        ALLOW,
+        ALLOW_ONCE
+    }
+
+    [DBus (name = "org.freedesktop.Notifications")]
+    public interface Notifications : Object {
+        public signal void action_invoked (uint32 id, string action_key);
+        public signal void notification_closed (uint32 id, uint32 reason);
+
+        public abstract void close_notification (uint32 id) throws DBusError, IOError;
+        public abstract uint32 notify (
+            string app_name,
+            uint32 replaces_id,
+            string app_icon,
+            string summary,
+            string body,
+            string[] actions,
+            HashTable<string, Variant> hints,
+            int32 expire_timeout
+        ) throws DBusError, IOError;
+    }
+
+    public NotificationHandler (DBusConnection connection) {
+        this.connection = connection;
+        notification_by_id = new HashTable<uint32, NotificationRequest> (null, null);
+
+        try {
+            notifications = connection.get_proxy_sync ("org.freedesktop.Notifications", "/org/freedesktop/Notifications");
+            notifications.action_invoked.connect (on_action_invoked);
+            notifications.notification_closed.connect (on_notification_closed);
+        } catch {
+            warning ("Cannot connect to notifications dbus, background portal working with reduced functionality.");
+        }
+    }
+
+    public NotificationRequest? send_notification (string app_id, string app_name) {
+        string[] actions = {
+            ACTION_ALLOW_BACKGROUND,
+            _("Allow"),
+            ACTION_FORBID_BACKGROUND,
+            _("Forbid")
+        };
+
+        try {
+            var id = notifications.notify (
+                Environment.get_prgname (),
+                0,
+                "dialog-information",
+                _("Background activity"),
+                _(""""%s" is running in the background""").printf (app_name),
+                actions,
+                new HashTable<string, Variant> (str_hash, str_equal),
+                0
+            );
+
+            var notification = new NotificationRequest (this, id);
+            notification_by_id.set (id, notification);
+
+            return notification;
+        } catch (Error e) {
+            warning ("Failed to send notification for app id '%s': %s", app_id, e.message);
+            return null;
+        }
+    }
+
+    private void on_action_invoked (uint32 id, string action_key) {
+        if (id in notification_by_id) {
+            var notification = notification_by_id.get (id);
+            if (action_key == NotificationHandler.ACTION_ALLOW_BACKGROUND) {
+                notification.response (NotifyBackgroundResult.ALLOW);
+            } else if (action_key == NotificationHandler.ACTION_FORBID_BACKGROUND) {
+                notification.response (NotifyBackgroundResult.FORBID);
+            }
+
+            notification_by_id.remove (id);
+        }
+    }
+
+    private void on_notification_closed (uint32 id, uint32 reason) {
+        if (id in notification_by_id) {
+            var notification = notification_by_id.get (id);
+            if (reason == 2 || reason == 3) {
+                notification.response (NotifyBackgroundResult.ALLOW_ONCE);
+
+                notification_by_id.remove (id);
+            }
+        }
+    }
+
+    public void close_notification (uint32 id) {
+        try {
+            notifications.close_notification (id);
+        } catch (Error e) {
+            warning ("Failed to close notification with id '%u': %s", id, e.message);
+        }
+
+        notification_by_id.remove (id);
+    }
+}

src/Background/NotificationRequest.vala

@@ -0,0 +1,19 @@
+[DBus (name = "org.freedesktop.impl.portal.Request")]
+public class NotificationRequest : Object {
+    [DBus (visible = false)]
+    public signal void response (uint32 result);
+
+    public uint register_id { get; set; default = 0; }
+
+    private NotificationHandler handler;
+    private uint32 id;
+
+    public NotificationRequest (NotificationHandler handler, uint32 id) {
+        this.handler = handler;
+        this.id = id;
+    }
+
+    public void close () throws DBusError, IOError {
+        handler.close_notification (id);
+    }
+}

src/Background/Portal.vala

@@ -0,0 +1,162 @@
+/*
+ * SPDX-FileCopyrightText: 2023 elementary, Inc. (https://elementary.io)
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+[DBus (name = "org.freedesktop.impl.portal.Background")]
+public class Background.Portal : Object {
+    public signal void running_applications_changed ();
+
+    private DBusConnection connection;
+    private DesktopIntegration desktop_integration;
+    private NotificationHandler notification_handler;
+
+    public Portal (DBusConnection connection) {
+        this.connection = connection;
+        notification_handler = new NotificationHandler (connection);
+        try {
+            desktop_integration = connection.get_proxy_sync ("org.pantheon.gala", "/org/pantheon/gala/DesktopInterface");
+            desktop_integration.running_applications_changed.connect (() => running_applications_changed ());
+        } catch {
+            warning ("Cannot connect to compositor, background portal working with reduced functionality.");
+        }
+    }
+
+    [DBus (name = "org.pantheon.gala.DesktopIntegration")]
+    public interface DesktopIntegration : Object {
+        public struct RunningApplications {
+            string app_id;
+            HashTable<string,Variant> details;
+        }
+
+        public signal void running_applications_changed ();
+        public abstract RunningApplications[] get_running_applications () throws DBusError, IOError;
+    }
+
+    private enum ApplicationState {
+        BACKGROUND,
+        RUNNING,
+        ACTIVE
+    }
+
+    public HashTable<string, Variant> get_app_state () throws DBusError, IOError {
+        if (desktop_integration == null) {
+            throw new DBusError.FAILED ("No connection to compositor.");
+        }
+
+        var apps = desktop_integration.get_running_applications ();
+        var results = new HashTable<string, Variant> (null, null);
+        foreach (var app in apps) {
+            var app_id = app.app_id;
+            if (app_id.has_suffix (".desktop")) {
+                app_id = app_id.slice (0, app_id.last_index_of_char ('.'));
+            }
+
+            results[app_id] = ApplicationState.RUNNING; //FIXME: Don't hardcode: needs implementation on the gala side
+        }
+
+        return results;
+    }
+
+    public async void notify_background (
+        ObjectPath handle,
+        string app_id,
+        string name,
+        out uint32 response,
+        out HashTable<string, Variant> results
+    ) throws DBusError, IOError {
+        response = 0; //Won't be used
+        var _results = new HashTable<string, Variant> (str_hash, str_equal);
+
+        var notification_request = notification_handler.send_notification (app_id, name);
+
+        if (notification_request == null) {
+            _results.set ("result", 2);
+            results = _results;
+            return;
+        }
+
+        notification_request.response.connect ((result) => {
+            _results.set ("result", result);
+            notify_background.callback ();
+        });
+
+        try {
+            notification_request.register_id = connection.register_object<NotificationRequest> (handle, notification_request);
+        } catch (Error e) {
+            critical ("Failed to export request object: %s", e.message);
+        }
+
+        yield;
+
+        connection.unregister_object (notification_request.register_id);
+        results = _results;
+    }
+
+    private enum AutostartFlags {
+        AUTOSTART_FLAGS_NONE,
+        AUTOSTART_FLAGS_DBUS_ACTIVATABLE
+    }
+
+    public bool enable_autostart (
+        string app_id,
+        bool enable,
+        string[] commandline,
+        uint32 flags
+    ) throws DBusError, IOError {
+        /* If the portal request is made by a non-flatpak application app_id will most of the time be empty */
+        if (app_id.strip () == "") {
+            /* Usually we can then asume that the first commandline arg is the app_id */
+            if (commandline[0].strip () != "") {
+                app_id = commandline[0];
+            } else {
+                return false;
+            }
+        }
+
+        var path = Path.build_filename (Environment.get_user_config_dir (), "autostart", app_id + ".desktop");
+
+        if (!enable) {
+            FileUtils.unlink (path);
+            return false;
+        }
+
+        var autostart_flags = (AutostartFlags) flags;
+
+        var key_file = new KeyFile ();
+        key_file.set_string (KeyFileDesktop.GROUP, KeyFileDesktop.KEY_TYPE, "Application");
+        key_file.set_string (KeyFileDesktop.GROUP, KeyFileDesktop.KEY_NAME, app_id);
+        key_file.set_string (KeyFileDesktop.GROUP, KeyFileDesktop.KEY_EXEC, flatpak_quote_argv (commandline));
+        if (autostart_flags == AUTOSTART_FLAGS_DBUS_ACTIVATABLE) {
+            key_file.set_boolean (KeyFileDesktop.GROUP, KeyFileDesktop.KEY_DBUS_ACTIVATABLE, true);
+        }
+        key_file.set_string (KeyFileDesktop.GROUP, "X-Flatpak", app_id);
+
+        try {
+            key_file.save_to_file (path);
+        } catch (Error e) {
+            warning ("Failed to write autostart file: %s", e.message);
+            return false;
+        }
+
+        return true;
+    }
+
+    private string flatpak_quote_argv (string[] argv) {
+        var builder = new StringBuilder ();
+
+        foreach (var arg in argv) {
+            foreach (var c in (char[]) arg.data) {
+                if (!c.isalnum () && !(c.to_string () in "-/~:._=@")) {
+                    arg = Shell.quote (arg);
+                    break;
+                }
+            }
+
+            builder.append (arg);
+            builder.append (" ");
+        }
+
+        return builder.str.strip ();
+    }
+}

src/XdgDesktopPortalPantheon.vala

@@ -37,6 +37,9 @@ private void on_bus_acquired (DBusConnection connection, string name) {
 
         connection.register_object ("/org/freedesktop/portal/desktop", new AppChooser.Portal (connection));
         debug ("AppChooser Portal registered!");
+
+        connection.register_object ("/org/freedesktop/portal/desktop", new Background.Portal (connection));
+        debug ("Background Portal registered!");
     } catch (Error e) {
         critical ("Unable to register the object: %s", e.message);
     }

src/meson.build

@@ -6,6 +6,9 @@ executable(
     'AppChooser/AppButton.vala',
     'AppChooser/Dialog.vala',
     'AppChooser/Portal.vala',
+    'Background/NotificationHandler.vala',
+    'Background/NotificationRequest.vala',
+    'Background/Portal.vala',
     configure_file(input: 'Config.vala.in', output: '@BASENAME@', configuration: conf_data),
     'ExternalWindow.vala',
     'XdgDesktopPortalPantheon.vala',