feat: Support live regions on Unix (#299)

Author: DataTriny

platforms/unix/src/adapter.rs

@@ -19,7 +19,7 @@ use crate::{
 use accesskit::{ActionHandler, NodeId, Rect, Role, TreeUpdate};
 use accesskit_consumer::{DetachedNode, FilterResult, Node, Tree, TreeChangeHandler, TreeState};
 use async_channel::{Receiver, Sender};
-use atspi::{Interface, InterfaceSet, State};
+use atspi::{Interface, InterfaceSet, Live, State};
 use futures_lite::StreamExt;
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
@@ -52,6 +52,22 @@ impl AdapterChangeHandler<'_> {
                 .unwrap();
             self.adapter.window_created(adapter_index, node.id());
         }
+
+        let live = node.live();
+        if live != Live::None {
+            if let Some(name) = node.name() {
+                self.adapter
+                    .events
+                    .send_blocking(Event::Object {
+                        target: ObjectId::Node {
+                            adapter: self.adapter.id,
+                            node: node.id(),
+                        },
+                        event: ObjectEvent::Announcement(name, live),
+                    })
+                    .unwrap();
+            }
+        }
     }
 
     fn remove_node(&mut self, node: &DetachedNode) {
@@ -409,7 +425,7 @@ impl Adapter {
                     adapter: self.id,
                     node: window.id(),
                 },
-                name: window.name(),
+                name: window.name().unwrap_or_default(),
                 event: WindowEvent::Activated,
             })
             .unwrap();
@@ -440,7 +456,7 @@ impl Adapter {
                     adapter: self.id,
                     node: window.id(),
                 },
-                name: window.name(),
+                name: window.name().unwrap_or_default(),
                 event: WindowEvent::Deactivated,
             })
             .unwrap();

platforms/unix/src/atspi/bus.rs

@@ -101,6 +101,7 @@ impl Bus {
         let interface = "org.a11y.atspi.Event.Object";
         let signal = match event {
             ObjectEvent::ActiveDescendantChanged(_) => "ActiveDescendantChanged",
+            ObjectEvent::Announcement(_, _) => "Announcement",
             ObjectEvent::BoundsChanged(_) => "BoundsChanged",
             ObjectEvent::ChildAdded(_, _) | ObjectEvent::ChildRemoved(_) => "ChildrenChanged",
             ObjectEvent::PropertyChanged(_) => "PropertyChange",
@@ -123,6 +124,21 @@ impl Bus {
                 )
                 .await
             }
+            ObjectEvent::Announcement(message, politeness) => {
+                self.emit_event(
+                    target,
+                    interface,
+                    signal,
+                    EventBody {
+                        kind: "",
+                        detail1: politeness as i32,
+                        detail2: 0,
+                        any_data: message.into(),
+                        properties,
+                    },
+                )
+                .await
+            }
             ObjectEvent::BoundsChanged(bounds) => {
                 self.emit_event(
                     target,

platforms/unix/src/atspi/interfaces/events.rs

@@ -4,7 +4,7 @@
 // the LICENSE-MIT file), at your option.
 
 use crate::atspi::{ObjectId, Rect};
-use atspi::{Role, State};
+use atspi::{Live, Role, State};
 
 pub(crate) enum Event {
     Object {
@@ -29,6 +29,7 @@ pub(crate) enum Property {
 #[allow(clippy::enum_variant_names)]
 pub(crate) enum ObjectEvent {
     ActiveDescendantChanged(ObjectId),
+    Announcement(String, Live),
     BoundsChanged(Rect),
     ChildAdded(usize, ObjectId),
     ChildRemoved(ObjectId),

platforms/unix/src/node.rs

@@ -18,12 +18,15 @@ use crate::{
     util::WindowBounds,
 };
 use accesskit::{
-    Action, ActionData, ActionRequest, Affine, Checked, DefaultActionVerb, NodeId, Point, Rect,
-    Role,
+    Action, ActionData, ActionRequest, Affine, Checked, DefaultActionVerb, Live, NodeId, Point,
+    Rect, Role,
 };
 use accesskit_consumer::{DetachedNode, FilterResult, Node, NodeState, TreeState};
 use async_channel::Sender;
-use atspi::{CoordType, Interface, InterfaceSet, Layer, Role as AtspiRole, State, StateSet};
+use atspi::{
+    CoordType, Interface, InterfaceSet, Layer, Live as AtspiLive, Role as AtspiRole, State,
+    StateSet,
+};
 use std::{
     iter::FusedIterator,
     sync::{Arc, RwLock, RwLockReadGuard, Weak},
@@ -56,12 +59,11 @@ impl<'a> NodeWrapper<'a> {
         }
     }
 
-    pub fn name(&self) -> String {
+    pub fn name(&self) -> Option<String> {
         match self {
             Self::Node { node, .. } => node.name(),
             Self::DetachedNode { node, .. } => node.name(),
         }
-        .unwrap_or_default()
     }
 
     pub fn description(&self) -> String {
@@ -412,6 +414,18 @@ impl<'a> NodeWrapper<'a> {
         interfaces
     }
 
+    pub(crate) fn live(&self) -> AtspiLive {
+        let live = match self {
+            Self::Node { node, .. } => node.live(),
+            Self::DetachedNode { node, .. } => node.live(),
+        };
+        match live {
+            Live::Off => AtspiLive::None,
+            Live::Polite => AtspiLive::Polite,
+            Live::Assertive => AtspiLive::Assertive,
+        }
+    }
+
     fn n_actions(&self) -> i32 {
         match self.node_state().default_action_verb() {
             Some(_) => 1,
@@ -502,15 +516,29 @@ impl<'a> NodeWrapper<'a> {
         let adapter = self.adapter();
         let name = self.name();
         if name != old.name() {
+            let name = name.unwrap_or_default();
             events
                 .send_blocking(Event::Object {
                     target: ObjectId::Node {
                         adapter,
                         node: self.id(),
                     },
-                    event: ObjectEvent::PropertyChanged(Property::Name(name)),
+                    event: ObjectEvent::PropertyChanged(Property::Name(name.clone())),
                 })
                 .unwrap();
+
+            let live = self.live();
+            if live != AtspiLive::None {
+                events
+                    .send_blocking(Event::Object {
+                        target: ObjectId::Node {
+                            adapter,
+                            node: self.id(),
+                        },
+                        event: ObjectEvent::Announcement(name, live),
+                    })
+                    .unwrap();
+            }
         }
         let description = self.description();
         if description != old.description() {
@@ -707,7 +735,7 @@ impl PlatformNode {
     pub fn name(&self) -> fdo::Result<String> {
         self.resolve(|node| {
             let wrapper = self.node_wrapper(&node);
-            Ok(wrapper.name())
+            Ok(wrapper.name().unwrap_or_default())
         })
     }