tablero 0.4.3

//! BlueZ bluetooth source.
//!
//! Reads the local Bluetooth adapter state over the system DBus and emits
//! typed [`Msg::Bluetooth`] snapshots through the [producer
//! bridge](crate::producer), so the adapter reaches the render loop the same
//! way every other message does — the rendering code never talks to DBus
//! directly.
//!
//! BlueZ exposes every adapter and paired device through
//! `org.freedesktop.DBus.ObjectManager` at the well-known name `org.bluez`:
//! `GetManagedObjects` returns the full tree of `org.bluez.Adapter1` and
//! `org.bluez.Device1` instances as a `{path: {iface: props}}` map. The
//! producer reads that map, normalizes it into a [`Bluetooth`] snapshot, and
//! emits it whenever it differs from the last one sent.
//!
//! Normalization lives in [`bluetooth_from_bluez`], a pure function the
//! tests drive directly — the full DBus value → message → widget path is
//! covered without a live system bus.
//!
//! Re-reads are driven by BlueZ's own signals, not a timer. Adapters and
//! devices appear and disappear dynamically, so rather than per-proxy property
//! streams (which would miss objects added after startup) the producer holds a
//! single match rule on every signal `org.bluez` sends and re-reads the whole
//! map when one could change the snapshot (`signal_changes_state`). An idle
//! adapter therefore costs nothing: no timer, no DBus call, no message. A slow
//! resync remains as a safety net for a missed signal.

use std::collections::HashMap;
use std::time::Duration;

use futures_util::FutureExt;
use futures_util::stream::{StreamExt, select};
use log::warn;
use tokio::time::{sleep, timeout};
use zbus::fdo::DBusProxy;
use zbus::message::Type;
use zbus::zvariant::{OwnedObjectPath, OwnedValue};
use zbus::{Connection, MatchRule, Message, MessageStream, proxy};

use crate::widget::{Bluetooth, BluetoothState, Msg};

use crate::producer::{MsgSender, Producer, ProducerFuture, ProducerResult};

/// How often the producer re-reads BlueZ without having seen a signal.
///
/// Changes arrive as signals; this only bounds how long a missed one could
/// leave the widget stale, so it is slow enough not to matter to an idle CPU.
const DEFAULT_INTERVAL: Duration = Duration::from_secs(60);

/// How long to let a burst of signals finish before re-reading once. Powering
/// an adapter or connecting a device emits several in quick succession.
const SETTLE: Duration = Duration::from_millis(150);

/// BlueZ's well-known bus name.
const BLUEZ: &str = "org.bluez";

/// Signals kept queued while a read is in flight; a burst beyond this is
/// collapsed into the one re-read anyway.
const MAX_QUEUED_SIGNALS: usize = 64;

/// The `org.bluez.Adapter1` interface name — the marker the ObjectManager
/// map uses to distinguish adapters from devices.
const ADAPTER_IFACE: &str = "org.bluez.Adapter1";

/// The `org.bluez.Device1` interface name — the marker the ObjectManager
/// map uses to distinguish devices from adapters.
const DEVICE_IFACE: &str = "org.bluez.Device1";

/// Normalize the BlueZ readings into a [`Bluetooth`] snapshot.
///
/// The producer may discover any combination of (no adapter / one adapter /
/// many adapters); this function folds all of those onto the three states
/// the bar actually displays:
///
/// * `adapter_count == 0` → [`Unavailable`](BluetoothState::Unavailable),
///   regardless of `powered` (a stale `powered` from before an adapter was
///   removed can never leak into a "powered off" reading on hardware with
///   no adapter);
/// * `adapter_count >= 1`, `powered == Some(true)` →
///   [`On`](BluetoothState::On) with `connected`;
/// * `adapter_count >= 1`, `powered == Some(false)` →
///   [`Off`](BluetoothState::Off) (the connected count is irrelevant when
///   the adapter is off and is forced to zero inside [`Bluetooth::new`]);
/// * `adapter_count >= 1`, `powered == None` →
///   [`Unavailable`](BluetoothState::Unavailable) — BlueZ didn't tell us.
///
/// Pure over its inputs: the integration tests drive the full BlueZ value →
/// message → widget path through this without a live bus.
pub fn bluetooth_from_bluez(
    adapter_count: usize,
    powered: Option<bool>,
    connected: u32,
) -> Bluetooth {
    if adapter_count == 0 {
        return Bluetooth::new(BluetoothState::Unavailable, 0);
    }
    match powered {
        Some(true) => Bluetooth::new(BluetoothState::On, connected),
        Some(false) => Bluetooth::new(BluetoothState::Off, 0),
        None => Bluetooth::new(BluetoothState::Unavailable, 0),
    }
}

/// Read a `bool` property out of an interface's property map.
///
/// BlueZ exposes its properties as a `HashMap<String, OwnedValue>` per
/// interface in `GetManagedObjects`. A missing property, a non-`bool`
/// payload, or an out-of-range value all degrade to `None` rather than
/// failing the whole read, so a transient type drift never takes the source
/// down.
fn read_bool(props: &HashMap<String, OwnedValue>, key: &str) -> Option<bool> {
    props.get(key).and_then(|v| bool::try_from(v).ok())
}

/// Walk an `ObjectManager` snapshot and extract the readings needed for the
/// bluetooth widget.
///
/// BlueZ may expose multiple adapters on machines with a wired and a
/// wireless adapter (USB dongles, laptops with both an internal adapter and
/// an external one). The bar shows a single power-state word, so the
/// readings are aggregated across **every** adapter rather than picking one:
///
/// * the power state is "on" if **any** adapter is powered, "off" if no
///   adapter is on and at least one explicitly reports `Powered = false`,
///   and "unknown" only when every adapter failed to report power at all;
/// * the connected-device count is the sum across every adapter's devices,
///   so a user with two adapters sees the right total.
///
/// Picking a single adapter and counting devices against it would let the
/// reported power state and connected count disagree — e.g. the smallest
/// adapter off, a second adapter on with two devices, the bar would say
/// "off" but the count would already be 2. Aggregating keeps the two
/// readings tied to the same scope.
fn summarize(
    objects: &HashMap<OwnedObjectPath, HashMap<String, HashMap<String, OwnedValue>>>,
) -> (usize, Option<bool>, u32) {
    let mut adapter_count = 0usize;
    let mut any_on = false;
    let mut any_off = false;

    for interfaces in objects.values() {
        let Some(adapter_props) = interfaces.get(ADAPTER_IFACE) else {
            continue;
        };
        adapter_count += 1;
        match read_bool(adapter_props, "Powered") {
            Some(true) => any_on = true,
            Some(false) => any_off = true,
            None => {}
        }
    }

    // Power-state rule: any adapter on → on; otherwise, any adapter
    // explicitly off → off; otherwise unknown. A transient BlueZ hiccup
    // on every adapter is the only path to `None` — the rule does not
    // require *every* adapter to be off, only that at least one is and
    // none is on. The count below is the total over all adapters
    // (meaningful only when at least one is on, but the
    // bluetooth_from_bluez normalization zeroes the count for any other
    // state so this stays consistent).
    let powered = if any_on {
        Some(true)
    } else if any_off {
        Some(false)
    } else {
        None
    };

    let mut connected: u32 = 0;
    for interfaces in objects.values() {
        if let Some(device_props) = interfaces.get(DEVICE_IFACE) {
            // The Connected property is what tells the bar a device is
            // actively paired and bonded for the current session; `Paired`
            // alone means "was paired once" and `Trusted` is just user
            // intent.
            if read_bool(device_props, "Connected") == Some(true) {
                connected = connected.saturating_add(1);
            }
        }
    }

    (adapter_count, powered, connected)
}

/// The subset of `org.freedesktop.DBus.ObjectManager` BlueZ implements, used
/// to enumerate adapters and devices in one round trip. zbus generates
/// `ObjectManagerProxy` from this.
#[proxy(
    interface = "org.freedesktop.DBus.ObjectManager",
    default_service = "org.bluez",
    default_path = "/"
)]
trait ObjectManager {
    /// Return every managed object under `default_path`, as
    /// `{object_path: {interface_name: properties}}`. Filtering on the
    /// `org.bluez.Adapter1` and `org.bluez.Device1` interface names picks
    /// out the adapters and devices the bar cares about.
    fn get_managed_objects(
        &self,
    ) -> zbus::Result<HashMap<OwnedObjectPath, HashMap<String, HashMap<String, OwnedValue>>>>;
}

/// Read BlueZ's current adapter state and normalize it into a snapshot.
///
/// A failed read degrades to a fresh snapshot with `adapter_count = 0`
/// (i.e. [`Unavailable`](BluetoothState::Unavailable)) and a logged
/// warning rather than ending the stream — a transient DBus hiccup never
/// takes the source down.
async fn read_snapshot(om: &ObjectManagerProxy<'_>) -> Bluetooth {
    match om.get_managed_objects().await {
        Ok(objects) => {
            let (adapter_count, powered, connected) = summarize(&objects);
            bluetooth_from_bluez(adapter_count, powered, connected)
        }
        Err(e) => {
            warn!("bluetooth: reading BlueZ state failed: {e}");
            Bluetooth::new(BluetoothState::Unavailable, 0)
        }
    }
}

/// Whether a signal from BlueZ could change the [`Bluetooth`] snapshot.
///
/// Objects coming and going always can. Of the property changes only an
/// adapter's `Powered` and a device's `Connected` are displayed; the rest —
/// notably the `RSSI` updates that stream in for every nearby device while
/// something is scanning — must not cost a re-read each.
fn signal_changes_state(message: &Message) -> bool {
    let header = message.header();
    let (Some(interface), Some(member)) = (header.interface(), header.member()) else {
        return false;
    };
    match (interface.as_str(), member.as_str()) {
        ("org.freedesktop.DBus.ObjectManager", "InterfacesAdded" | "InterfacesRemoved") => true,
        ("org.freedesktop.DBus.Properties", "PropertiesChanged") => message
            .body()
            .deserialize::<(String, HashMap<String, OwnedValue>, Vec<String>)>()
            .is_ok_and(|(interface, changed, invalidated)| {
                let names = changed.keys().chain(&invalidated).map(String::as_str);
                property_change_is_displayed(&interface, names)
            }),
        _ => false,
    }
}

/// Whether a `PropertiesChanged` on `interface` touching `names` is one the
/// widget shows. Pure over its input.
fn property_change_is_displayed<'a>(
    interface: &str,
    mut names: impl Iterator<Item = &'a str>,
) -> bool {
    match interface {
        ADAPTER_IFACE => names.any(|name| name == "Powered"),
        DEVICE_IFACE => names.any(|name| name == "Connected"),
        _ => false,
    }
}

/// A [`Producer`] that follows BlueZ's local adapter state and emits
/// [`Msg::Bluetooth`] snapshots on every change.
///
/// Construct with [`new`](BluetoothProducer::new) and hand it to the
/// producer bridge; it reads an initial snapshot, then re-reads whenever BlueZ
/// signals a change until the system bus closes or the render loop shuts down.
pub struct BluetoothProducer {
    interval: Duration,
}

impl BluetoothProducer {
    /// Create a bluetooth producer resyncing at the default cadence.
    pub fn new() -> Self {
        Self {
            interval: DEFAULT_INTERVAL,
        }
    }

    /// Create a producer resyncing at a custom `interval` (used by tests).
    pub fn with_interval(interval: Duration) -> Self {
        Self { interval }
    }
}

impl Default for BluetoothProducer {
    fn default() -> Self {
        Self::new()
    }
}

impl Producer for BluetoothProducer {
    fn name(&self) -> String {
        "bluetooth".to_string()
    }

    fn run(self: Box<Self>, tx: MsgSender) -> ProducerFuture {
        Box::pin(run(tx, self.interval))
    }
}

/// Drive the producer: connect to the system bus, seed the bar with the
/// initial snapshot, then re-read on every relevant BlueZ signal, on BlueZ
/// appearing or vanishing, and at the slow `resync` cadence.
///
/// A failed system-bus connection propagates as an error the bridge logs
/// and isolates — the bar keeps running, the bluetooth widget simply stays
/// `unavailable`. A failed read is logged and degrades to
/// [`Unavailable`](BluetoothState::Unavailable); the next event retries the
/// live read.
///
/// [`Unavailable`]: crate::widget::BluetoothState::Unavailable
async fn run(tx: MsgSender, resync: Duration) -> ProducerResult {
    let conn = Connection::system().await?;
    let om = ObjectManagerProxy::new(&conn).await?;

    // One rule for every object BlueZ has or will have. The bus resolves the
    // well-known name per signal, so it keeps matching across a BlueZ restart.
    let rule = MatchRule::builder()
        .msg_type(Type::Signal)
        .sender(BLUEZ)?
        .build();
    let signals = MessageStream::for_match_rule(rule, &conn, Some(MAX_QUEUED_SIGNALS))
        .await?
        .filter_map(|message| async move {
            message
                .is_ok_and(|message| signal_changes_state(&message))
                .then_some(())
        });
    // A vanished BlueZ sends nothing, so watch its name too.
    let owners = DBusProxy::new(&conn)
        .await?
        .receive_name_owner_changed_with_args(&[(0, BLUEZ)])
        .await?
        .map(|_| ());
    let events = select(signals, owners);
    futures_util::pin_mut!(events);

    // Subscribed before the first read, so a change racing with it stays
    // queued and causes another read instead of being lost.
    let mut sent = None;
    loop {
        if !send_if_changed(&tx, &mut sent, read_snapshot(&om).await) {
            return Ok(());
        }
        if let Ok(None) = timeout(resync, events.next()).await {
            return Ok(());
        }
        // Let the rest of a burst arrive, then answer it with a single read.
        sleep(SETTLE).await;
        while let Some(Some(())) = events.next().now_or_never() {}
    }
}

/// Send `snapshot` unless it is what the widget already shows. Returns `false`
/// once the render loop has gone away.
fn send_if_changed(tx: &MsgSender, sent: &mut Option<Bluetooth>, snapshot: Bluetooth) -> bool {
    if *sent == Some(snapshot) {
        return true;
    }
    *sent = Some(snapshot);
    tx.send(Msg::Bluetooth(snapshot)).is_ok()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn empty_objects() -> HashMap<OwnedObjectPath, HashMap<String, HashMap<String, OwnedValue>>> {
        HashMap::new()
    }

    fn adapter_with(powered: Option<bool>) -> HashMap<String, OwnedValue> {
        let mut props = HashMap::new();
        if let Some(p) = powered {
            props.insert("Powered".to_string(), OwnedValue::from(p));
        }
        props
    }

    fn device_with(connected: Option<bool>) -> HashMap<String, OwnedValue> {
        let mut props = HashMap::new();
        if let Some(c) = connected {
            props.insert("Connected".to_string(), OwnedValue::from(c));
        }
        props
    }

    fn insert_adapter(
        objects: &mut HashMap<OwnedObjectPath, HashMap<String, HashMap<String, OwnedValue>>>,
        path: &str,
        props: HashMap<String, OwnedValue>,
    ) {
        let mut ifaces = HashMap::new();
        ifaces.insert(ADAPTER_IFACE.to_string(), props);
        objects.insert(OwnedObjectPath::try_from(path).unwrap(), ifaces);
    }

    fn insert_device(
        objects: &mut HashMap<OwnedObjectPath, HashMap<String, HashMap<String, OwnedValue>>>,
        path: &str,
        props: HashMap<String, OwnedValue>,
    ) {
        let mut ifaces = HashMap::new();
        ifaces.insert(DEVICE_IFACE.to_string(), props);
        objects.insert(OwnedObjectPath::try_from(path).unwrap(), ifaces);
    }

    #[test]
    fn no_adapter_normalizes_to_unavailable_regardless_of_powered() {
        // A stale `powered` from before the adapter was unplugged must not
        // leak back into the bar as `off` — the snapshot says "no adapter".
        for powered in [None, Some(true), Some(false)] {
            assert_eq!(
                bluetooth_from_bluez(0, powered, 0).state(),
                BluetoothState::Unavailable
            );
        }
    }

    #[test]
    fn powered_adapter_normalizes_to_on_with_the_connected_count() {
        assert_eq!(
            bluetooth_from_bluez(1, Some(true), 0),
            Bluetooth::new(BluetoothState::On, 0)
        );
        assert_eq!(
            bluetooth_from_bluez(1, Some(true), 2),
            Bluetooth::new(BluetoothState::On, 2)
        );
    }

    #[test]
    fn unpowered_adapter_normalizes_to_off_with_zero_connected() {
        // Even if BlueZ hands a non-zero connected count alongside a powered
        // off adapter, the normalized snapshot zeroes it.
        assert_eq!(
            bluetooth_from_bluez(1, Some(false), 5),
            Bluetooth::new(BluetoothState::Off, 0)
        );
    }

    #[test]
    fn missing_powered_with_an_adapter_normalizes_to_unavailable() {
        // The adapter exists but didn't tell us whether it's on — show
        // `unavailable` rather than guess.
        assert_eq!(
            bluetooth_from_bluez(1, None, 0).state(),
            BluetoothState::Unavailable
        );
    }

    #[test]
    fn summarize_with_no_objects_reports_zero_adapters_and_unknown_power() {
        let (count, powered, connected) = summarize(&empty_objects());
        assert_eq!(count, 0);
        assert_eq!(powered, None);
        assert_eq!(connected, 0);
    }

    #[test]
    fn summarize_aggregates_power_across_all_adapters() {
        // Two adapters: hci0 powered, hci1 unpowered. Any-on wins: the bar
        // sees "on" and counts devices across both adapters.
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(Some(true)));
        insert_adapter(&mut objects, "/org/bluez/hci1", adapter_with(Some(false)));
        let (count, powered, connected) = summarize(&objects);
        assert_eq!(count, 2);
        assert_eq!(powered, Some(true));
        assert_eq!(connected, 0);
    }

    #[test]
    fn summarize_power_is_off_when_no_adapter_is_on_and_at_least_one_is() {
        // hci0 reports no Powered at all (transient) but hci1 says off:
        // no adapter is on, and at least one explicitly says off, so the
        // bar settles on `off` — the rule does not require *every*
        // adapter to be off, only that at least one is and none is on.
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(None));
        insert_adapter(&mut objects, "/org/bluez/hci1", adapter_with(Some(false)));
        let (_, powered, _) = summarize(&objects);
        assert_eq!(powered, Some(false));
    }

    #[test]
    fn summarize_power_is_unknown_when_every_adapter_omits_powered() {
        // No adapter told us anything about power: degrade to "unknown"
        // rather than guessing.
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(None));
        insert_adapter(&mut objects, "/org/bluez/hci1", adapter_with(None));
        let (_, powered, _) = summarize(&objects);
        assert_eq!(powered, None);
    }

    #[test]
    fn summarize_aggregation_is_independent_of_path_iteration_order() {
        // The same set of adapters inserted in the opposite order must
        // resolve to the same `powered` reading. `summarize` no longer sorts
        // adapter paths, so the result has to be independent of HashMap
        // iteration order — the aggregation iterates every adapter and
        // combines, which is by definition order-independent.
        let mut objects_a = empty_objects();
        insert_adapter(&mut objects_a, "/org/bluez/hci0", adapter_with(Some(true)));
        insert_adapter(&mut objects_a, "/org/bluez/hci1", adapter_with(Some(false)));
        let mut objects_b = empty_objects();
        insert_adapter(&mut objects_b, "/org/bluez/hci1", adapter_with(Some(false)));
        insert_adapter(&mut objects_b, "/org/bluez/hci0", adapter_with(Some(true)));
        let (count_a, powered_a, connected_a) = summarize(&objects_a);
        let (count_b, powered_b, connected_b) = summarize(&objects_b);
        assert_eq!(
            (count_a, powered_a, connected_a),
            (count_b, powered_b, connected_b)
        );
    }

    #[test]
    fn summarize_power_state_and_connected_count_share_the_same_scope() {
        // The bug this regression test pins down: with hci0 off and hci1
        // on with two devices, the bar must say "on" with 2 connected —
        // never "off" with 2 connected, which would have been possible if
        // summarize had picked hci0 for power but summed devices across
        // both adapters.
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(Some(false)));
        insert_adapter(&mut objects, "/org/bluez/hci1", adapter_with(Some(true)));
        insert_device(
            &mut objects,
            "/org/bluez/hci1/dev_AA",
            device_with(Some(true)),
        );
        insert_device(
            &mut objects,
            "/org/bluez/hci1/dev_BB",
            device_with(Some(true)),
        );
        let (count, powered, connected) = summarize(&objects);
        assert_eq!(count, 2);
        assert_eq!(powered, Some(true));
        assert_eq!(connected, 2);
        // And the normalization must surface that as "on" with 2 connected.
        assert_eq!(
            bluetooth_from_bluez(count, powered, connected),
            Bluetooth::new(BluetoothState::On, 2)
        );
    }

    #[test]
    fn summarize_counts_connected_devices_across_adapters() {
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(Some(true)));
        // One connected device, one disconnected — only the connected one counts.
        insert_device(
            &mut objects,
            "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF",
            device_with(Some(true)),
        );
        insert_device(
            &mut objects,
            "/org/bluez/hci0/dev_11_22_33_44_55_66",
            device_with(Some(false)),
        );
        insert_device(
            &mut objects,
            "/org/bluez/hci0/dev_DE_AD_BE_EF",
            device_with(None),
        );
        // A second adapter with one of its devices connected.
        insert_adapter(&mut objects, "/org/bluez/hci1", adapter_with(Some(true)));
        insert_device(
            &mut objects,
            "/org/bluez/hci1/dev_AB_CD_EF_00_11_22",
            device_with(Some(true)),
        );
        let (count, powered, connected) = summarize(&objects);
        assert_eq!(count, 2);
        assert_eq!(powered, Some(true));
        assert_eq!(connected, 2);
    }

    #[test]
    fn summarize_ignores_devices_with_unknown_connected() {
        // A device that hasn't reported Connected yet counts as zero — we
        // only count affirmative `Connected = true` readings.
        let mut objects = empty_objects();
        insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(Some(true)));
        insert_device(&mut objects, "/org/bluez/hci0/dev_AA", device_with(None));
        let (_, _, connected) = summarize(&objects);
        assert_eq!(connected, 0);
    }

    #[test]
    fn bluetooth_bluez_round_trip_drives_visible_labels() {
        // The full BlueZ value → Bluetooth snapshot → label pipeline, end to
        // end, without a live system bus.
        let powered_on = {
            let mut objects = empty_objects();
            insert_adapter(&mut objects, "/org/bluez/hci0", adapter_with(Some(true)));
            insert_device(
                &mut objects,
                "/org/bluez/hci0/dev_AA",
                device_with(Some(true)),
            );
            insert_device(
                &mut objects,
                "/org/bluez/hci0/dev_BB",
                device_with(Some(true)),
            );
            let (count, powered, connected) = summarize(&objects);
            bluetooth_from_bluez(count, powered, connected)
        };
        assert_eq!(powered_on.state(), BluetoothState::On);
        assert_eq!(powered_on.connected(), 2);
        assert_eq!(powered_on.label(), "2 connected");

        let powered_off = bluetooth_from_bluez(1, Some(false), 0);
        assert_eq!(powered_off.state(), BluetoothState::Off);
        assert_eq!(powered_off.label(), "off");

        let no_adapter = bluetooth_from_bluez(0, None, 0);
        assert_eq!(no_adapter.state(), BluetoothState::Unavailable);
        assert_eq!(no_adapter.label(), "unavailable");
    }

    fn properties_changed(interface: &str, changed: &[&str], invalidated: &[&str]) -> Message {
        let changed: HashMap<&str, OwnedValue> = changed
            .iter()
            .map(|name| (*name, OwnedValue::from(true)))
            .collect();
        Message::signal(
            "/org/bluez/hci0",
            "org.freedesktop.DBus.Properties",
            "PropertiesChanged",
        )
        .unwrap()
        .build(&(interface, changed, invalidated))
        .unwrap()
    }

    #[test]
    fn displayed_property_changes_cause_a_re_read() {
        assert!(signal_changes_state(&properties_changed(
            ADAPTER_IFACE,
            &["Powered"],
            &[]
        )));
        assert!(signal_changes_state(&properties_changed(
            DEVICE_IFACE,
            &["ServicesResolved", "Connected"],
            &[]
        )));
        // A property BlueZ only invalidates still has to be read back.
        assert!(signal_changes_state(&properties_changed(
            DEVICE_IFACE,
            &[],
            &["Connected"]
        )));
    }

    #[test]
    fn scan_noise_and_foreign_interfaces_cause_no_re_read() {
        for (interface, name) in [
            (DEVICE_IFACE, "RSSI"),
            (ADAPTER_IFACE, "Discovering"),
            // `Connected` exists on other interfaces too; only devices count.
            ("org.bluez.MediaTransport1", "Connected"),
            ("org.bluez.Battery1", "Percentage"),
        ] {
            assert!(
                !signal_changes_state(&properties_changed(interface, &[name], &[])),
                "{interface} {name}"
            );
        }
    }

    #[test]
    fn objects_appearing_and_vanishing_cause_a_re_read() {
        for member in ["InterfacesAdded", "InterfacesRemoved"] {
            let message = Message::signal("/", "org.freedesktop.DBus.ObjectManager", member)
                .unwrap()
                .build(&())
                .unwrap();
            assert!(signal_changes_state(&message), "{member}");
        }
    }

    #[test]
    fn unrelated_and_malformed_signals_cause_no_re_read() {
        let unrelated = Message::signal("/", "org.bluez.Custom", "Something")
            .unwrap()
            .build(&())
            .unwrap();
        assert!(!signal_changes_state(&unrelated));
        let malformed =
            Message::signal("/", "org.freedesktop.DBus.Properties", "PropertiesChanged")
                .unwrap()
                .build(&("not the PropertiesChanged body",))
                .unwrap();
        assert!(!signal_changes_state(&malformed));
    }

    #[test]
    fn an_unchanged_snapshot_is_not_sent_again() {
        let (bridge, channel) = crate::producer::ProducerBridge::new().unwrap();
        let tx = bridge.sender();
        let on = Bluetooth::new(BluetoothState::On, 0);
        let connected = Bluetooth::new(BluetoothState::On, 1);
        let mut sent = None;

        for snapshot in [on, on, connected, connected] {
            assert!(send_if_changed(&tx, &mut sent, snapshot));
        }

        let received: Vec<_> = std::iter::from_fn(|| channel.try_recv().ok())
            .map(|msg| match msg {
                Msg::Bluetooth(snapshot) => snapshot,
                other => panic!("unexpected message: {other:?}"),
            })
            .collect();
        assert_eq!(received, [on, connected]);
    }
}