use core::cell::{Cell, RefCell};
use crate::clusters::generated::ota_software_update_requestor as spec_requestor;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::error::Result;
use crate::im::{
ClusterHandler, ClusterId, CommandId, EndpointId, InteractionContext, Status, StatusIb, WriteOp,
};
use crate::msg::{FabricIndex, NodeId, VendorId};
use crate::tlv::{ContainerKind, FromTlv, Tag, TlvReader, TlvWriter, ToTlv, Value};
use super::Cluster;
pub use spec_requestor::attribute::{
DEFAULT_OTA_PROVIDERS, UPDATE_POSSIBLE, UPDATE_STATE, UPDATE_STATE_PROGRESS,
};
pub use spec_requestor::command::ANNOUNCE_OTA_PROVIDER;
pub use spec_requestor::event::{DOWNLOAD_ERROR, STATE_TRANSITION, VERSION_APPLIED};
pub use spec_requestor::{
AnnouncementReasonEnum, ChangeReasonEnum, ID, PICS, ProviderLocation, REVISION, UpdateStateEnum,
};
pub const METADATA_MAX: usize = 512;
pub const PROGRESS_MAX: u8 = 100;
pub const EVENT_QUEUE: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Announcement<'a> {
pub fabric_index: FabricIndex,
pub provider_node_id: NodeId,
pub endpoint: EndpointId,
pub vendor_id: VendorId,
pub reason: AnnouncementReasonEnum,
pub metadata: Option<&'a [u8]>,
}
impl Announcement<'_> {
#[must_use]
pub const fn location(&self) -> ProviderLocation {
ProviderLocation {
provider_node_id: self.provider_node_id,
endpoint: self.endpoint,
fabric_index: self.fabric_index,
}
}
#[must_use]
pub const fn is_urgent(&self) -> bool {
matches!(self.reason, AnnouncementReasonEnum::UrgentUpdateAvailable)
}
}
pub trait OtaRequestorHooks {
fn announced(&self, announcement: &Announcement<'_>) {
let _ = announcement;
}
}
impl OtaRequestorHooks for () {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Event {
StateTransition {
previous: UpdateStateEnum,
new_state: UpdateStateEnum,
reason: ChangeReasonEnum,
target_software_version: Option<u32>,
},
VersionApplied {
software_version: u32,
product_id: u16,
},
DownloadError {
software_version: u32,
bytes_downloaded: u64,
progress_percent: Option<u8>,
platform_code: Option<i64>,
},
}
impl Event {
#[must_use]
pub const fn id(&self) -> crate::im::EventId {
match self {
Self::StateTransition { .. } => STATE_TRANSITION,
Self::VersionApplied { .. } => VERSION_APPLIED,
Self::DownloadError { .. } => DOWNLOAD_ERROR,
}
}
}
impl ToTlv for Event {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
match *self {
Self::StateTransition {
previous,
new_state,
reason,
target_software_version,
} => {
w.unsigned(Tag::Context(0), u64::from(previous.value()))?;
w.unsigned(Tag::Context(1), u64::from(new_state.value()))?;
w.unsigned(Tag::Context(2), u64::from(reason.value()))?;
match target_software_version {
Some(version) => w.unsigned(Tag::Context(3), u64::from(version))?,
None => w.null(Tag::Context(3))?,
}
}
Self::VersionApplied {
software_version,
product_id,
} => {
w.unsigned(Tag::Context(0), u64::from(software_version))?;
w.unsigned(Tag::Context(1), u64::from(product_id))?;
}
Self::DownloadError {
software_version,
bytes_downloaded,
progress_percent,
platform_code,
} => {
w.unsigned(Tag::Context(0), u64::from(software_version))?;
w.unsigned(Tag::Context(1), bytes_downloaded)?;
match progress_percent {
Some(percent) => w.unsigned(Tag::Context(2), u64::from(percent))?,
None => w.null(Tag::Context(2))?,
}
match platform_code {
Some(code) => w.signed(Tag::Context(3), code)?,
None => w.null(Tag::Context(3))?,
}
}
}
w.end_container()
}
}
#[derive(Debug)]
pub struct OtaRequestor<'a, H: OtaRequestorHooks, const N: usize> {
hooks: &'a H,
providers: RefCell<heapless::Vec<ProviderLocation, N>>,
possible: Cell<bool>,
state: Cell<UpdateStateEnum>,
progress: Cell<Option<u8>>,
events: RefCell<heapless::Vec<Event, EVENT_QUEUE>>,
}
impl<'a, H: OtaRequestorHooks, const N: usize> OtaRequestor<'a, H, N> {
#[must_use]
pub const fn new(hooks: &'a H) -> Self {
Self {
hooks,
providers: RefCell::new(heapless::Vec::new()),
possible: Cell::new(true),
state: Cell::new(UpdateStateEnum::Unknown),
progress: Cell::new(None),
events: RefCell::new(heapless::Vec::new()),
}
}
pub fn conforming(feature_map: u32, optional: &Optional<'_>) -> Result<Conforming<4, 1, 0, 3>> {
Conforming::new(&spec_requestor::CLUSTER, feature_map, optional)
}
#[must_use]
pub fn providers(&self) -> core::cell::Ref<'_, heapless::Vec<ProviderLocation, N>> {
self.providers.borrow()
}
#[must_use]
pub fn provider_for(&self, fabric: FabricIndex) -> Option<ProviderLocation> {
self.providers
.borrow()
.iter()
.find(|p| p.fabric_index == fabric)
.copied()
}
pub fn set_provider(&self, provider: ProviderLocation) -> core::result::Result<(), Status> {
if provider.fabric_index.0 == 0 {
return Err(Status::UnsupportedAccess);
}
let mut providers = self.providers.borrow_mut();
if let Some(slot) = providers
.iter_mut()
.find(|p| p.fabric_index == provider.fabric_index)
{
*slot = provider;
return Ok(());
}
providers
.push(provider)
.map_err(|_| Status::ResourceExhausted)
}
pub fn remove_fabric(&self, fabric: FabricIndex) {
self.providers
.borrow_mut()
.retain(|p| p.fabric_index != fabric);
}
#[must_use]
pub fn update_possible(&self) -> bool {
self.possible.get()
}
pub fn set_update_possible(&self, possible: bool) {
self.possible.set(possible);
}
#[must_use]
pub fn state(&self) -> UpdateStateEnum {
self.state.get()
}
#[must_use]
pub fn progress(&self) -> Option<u8> {
self.progress.get()
}
pub fn transition(
&self,
new_state: UpdateStateEnum,
reason: ChangeReasonEnum,
target_software_version: Option<u32>,
) {
let previous = self.state.get();
if previous == new_state {
return;
}
self.state.set(new_state);
self.progress.set(None);
self.push(Event::StateTransition {
previous,
new_state,
reason,
target_software_version: target_software_version
.filter(|_| Self::has_target(new_state)),
});
}
pub fn set_progress(&self, percent: Option<u8>) -> core::result::Result<(), Status> {
if percent.is_some_and(|p| p > PROGRESS_MAX) {
return Err(Status::ConstraintError);
}
self.progress.set(percent);
Ok(())
}
pub fn version_applied(&self, software_version: u32, product_id: u16) {
self.push(Event::VersionApplied {
software_version,
product_id,
});
}
pub fn download_error(
&self,
software_version: u32,
bytes_downloaded: u64,
total: Option<u64>,
platform_code: Option<i64>,
) {
self.push(Event::DownloadError {
software_version,
bytes_downloaded,
progress_percent: Self::percent(bytes_downloaded, total),
platform_code,
});
}
pub fn take_events(&self) -> heapless::Vec<Event, EVENT_QUEUE> {
core::mem::take(&mut self.events.borrow_mut())
}
fn percent(done: u64, total: Option<u64>) -> Option<u8> {
let total = total.filter(|t| *t != 0)?;
let scaled = done
.checked_mul(200)?
.checked_add(total)?
.checked_div(total.checked_mul(2)?)?;
u8::try_from(scaled.min(u64::from(PROGRESS_MAX))).ok()
}
const fn has_target(state: UpdateStateEnum) -> bool {
matches!(
state,
UpdateStateEnum::Downloading | UpdateStateEnum::Applying | UpdateStateEnum::RollingBack
)
}
fn push(&self, event: Event) {
let mut events = self.events.borrow_mut();
if events.is_full() {
events.remove(0);
}
let _ = events.push(event);
}
fn visible(ctx: &InteractionContext<'_>, index: FabricIndex) -> bool {
!ctx.fabric_filtered || ctx.fabric_index == Some(index)
}
}
impl<H: OtaRequestorHooks, const N: usize> ClusterHandler for OtaRequestor<'_, H, N> {
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,
) -> core::result::Result<(), Status> {
let full = |r: Result<()>| r.map_err(|_| Status::ResourceExhausted);
match resolved.attribute {
DEFAULT_OTA_PROVIDERS => {
let providers = self.providers.borrow();
full(w.start_array(tag))?;
for provider in providers
.iter()
.filter(|p| Self::visible(ctx, p.fabric_index))
{
full(provider.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())
}
UPDATE_POSSIBLE => full(w.bool(tag, self.possible.get())),
UPDATE_STATE => full(w.unsigned(tag, u64::from(self.state.get().value()))),
UPDATE_STATE_PROGRESS => match self.progress.get() {
Some(percent) => full(w.unsigned(tag, u64::from(percent))),
None => full(w.null(tag)),
},
_ => Err(Status::UnsupportedAttribute),
}
}
fn write(
&self,
resolved: &Resolved<'_>,
data: &[u8],
op: WriteOp,
ctx: &InteractionContext<'_>,
) -> core::result::Result<(), Status> {
if resolved.attribute != DEFAULT_OTA_PROVIDERS {
return Err(Status::UnsupportedWrite);
}
let Some(fabric_index) = ctx.fabric_index else {
return Err(Status::UnsupportedAccess);
};
let mut reader = TlvReader::new_in(data, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidAction)?
.ok_or(Status::InvalidAction)?;
match op {
WriteOp::Replace => {
if element.value.container() != Some(ContainerKind::Array) {
return Err(Status::InvalidAction);
}
let mut replacement: Option<ProviderLocation> = None;
loop {
let Some(item) = reader.next_element().map_err(|_| Status::InvalidAction)?
else {
return Err(Status::InvalidAction);
};
if item.value == Value::EndOfContainer {
break;
}
let provider = decode_provider(&mut reader, &item, fabric_index)?;
if replacement.replace(provider).is_some() {
return Err(Status::ConstraintError);
}
}
let mut providers = self.providers.borrow_mut();
providers.retain(|p| p.fabric_index != fabric_index);
if let Some(provider) = replacement {
providers
.push(provider)
.map_err(|_| Status::ResourceExhausted)?;
}
Ok(())
}
WriteOp::Append => {
let provider = decode_provider(&mut reader, &element, fabric_index)?;
if self.provider_for(fabric_index).is_some() {
return Err(Status::ConstraintError);
}
self.set_provider(provider)
}
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> core::result::Result<Option<CommandId>, StatusIb> {
if resolved.command.id != ANNOUNCE_OTA_PROVIDER {
return Err(Status::UnsupportedCommand.into());
}
let Some(fabric_index) = ctx.fabric_index.filter(|f| f.0 != 0) else {
return Err(Status::UnsupportedAccess.into());
};
let payload = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
let decoded: spec_requestor::AnnounceOTAProviderFields<'_> = super::decode_fields(payload)?;
if decoded
.metadata_for_node
.is_some_and(|m| m.len() > METADATA_MAX)
{
return Err(Status::ConstraintError.into());
}
self.hooks.announced(&Announcement {
fabric_index,
provider_node_id: decoded.provider_node_id,
endpoint: decoded.endpoint,
vendor_id: decoded.vendor_id,
reason: decoded.announcement_reason,
metadata: decoded.metadata_for_node,
});
Ok(None)
}
}
fn decode_provider<'a>(
reader: &mut TlvReader<'a>,
element: &crate::tlv::Element<'a>,
fabric_index: FabricIndex,
) -> core::result::Result<ProviderLocation, Status> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidAction);
}
let mut provider =
ProviderLocation::from_tlv(reader, element).map_err(|_| Status::InvalidAction)?;
provider.fabric_index = fabric_index;
Ok(provider)
}
impl<H: OtaRequestorHooks, const N: usize> Cluster for OtaRequestor<'_, H, N> {
const ID: ClusterId = ID;
}