use core::cell::RefCell;
use crate::clusters::generated::groups as spec_groups;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb};
use crate::msg::{FabricIndex, GroupId};
use crate::tlv::{Tag, TlvWriter, ToTlv};
use super::Cluster;
use super::scenes::{NoScenes, ScenePurge};
pub trait GroupMembership {
fn is_group_member(&self, fabric: FabricIndex, group: GroupId) -> bool;
}
pub use spec_groups::attribute::NAME_SUPPORT;
pub use spec_groups::command::{
ADD_GROUP, ADD_GROUP_IF_IDENTIFYING, ADD_GROUP_RESPONSE, GET_GROUP_MEMBERSHIP,
GET_GROUP_MEMBERSHIP_RESPONSE, REMOVE_ALL_GROUPS, REMOVE_GROUP, REMOVE_GROUP_RESPONSE,
VIEW_GROUP, VIEW_GROUP_RESPONSE,
};
pub use spec_groups::{ID, NameSupportBitmap, PICS, REVISION, feature};
pub const NAME_MAX: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Membership {
pub group: GroupId,
pub fabric: FabricIndex,
name: [u8; NAME_MAX],
name_len: usize,
}
impl Membership {
#[must_use]
pub fn name(&self) -> &str {
core::str::from_utf8(self.name.get(..self.name_len).unwrap_or(&[])).unwrap_or("")
}
}
pub trait Identifying {
fn is_identifying(&self) -> bool;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct NeverIdentifying;
impl Identifying for NeverIdentifying {
fn is_identifying(&self) -> bool {
false
}
}
#[derive(Debug)]
pub struct Groups<'a, const N: usize, I: Identifying = NeverIdentifying, S: ScenePurge = NoScenes> {
memberships: RefCell<heapless::Vec<Membership, N>>,
per_fabric: usize,
names: bool,
identifying: &'a I,
scenes: &'a S,
}
impl<const N: usize> Groups<'static, N, NeverIdentifying, NoScenes> {
#[must_use]
pub const fn new(per_fabric: usize, names: bool) -> Self {
Self::with(per_fabric, names, &NeverIdentifying, &NoScenes)
}
}
impl<'a, const N: usize, I: Identifying, S: ScenePurge> Groups<'a, N, I, S> {
#[must_use]
pub const fn with(per_fabric: usize, names: bool, identifying: &'a I, scenes: &'a S) -> Self {
Self {
memberships: RefCell::new(heapless::Vec::new()),
per_fabric,
names,
identifying,
scenes,
}
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<1, 6, 4, 0>> {
Conforming::new(&spec_groups::CLUSTER, feature_map, optional)
}
#[must_use]
pub fn name_support(&self) -> NameSupportBitmap {
if self.names {
NameSupportBitmap::GROUP_NAMES
} else {
NameSupportBitmap::empty()
}
}
#[must_use]
pub const fn feature_map(&self) -> u32 {
if self.names { feature::GROUP_NAMES } else { 0 }
}
#[must_use]
pub fn memberships(&self) -> core::cell::Ref<'_, heapless::Vec<Membership, N>> {
self.memberships.borrow()
}
#[must_use]
pub fn is_member(&self, fabric: FabricIndex, group: GroupId) -> bool {
self.memberships
.borrow()
.iter()
.any(|m| m.fabric == fabric && m.group == group)
}
#[must_use]
pub fn len_of_fabric(&self, fabric: FabricIndex) -> usize {
self.memberships
.borrow()
.iter()
.filter(|m| m.fabric == fabric)
.count()
}
#[must_use]
pub fn capacity(&self, fabric: FabricIndex) -> u8 {
let used = self.len_of_fabric(fabric);
let free = self.per_fabric.saturating_sub(used);
u8::try_from(free.min(0xFD)).unwrap_or(0xFD)
}
pub fn remove_fabric(&self, fabric: FabricIndex) {
self.memberships.borrow_mut().retain(|m| m.fabric != fabric);
self.scenes.remove_grouped_scenes(fabric);
}
fn add(&self, fabric: FabricIndex, group: GroupId, name: &str) -> Status {
if group.0 == 0 || name.len() > NAME_MAX {
return Status::ConstraintError;
}
let mut stored = [0u8; NAME_MAX];
let kept = if self.names { name } else { "" };
let len = kept.len().min(NAME_MAX);
if let (Some(slot), Some(source)) = (stored.get_mut(..len), kept.as_bytes().get(..len)) {
slot.copy_from_slice(source);
}
let mut memberships = self.memberships.borrow_mut();
if let Some(existing) = memberships
.iter_mut()
.find(|m| m.fabric == fabric && m.group == group)
{
existing.name = stored;
existing.name_len = len;
return Status::Success;
}
if memberships.iter().filter(|m| m.fabric == fabric).count() >= self.per_fabric {
return Status::ResourceExhausted;
}
match memberships.push(Membership {
group,
fabric,
name: stored,
name_len: len,
}) {
Ok(()) => Status::Success,
Err(_) => Status::ResourceExhausted,
}
}
fn remove(&self, fabric: FabricIndex, group: GroupId) -> Status {
if group.0 == 0 {
return Status::ConstraintError;
}
let removed = {
let mut memberships = self.memberships.borrow_mut();
let before = memberships.len();
memberships.retain(|m| !(m.fabric == fabric && m.group == group));
memberships.len() != before
};
if !removed {
return Status::NotFound;
}
self.scenes.remove_group_scenes(fabric, group);
Status::Success
}
}
impl<const N: usize, I: Identifying, S: ScenePurge> ClusterHandler for Groups<'_, N, I, S> {
fn on_lifecycle(&self, event: crate::im::Lifecycle) {
if let crate::im::Lifecycle::FabricRemoved(fabric) = event {
self.remove_fabric(fabric);
}
}
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
if resolved.attribute != NAME_SUPPORT {
return Err(Status::UnsupportedAttribute);
}
w.unsigned(tag, u64::from(self.name_support().bits()))
.map_err(|_| Status::ResourceExhausted)
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let answer = ctx.group.is_none();
let full = |r: crate::error::Result<()>| r.map_err(|_| StatusIb::from(Status::Failure));
let Some(fabric) = ctx.fabric_index else {
return Err(Status::UnsupportedAccess.into());
};
match resolved.command.id {
ADD_GROUP_IF_IDENTIFYING => {
let decoded: spec_groups::AddGroupIfIdentifyingFields<'_> =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
if self.identifying.is_identifying() {
self.add(fabric, decoded.group_id, decoded.group_name);
}
Ok(None)
}
ADD_GROUP => {
let decoded: spec_groups::AddGroupFields<'_> =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
let status = self.add(fabric, decoded.group_id, decoded.group_name);
if !answer {
return Ok(None);
}
full(
spec_groups::AddGroupResponseFields {
status: status.value(),
group_id: decoded.group_id,
}
.to_tlv(w, tag),
)?;
Ok(Some(ADD_GROUP_RESPONSE))
}
VIEW_GROUP => {
let decoded: spec_groups::ViewGroupFields =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
let memberships = self.memberships.borrow();
let found = memberships
.iter()
.find(|m| m.fabric == fabric && m.group == decoded.group_id);
let status = match (decoded.group_id.0, found) {
(0, _) => Status::ConstraintError,
(_, Some(_)) => Status::Success,
(_, None) => Status::NotFound,
};
let name = found.map_or("", Membership::name);
if !answer {
return Ok(None);
}
full(
spec_groups::ViewGroupResponseFields {
status: status.value(),
group_id: decoded.group_id,
group_name: name,
}
.to_tlv(w, tag),
)?;
Ok(Some(VIEW_GROUP_RESPONSE))
}
GET_GROUP_MEMBERSHIP => {
let decoded: spec_groups::GetGroupMembershipFields<'_> =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
if !answer {
return Ok(None);
}
let everything = decoded.group_list.is_empty();
let memberships = self.memberships.borrow();
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(self.capacity(fabric))))?;
full(w.start_array(Tag::Context(1)))?;
for membership in memberships.iter().filter(|m| m.fabric == fabric) {
if !everything {
let mut asked = false;
for entry in decoded.group_list.iter() {
let group: GroupId =
entry.map_err(|_| StatusIb::from(Status::ConstraintError))?;
if group == membership.group {
asked = true;
break;
}
}
if !asked {
continue;
}
}
full(w.unsigned(Tag::Anonymous, u64::from(membership.group.0)))?;
}
full(w.end_container())?;
full(w.end_container())?;
Ok(Some(GET_GROUP_MEMBERSHIP_RESPONSE))
}
REMOVE_GROUP => {
let decoded: spec_groups::RemoveGroupFields =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
let status = self.remove(fabric, decoded.group_id);
if !answer {
return Ok(None);
}
full(
spec_groups::RemoveGroupResponseFields {
status: status.value(),
group_id: decoded.group_id,
}
.to_tlv(w, tag),
)?;
Ok(Some(REMOVE_GROUP_RESPONSE))
}
REMOVE_ALL_GROUPS => {
self.memberships.borrow_mut().retain(|m| m.fabric != fabric);
self.scenes.remove_grouped_scenes(fabric);
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<const N: usize, I: Identifying, S: ScenePurge> GroupMembership for Groups<'_, N, I, S> {
fn is_group_member(&self, fabric: FabricIndex, group: GroupId) -> bool {
self.is_member(fabric, group)
}
}
impl<const N: usize, I: Identifying, S: ScenePurge> Cluster for Groups<'_, N, I, S> {
const ID: ClusterId = ID;
}