Retrieve new toplevels from cosmic-comp

Implements emitting a signal for `Background::RunningApplicationsChanged`
in response to toplevel changes (created, destroyed, updated).

`Background::GetAppState` should work now as well

Author: joshuamegnauth54

src/app.rs

@@ -221,7 +221,8 @@ impl cosmic::Application for CosmicPortal {
                 subscription::Event::Config(config) => self.update(Msg::ConfigSubUpdate(config)),
                 subscription::Event::Accent(_)
                 | subscription::Event::IsDark(_)
-                | subscription::Event::HighContrast(_) => cosmic::iced::Command::none(),
+                | subscription::Event::HighContrast(_)
+                | subscription::Event::BackgroundToplevels => cosmic::iced::Command::none(),
                 subscription::Event::Init(tx) => {
                     self.tx = Some(tx);
                     Command::none()

src/background.rs

@@ -1,47 +1,102 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    sync::{Arc, Condvar, Mutex},
+};
 
+use ashpd::enumflags2::BitFlags;
 use cosmic::{iced::window, widget};
+use cosmic_protocols::toplevel_info::v1::client::zcosmic_toplevel_handle_v1;
 use futures::{FutureExt, TryFutureExt};
 use tokio::sync::mpsc::Sender;
 use zbus::{fdo, object_server::SignalContext, zvariant};
 
-use crate::{app::CosmicPortal, fl, subscription, PortalResponse};
-
-const POP_SHELL_DEST: &str = "com.System76.PopShell";
-const POP_SHELL_PATH: &str = "/com.System76.PopShell";
+use crate::{app::CosmicPortal, fl, subscription, wayland::WaylandHelper, PortalResponse};
 
 /// Background portal backend
 ///
 /// https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.impl.portal.Background.html
 pub struct Background {
+    wayland_helper: WaylandHelper,
     tx: Sender<subscription::Event>,
 }
 
 impl Background {
-    pub const fn new(tx: Sender<subscription::Event>) -> Self {
-        Self { tx }
+    pub fn new(wayland_helper: WaylandHelper, tx: Sender<subscription::Event>) -> Self {
+        let toplevel_signal = wayland_helper.toplevel_signal();
+        let toplevel_tx = tx.clone();
+        std::thread::Builder::new()
+            .name("background-toplevel-updates".into())
+            .spawn(move || Background::toplevel_signal(toplevel_signal, toplevel_tx))
+            .expect("Spawning toplevels update thread should succeed");
+
+        Self { wayland_helper, tx }
+    }
+
+    /// Trigger [`Background::running_applications_changed`] on toplevel updates
+    fn toplevel_signal(signal: Arc<(Mutex<bool>, Condvar)>, tx: Sender<subscription::Event>) {
+        loop {
+            let (lock, cvar) = &*signal;
+            let mut updated = lock.lock().unwrap();
+
+            log::debug!("[background] Waiting for toplevel updates");
+            while !*updated {
+                updated = cvar.wait(updated).unwrap();
+            }
+
+            log::debug!(
+                "[background] Emitting RunningApplicationsChanged in response to toplevel updates"
+            );
+            debug_assert!(*updated);
+            *updated = false;
+            if let Err(e) = tx.blocking_send(subscription::Event::BackgroundToplevels) {
+                log::warn!("[background] Failed sending event to trigger RunningApplicationsChanged: {e:?}");
+            }
+        }
     }
 }
 
 #[zbus::interface(name = "org.freedesktop.impl.portal.Background")]
 impl Background {
-    /// Current status on running apps
-    async fn get_app_state(
-        &self,
-        // #[zbus(connection)] connection: &zbus::Connection,
-    ) -> fdo::Result<HashMap<String, AppStatus>> {
-        // TODO: Subscribe to Wayland window open events for running apps
-        log::warn!("[background] GetAppState is currently unimplemented");
-        Ok(HashMap::default())
+    /// Status on running apps (active, running, or background)
+    async fn get_app_state(&self) -> fdo::Result<HashMap<String, AppStatus>> {
+        let toplevels: HashMap<_, _> = self
+            .wayland_helper
+            .toplevels()
+            .into_iter()
+            .map(|(_, info)| {
+                let status = if info
+                    .state
+                    .contains(&zcosmic_toplevel_handle_v1::State::Activated)
+                {
+                    AppStatus::Active
+                } else if !info.state.is_empty() {
+                    AppStatus::Running
+                } else {
+                    // xxx Is this the correct way to determine if a program is running in the
+                    // background? If a toplevel exists but isn't running, activated, et cetera,
+                    // then it logically must be in the background (?)
+                    AppStatus::Background
+                };
+
+                (info.app_id, status)
+            })
+            .collect();
+
+        log::debug!(
+            "[background] GetAppState returning {} toplevels",
+            toplevels.len()
+        );
+        #[cfg(debug_assertions)]
+        log::trace!("[background] App status: {toplevels:#?}");
+
+        Ok(toplevels)
     }
 
     /// Notifies the user that an app is running in the background
     async fn notify_background(
         &self,
-        // #[zbus(connection)] connection: &zbus::Connection,
-        #[zbus(signal_context)] context: SignalContext<'_>,
         handle: zvariant::ObjectPath<'_>,
         app_id: String,
         name: String,
@@ -139,15 +194,8 @@ impl Background {
     pub async fn running_applications_changed(context: &SignalContext<'_>) -> zbus::Result<()>;
 }
 
-/// Information on running apps
-// #[derive(Clone, Debug, zvariant::SerializeDict, zvariant::Type)]
-// #[zvariant(signature = "a{sv}")]
-// pub struct GetAppState {
-//     apps: HashMap<String, AppStatus>,
-// }
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, zvariant::Type)]
-#[zvariant(signature = "u")]
+#[zvariant(signature = "v")]
 pub enum AppStatus {
     /// No open windows
     Background = 0,
@@ -164,7 +212,7 @@ pub struct NotifyBackgroundResult {
     result: PermissionResponse,
 }
 
-/// Response for apps requesting to run in the background
+/// Response for apps requesting to run in the background for [`Background::notify_background`]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, zvariant::Type)]
 #[zvariant(signature = "u")]
 pub enum PermissionResponse {

src/subscription.rs

@@ -25,6 +25,7 @@ pub enum Event {
     CancelScreencast(zvariant::ObjectPath<'static>),
     Background(crate::background::Args),
     BackgroundGetAppPerm(String, Sender<crate::background::ConfigAppPerm>),
+    BackgroundToplevels,
     Accent(Srgba),
     IsDark(bool),
     HighContrast(bool),
@@ -84,6 +85,7 @@ impl Debug for Event {
                 .field(app_id)
                 .field(tx)
                 .finish(),
+            Event::BackgroundToplevels => f.debug_tuple("BackgroundToplevels").finish(),
             Event::Accent(a) => a.fmt(f),
             Event::IsDark(t) => t.fmt(f),
             Event::HighContrast(c) => c.fmt(f),
@@ -144,7 +146,10 @@ pub(crate) async fn process_changes(
             let connection = zbus::ConnectionBuilder::session()?
                 .name(DBUS_NAME)?
                 .serve_at(DBUS_PATH, Access::new(wayland_helper.clone(), tx.clone()))?
-                .serve_at(DBUS_PATH, Background::new(tx.clone()))?
+                .serve_at(
+                    DBUS_PATH,
+                    Background::new(wayland_helper.clone(), tx.clone()),
+                )?
                 .serve_at(DBUS_PATH, FileChooser::new(tx.clone()))?
                 .serve_at(
                     DBUS_PATH,
@@ -199,6 +204,14 @@ pub(crate) async fn process_changes(
                             log::error!("Error sending background config request event: {:?}", err);
                         }
                     }
+                    Event::BackgroundToplevels => {
+                        let background = conn
+                            .object_server()
+                            .interface::<_, Background>(DBUS_PATH)
+                            .await?;
+                        Background::running_applications_changed(background.signal_context())
+                            .await?;
+                    }
                     Event::Accent(a) => {
                         let object_server = conn.object_server();
                         let iface_ref = object_server.interface::<_, Settings>(DBUS_PATH).await?;

src/wayland/mod.rs

@@ -87,6 +87,7 @@ struct WaylandHelperInner {
     output_infos: Mutex<HashMap<wl_output::WlOutput, OutputInfo>>,
     output_toplevels: Mutex<HashMap<wl_output::WlOutput, Vec<ZcosmicToplevelHandleV1>>>,
     toplevels: Mutex<Vec<(ZcosmicToplevelHandleV1, ToplevelInfo)>>,
+    toplevel_update: Arc<(Mutex<bool>, Condvar)>,
     qh: QueueHandle<AppData>,
     screencopy_manager: zcosmic_screencopy_manager_v2::ZcosmicScreencopyManagerV2,
     output_source_manager: ZcosmicOutputImageSourceManagerV1,
@@ -167,6 +168,12 @@ impl AppData {
             .toplevels()
             .filter_map(|(handle, info)| Some((handle.clone(), info?.clone())))
             .collect();
+
+        // Signal that toplevels were updated; the actual updates are unimportant here
+        let (lock, cvar) = &*self.wayland_helper.inner.toplevel_update;
+        let mut updated = lock.lock().unwrap();
+        *updated = true;
+        cvar.notify_all();
     }
 }
 
@@ -250,13 +257,15 @@ impl WaylandHelper {
         let screencopy_state = ScreencopyState::new(&globals, &qh);
         let shm_state = Shm::bind(&globals, &qh).unwrap();
         let zwp_dmabuf = globals.bind(&qh, 4..=4, sctk::globals::GlobalData).unwrap();
+        let toplevel_update = Arc::new((Mutex::new(false), Condvar::new()));
         let wayland_helper = WaylandHelper {
             inner: Arc::new(WaylandHelperInner {
                 conn,
                 outputs: Mutex::new(Vec::new()),
                 output_infos: Mutex::new(HashMap::new()),
                 output_toplevels: Mutex::new(HashMap::new()),
                 toplevels: Mutex::new(Vec::new()),
+                toplevel_update,
                 qh: qh.clone(),
                 screencopy_manager: screencopy_state.screencopy_manager.clone(),
                 output_source_manager: screencopy_state.output_source_manager.clone().unwrap(),
@@ -304,6 +313,10 @@ impl WaylandHelper {
         self.inner.toplevels.lock().unwrap().clone()
     }
 
+    pub fn toplevel_signal(&self) -> Arc<(Mutex<bool>, Condvar)> {
+        Arc::clone(&self.inner.toplevel_update)
+    }
+
     pub fn output_info(&self, output: &wl_output::WlOutput) -> Option<OutputInfo> {
         self.inner.output_infos.lock().unwrap().get(output).cloned()
     }