#![allow(unused_imports)]
use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
use crate::dm::meta::{EventPriority, Reporting};
use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
use crate::error::Result;
use crate::im::{AttributeId, ClusterId, CommandId, EventId};
use crate::tlv::{
ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
};
pub const ID: ClusterId = 0x0029;
pub const REVISION: u16 = 1;
pub const PICS: &str = "OTAP";
pub const FEATURES: &[Feature] = &[];
pub mod command {
use crate::im::CommandId;
pub const QUERY_IMAGE: CommandId = 0x00;
pub const QUERY_IMAGE_RESPONSE: CommandId = 0x01;
pub const APPLY_UPDATE_REQUEST: CommandId = 0x02;
pub const APPLY_UPDATE_RESPONSE: CommandId = 0x03;
pub const NOTIFY_UPDATE_APPLIED: CommandId = 0x04;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ApplyUpdateActionEnum {
Proceed = 0,
AwaitNextAction = 1,
Discontinue = 2,
}
impl ApplyUpdateActionEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Proceed),
1 => Some(Self::AwaitNextAction),
2 => Some(Self::Discontinue),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for ApplyUpdateActionEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for ApplyUpdateActionEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DownloadProtocolEnum {
BDXSynchronous = 0,
BDXAsynchronous = 1,
HTTPS = 2,
VendorSpecific = 3,
}
impl DownloadProtocolEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::BDXSynchronous),
1 => Some(Self::BDXAsynchronous),
2 => Some(Self::HTTPS),
3 => Some(Self::VendorSpecific),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for DownloadProtocolEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for DownloadProtocolEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum StatusEnum {
UpdateAvailable = 0,
Busy = 1,
NotAvailable = 2,
DownloadProtocolNotSupported = 3,
}
impl StatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::UpdateAvailable),
1 => Some(Self::Busy),
2 => Some(Self::NotAvailable),
3 => Some(Self::DownloadProtocolNotSupported),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for StatusEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for StatusEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct QueryImageFields<'a> {
pub vendor_id: crate::msg::VendorId,
pub product_id: u16,
pub software_version: u32,
pub protocols_supported: TlvList<'a, DownloadProtocolEnum>,
pub hardware_version: Option<u16>,
pub location: Option<&'a str>,
pub requestor_can_consent: Option<bool>,
pub metadata_for_provider: Option<&'a [u8]>,
}
impl<'a> ToTlv for QueryImageFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.vendor_id.to_tlv(w, Tag::Context(0))?;
self.product_id.to_tlv(w, Tag::Context(1))?;
self.software_version.to_tlv(w, Tag::Context(2))?;
self.protocols_supported.to_tlv(w, Tag::Context(3))?;
if let Some(value) = &self.hardware_version {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.location {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.requestor_can_consent {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.metadata_for_provider {
value.to_tlv(w, Tag::Context(7))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for QueryImageFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut vendor_id = None;
let mut product_id = None;
let mut software_version = None;
let mut protocols_supported = None;
let mut hardware_version = None;
let mut location = None;
let mut requestor_can_consent = None;
let mut metadata_for_provider = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => vendor_id = Some(<crate::msg::VendorId>::from_tlv(reader, &field)?),
Some(1) => product_id = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => software_version = Some(<u32>::from_tlv(reader, &field)?),
Some(3) => {
protocols_supported = Some(<TlvList<'a, DownloadProtocolEnum>>::from_tlv(
reader, &field,
)?)
}
Some(4) => hardware_version = Some(<u16>::from_tlv(reader, &field)?),
Some(5) => location = Some(<&'a str>::from_tlv(reader, &field)?),
Some(6) => requestor_can_consent = Some(<bool>::from_tlv(reader, &field)?),
Some(7) => metadata_for_provider = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
vendor_id: vendor_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
product_id: product_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
software_version: software_version
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
protocols_supported: protocols_supported
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
hardware_version,
location,
requestor_can_consent,
metadata_for_provider,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct QueryImageResponseFields<'a> {
pub status: StatusEnum,
pub delayed_action_time: Option<u32>,
pub image_uri: Option<&'a str>,
pub software_version: Option<u32>,
pub software_version_string: Option<&'a str>,
pub update_token: Option<&'a [u8]>,
pub user_consent_needed: Option<bool>,
pub metadata_for_requestor: Option<&'a [u8]>,
}
impl<'a> ToTlv for QueryImageResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.delayed_action_time {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.image_uri {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.software_version {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.software_version_string {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.update_token {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.user_consent_needed {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.metadata_for_requestor {
value.to_tlv(w, Tag::Context(7))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for QueryImageResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut status = None;
let mut delayed_action_time = None;
let mut image_uri = None;
let mut software_version = None;
let mut software_version_string = None;
let mut update_token = None;
let mut user_consent_needed = None;
let mut metadata_for_requestor = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => status = Some(<StatusEnum>::from_tlv(reader, &field)?),
Some(1) => delayed_action_time = Some(<u32>::from_tlv(reader, &field)?),
Some(2) => image_uri = Some(<&'a str>::from_tlv(reader, &field)?),
Some(3) => software_version = Some(<u32>::from_tlv(reader, &field)?),
Some(4) => software_version_string = Some(<&'a str>::from_tlv(reader, &field)?),
Some(5) => update_token = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(6) => user_consent_needed = Some(<bool>::from_tlv(reader, &field)?),
Some(7) => metadata_for_requestor = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
delayed_action_time,
image_uri,
software_version,
software_version_string,
update_token,
user_consent_needed,
metadata_for_requestor,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ApplyUpdateRequestFields<'a> {
pub update_token: &'a [u8],
pub new_version: u32,
}
impl<'a> ToTlv for ApplyUpdateRequestFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.update_token.to_tlv(w, Tag::Context(0))?;
self.new_version.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ApplyUpdateRequestFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut update_token = None;
let mut new_version = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => update_token = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => new_version = Some(<u32>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
update_token: update_token.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
new_version: new_version.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ApplyUpdateResponseFields {
pub action: ApplyUpdateActionEnum,
pub delayed_action_time: u32,
}
impl ToTlv for ApplyUpdateResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.action.to_tlv(w, Tag::Context(0))?;
self.delayed_action_time.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ApplyUpdateResponseFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut action = None;
let mut delayed_action_time = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => action = Some(<ApplyUpdateActionEnum>::from_tlv(reader, &field)?),
Some(1) => delayed_action_time = Some(<u32>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
action: action.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
delayed_action_time: delayed_action_time
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct NotifyUpdateAppliedFields<'a> {
pub update_token: &'a [u8],
pub software_version: u32,
}
impl<'a> ToTlv for NotifyUpdateAppliedFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.update_token.to_tlv(w, Tag::Context(0))?;
self.software_version.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for NotifyUpdateAppliedFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut update_token = None;
let mut software_version = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => update_token = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => software_version = Some(<u32>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
update_token: update_token.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
software_version: software_version
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "QueryImage",
to_server: true,
response: Some(0x01),
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "QueryImageResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x02,
name: "ApplyUpdateRequest",
to_server: true,
response: Some(0x03),
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "ApplyUpdateResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "NotifyUpdateApplied",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "OTA Software Update Provider",
revision: REVISION,
pics: "OTAP",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};