backend: add DevicesEnumerated event

src/backend.rs

@@ -142,6 +142,7 @@ pub enum BackendEvent {
     NewDrmDevice(Rc<dyn BackendDrmDevice>),
     NewConnector(Rc<dyn Connector>),
     NewInputDevice(Rc<dyn InputDevice>),
+    DevicesEnumerated,
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]

src/backends/metal.rs

@@ -31,6 +31,7 @@ use {
             clonecell::{CloneCell, UnsafeCellCloneSafe},
             copyhashmap::CopyHashMap,
             errorfmt::ErrorFmt,
+            numcell::NumCell,
             oserror::OsError,
             smallmap::SmallMap,
             syncqueue::SyncQueue,
@@ -226,6 +227,7 @@ pub async fn create(state: &Rc<State>) -> Result<Rc<MetalBackend>, MetalError> {
         input_devices: Default::default(),
         drm_devices: Default::default(),
         pending_drm_devices: Default::default(),
+        num_pending_devices: Default::default(),
     });
     let udev = Rc::new(Udev::new()?);
     let monitor = Rc::new(udev.create_monitor()?);
@@ -309,6 +311,7 @@ struct DeviceHolder {
     input_devices: RefCell<Vec<Option<Rc<MetalInputDevice>>>>,
     drm_devices: CopyHashMap<c::dev_t, Rc<MetalDrmDeviceData>>,
     pending_drm_devices: CopyHashMap<c::dev_t, PendingDrmDevice>,
+    num_pending_devices: NumCell<u32>,
 }
 
 impl LibInputAdapter for DeviceHolder {

src/backends/metal/monitor.rs

@@ -5,11 +5,13 @@ use {
             video::{MetalDrmDeviceData, PendingDrmDevice},
             MetalBackend, MetalDevice, MetalError, MetalInputDevice,
         },
-        dbus::TRUE,
+        dbus::{DbusError, TRUE},
         udev::UdevDevice,
         utils::{bitflags::BitflagsExt, errorfmt::ErrorFmt, nonblock::set_nonblock},
         video::drm::DrmMaster,
-        wire_dbus::org::freedesktop::login1::session::{PauseDevice, ResumeDevice},
+        wire_dbus::org::freedesktop::login1::session::{
+            PauseDevice, ResumeDevice, TakeDeviceReply,
+        },
     },
     bstr::ByteSlice,
     std::{cell::Cell, rc::Rc},
@@ -199,7 +201,7 @@ impl MetalBackend {
         };
         self.device_holder.pending_drm_devices.set(devnum, dev);
         let slf = self.clone();
-        self.session.get_device(devnum, move |res| {
+        self.get_device(devnum, move |res| {
             let dev = match slf.device_holder.pending_drm_devices.remove(&devnum) {
                 Some(d) if d.id == id => d,
                 _ => return,
@@ -303,7 +305,7 @@ impl MetalBackend {
         self.device_holder
             .devices
             .set(devnum, MetalDevice::Input(dev));
-        self.session.get_device(devnum, move |res| {
+        self.get_device(devnum, move |res| {
             let id = &slf.device_holder.devices;
             let mut slots = slf.device_holder.input_devices.borrow_mut();
             let dev = 'dev: {
@@ -345,4 +347,23 @@ impl MetalBackend {
         });
         None
     }
+
+    fn get_device<F>(self: &Rc<Self>, dev: c::dev_t, f: F)
+    where
+        F: FnOnce(Result<&TakeDeviceReply, DbusError>) + 'static,
+    {
+        self.device_holder.num_pending_devices.fetch_add(1);
+        let slf = self.clone();
+        self.session.get_device(dev, move |res| {
+            let rem = slf.device_holder.num_pending_devices.fetch_sub(1);
+            f(res);
+            if rem == 1 {
+                slf.state
+                    .backend_events
+                    .push(BackendEvent::DevicesEnumerated);
+                // Set to 1 to ensure this branch is never taken again.
+                slf.device_holder.num_pending_devices.set(1);
+            }
+        })
+    }
 }

src/backends/x.rs

@@ -299,6 +299,10 @@ impl XBackend {
             self.active_output(output).await;
         }
 
+        self.state
+            .backend_events
+            .push(BackendEvent::DevicesEnumerated);
+
         pending().await
     }
 

src/config.rs

@@ -122,6 +122,10 @@ impl ConfigProxy {
         self.send(&ServerMessage::GraphicsInitialized);
     }
 
+    pub fn devices_enumerated(&self) {
+        self.send(&ServerMessage::DevicesEnumerated);
+    }
+
     pub fn clear(&self) {
         self.send(&ServerMessage::Clear);
     }

src/it/test_config.rs

@@ -105,6 +105,7 @@ unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
         ServerMessage::NewDrmDev { .. } => {}
         ServerMessage::DelDrmDev { .. } => {}
         ServerMessage::Idle => {}
+        ServerMessage::DevicesEnumerated => {}
     }
 }
 

src/state.rs

@@ -268,6 +268,12 @@ impl State {
         self.reload_cursors();
     }
 
+    pub fn devices_enumerated(&self) {
+        if let Some(config) = self.config.get() {
+            config.devices_enumerated()
+        }
+    }
+
     pub fn set_render_ctx(&self, ctx: Option<&Rc<RenderContext>>) {
         self.render_ctx.set(ctx.cloned());
         self.render_ctx_version.fetch_add(1);

src/tasks/backend.rs

@@ -25,6 +25,7 @@ impl BackendEventHandler {
             BackendEvent::NewConnector(connector) => connector::handle(&self.state, &connector),
             BackendEvent::NewInputDevice(s) => input_device::handle(&self.state, s),
             BackendEvent::NewDrmDevice(d) => drmdev::handle(&self.state, d),
+            BackendEvent::DevicesEnumerated => self.state.devices_enumerated(),
         }
     }
 }