pairing.rs

use anyhow::Result;
use bluer::Address;
use std::collections::HashSet;
use std::fs::{File, OpenOptions};
use std::io::{ErrorKind, Read, Write};
use std::ops::Deref;
use std::path::PathBuf;

/// A set of paired device addresses, backed by a file.
pub struct PairedDevices {
    file: File,
    addresses: HashSet<Address>,
}

impl PairedDevices {
    /// Reads the list of paired addresses from the given path.
    ///
    /// Even if incorrect, assumes that the file will not change
    /// due to external events until dropped.
    pub fn read(path: &PathBuf) -> Result<Self> {
        let mut file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .open(path)?;

        let mut buffer = [0; 6];
        let mut addresses = HashSet::new();
        loop {
            match file.read_exact(&mut buffer) {
                Ok(_) => {
                    addresses.insert(Address::new(buffer.clone()));
                }
                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
                Err(e) => return Err(e.into()),
            }
        }

        Ok(Self { file, addresses })
    }

    pub fn add(&mut self, address: Address) -> Result<()> {
        if self.addresses.insert(address) {
            self.file.write_all(&address.0)?;
        }
        Ok(())
    }
}

impl Deref for PairedDevices {
    type Target = HashSet<Address>;

    fn deref(&self) -> &Self::Target {
        &self.addresses
    }
}