use heapless::{String, Vec};
use super::{
COMMISSIONABLE_SERVICE, COMMISSIONING_MODE_SUBTYPE, CommissionableTxt, CommissioningMode,
HOST_NAME_MAX, INSTANCE_NAME_LEN, INSTANCE_NAME_MAX, OPERATIONAL_SERVICE, OperationalTxt,
SUBTYPE_MAX, TxtWriter, responder::Advertisement,
};
use crate::error::Result;
use crate::msg::VendorId;
use crate::platform::Rng;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Identity {
pub discriminator: u16,
pub vendor_id: VendorId,
pub product_id: u16,
pub port: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OpenWindow {
pub discriminator: u16,
pub mode: CommissioningMode,
}
#[derive(Debug)]
struct Commissionable {
long: String<6>,
short: String<4>,
txt: TxtWriter,
}
#[derive(Debug)]
pub struct Advertiser<const F: usize, const A: usize> {
identity: Identity,
host: String<HOST_NAME_MAX>,
instance: String<INSTANCE_NAME_LEN>,
address: Option<[u8; 16]>,
operational: Vec<(String<INSTANCE_NAME_MAX>, String<SUBTYPE_MAX>), F>,
operational_txt: TxtWriter,
commissionable: Option<Commissionable>,
}
impl<const F: usize, const A: usize> Advertiser<F, A> {
pub fn new(identity: Identity, rng: &impl Rng) -> Result<Self> {
const {
assert!(
A > F,
"one operational record per fabric and one commissionable"
);
}
let mut advertiser = Self {
identity,
host: hex(rng.next_u64()?),
instance: hex(rng.next_u64()?),
address: None,
operational: Vec::new(),
operational_txt: OperationalTxt::default().encode()?,
commissionable: None,
};
advertiser.refresh(core::iter::empty(), None)?;
Ok(advertiser)
}
#[must_use]
pub const fn with_address(mut self, address: [u8; 16]) -> Self {
self.address = Some(address);
self
}
pub fn refresh(
&mut self,
operational: impl IntoIterator<Item = (String<INSTANCE_NAME_MAX>, String<SUBTYPE_MAX>)>,
window: Option<OpenWindow>,
) -> Result<()> {
self.operational.clear();
for entry in operational {
if self.operational.push(entry).is_err() {
break;
}
}
let commissionable = match window {
Some(window) => Some(window),
None if self.operational.is_empty() => Some(OpenWindow {
discriminator: self.identity.discriminator,
mode: CommissioningMode::Basic,
}),
None => None,
};
self.commissionable = match commissionable {
Some(window) => Some(self.commissionable_for(window)?),
None => None,
};
Ok(())
}
fn commissionable_for(&self, window: OpenWindow) -> Result<Commissionable> {
let txt = CommissionableTxt {
discriminator: window.discriminator,
vendor_id: Some(self.identity.vendor_id),
product_id: Some(self.identity.product_id),
commissioning_mode: window.mode,
..CommissionableTxt::default()
}
.encode()?;
let mut long = String::new();
let _ = core::fmt::Write::write_fmt(&mut long, format_args!("_L{}", window.discriminator));
let mut short = String::new();
let _ = core::fmt::Write::write_fmt(
&mut short,
format_args!("_S{}", window.discriminator >> 8),
);
Ok(Commissionable { long, short, txt })
}
#[must_use]
pub fn host(&self) -> &str {
&self.host
}
#[must_use]
pub fn instance(&self) -> &str {
&self.instance
}
#[must_use]
pub const fn is_commissionable(&self) -> bool {
self.commissionable.is_some()
}
#[must_use]
pub fn advertisements(&self) -> Vec<Advertisement<'_>, A> {
let mut out = Vec::new();
for (instance, subtype) in &self.operational {
let mut a = Advertisement::new(
instance,
OPERATIONAL_SERVICE,
&self.host,
self.identity.port,
self.operational_txt.finish(),
);
a.subtypes.push(subtype).ok();
if let Some(address) = self.address {
a.addresses.push(address).ok();
}
if out.push(a).is_err() {
return out;
}
}
if let Some(c) = &self.commissionable {
let mut a = Advertisement::new(
&self.instance,
COMMISSIONABLE_SERVICE,
&self.host,
self.identity.port,
c.txt.finish(),
);
a.subtypes.push(&c.long).ok();
a.subtypes.push(&c.short).ok();
a.subtypes.push(COMMISSIONING_MODE_SUBTYPE).ok();
if let Some(address) = self.address {
a.addresses.push(address).ok();
}
out.push(a).ok();
}
out
}
}
fn hex(value: u64) -> String<16> {
let mut out = String::new();
let _ = core::fmt::Write::write_fmt(&mut out, format_args!("{value:016X}"));
out
}