#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Protocol {
BleGatt,
Classic,
Rfcomm,
ClassicL2cap,
L2cap,
Sdp,
Profiles,
Mesh,
RawAcl,
RawSco,
LeAudio,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProtocolCapabilities {
ble_gatt: bool,
classic: bool,
rfcomm: bool,
l2cap: bool,
classic_l2cap: bool,
sdp: bool,
profiles: bool,
mesh: bool,
raw_acl: bool,
raw_sco: bool,
le_audio: bool,
}
impl ProtocolCapabilities {
pub const fn current() -> Self {
Self {
ble_gatt: true,
classic: cfg!(feature = "classic"),
rfcomm: cfg!(all(
feature = "rfcomm",
any(
target_os = "linux",
target_os = "android",
target_os = "windows"
)
)),
l2cap: !cfg!(any(target_os = "windows", target_arch = "wasm32")),
classic_l2cap: cfg!(feature = "classic-l2cap"),
sdp: cfg!(feature = "classic"),
profiles: cfg!(feature = "profiles"),
mesh: cfg!(feature = "mesh"),
raw_acl: cfg!(all(feature = "raw-acl", target_os = "linux")),
raw_sco: cfg!(all(feature = "raw-sco", target_os = "linux")),
le_audio: cfg!(feature = "le-audio"),
}
}
pub const fn supports(self, protocol: Protocol) -> bool {
match protocol {
Protocol::BleGatt => self.ble_gatt,
Protocol::L2cap => self.l2cap,
Protocol::Classic => self.classic,
Protocol::Rfcomm => self.rfcomm,
Protocol::ClassicL2cap => self.classic_l2cap,
Protocol::Sdp => self.sdp,
Protocol::Profiles => self.profiles,
Protocol::Mesh => self.mesh,
Protocol::RawAcl => self.raw_acl,
Protocol::RawSco => self.raw_sco,
Protocol::LeAudio => self.le_audio,
}
}
pub const fn ble_gatt(self) -> bool {
self.ble_gatt
}
pub const fn l2cap(self) -> bool {
self.l2cap
}
pub const fn classic(self) -> bool {
self.classic
}
pub const fn rfcomm(self) -> bool {
self.rfcomm
}
pub const fn classic_l2cap(self) -> bool {
self.classic_l2cap
}
pub const fn sdp(self) -> bool {
self.sdp
}
pub const fn profiles(self) -> bool {
self.profiles
}
pub const fn mesh(self) -> bool {
self.mesh
}
pub const fn raw_acl(self) -> bool {
self.raw_acl
}
pub const fn raw_sco(self) -> bool {
self.raw_sco
}
pub const fn le_audio(self) -> bool {
self.le_audio
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn current_capabilities_match_feature_flags() {
let capabilities = ProtocolCapabilities::current();
assert!(capabilities.ble_gatt());
assert_eq!(
capabilities.l2cap(),
!cfg!(any(target_os = "windows", target_arch = "wasm32"))
);
assert_eq!(capabilities.classic(), cfg!(feature = "classic"));
assert_eq!(
capabilities.rfcomm(),
cfg!(all(
feature = "rfcomm",
any(
target_os = "linux",
target_os = "android",
target_os = "windows"
)
))
);
assert_eq!(
capabilities.classic_l2cap(),
cfg!(feature = "classic-l2cap")
);
assert_eq!(capabilities.sdp(), cfg!(feature = "classic"));
assert_eq!(capabilities.profiles(), cfg!(feature = "profiles"));
assert_eq!(capabilities.mesh(), cfg!(feature = "mesh"));
assert_eq!(
capabilities.raw_acl(),
cfg!(all(feature = "raw-acl", target_os = "linux"))
);
assert_eq!(
capabilities.raw_sco(),
cfg!(all(feature = "raw-sco", target_os = "linux"))
);
assert_eq!(capabilities.le_audio(), cfg!(feature = "le-audio"));
assert!(capabilities.supports(Protocol::BleGatt));
assert_eq!(
capabilities.supports(Protocol::Classic),
cfg!(feature = "classic")
);
assert_eq!(
capabilities.supports(Protocol::Rfcomm),
cfg!(all(
feature = "rfcomm",
any(
target_os = "linux",
target_os = "android",
target_os = "windows"
)
))
);
assert_eq!(
capabilities.supports(Protocol::ClassicL2cap),
cfg!(feature = "classic-l2cap")
);
assert_eq!(
capabilities.supports(Protocol::L2cap),
!cfg!(any(target_os = "windows", target_arch = "wasm32"))
);
assert_eq!(
capabilities.supports(Protocol::Sdp),
cfg!(feature = "classic")
);
assert_eq!(
capabilities.supports(Protocol::Profiles),
cfg!(feature = "profiles")
);
assert_eq!(
capabilities.supports(Protocol::Mesh),
cfg!(feature = "mesh")
);
assert_eq!(
capabilities.supports(Protocol::RawAcl),
cfg!(all(feature = "raw-acl", target_os = "linux"))
);
assert_eq!(
capabilities.supports(Protocol::RawSco),
cfg!(all(feature = "raw-sco", target_os = "linux"))
);
assert_eq!(
capabilities.supports(Protocol::LeAudio),
cfg!(feature = "le-audio")
);
}
}