#![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 = 0x0504;
pub const REVISION: u16 = 2;
pub const PICS: &str = "CHANNEL";
pub mod feature {
pub const CHANNEL_LIST: u32 = 1 << 0;
pub const LINEUP_INFO: u32 = 1 << 1;
pub const ELECTRONIC_GUIDE: u32 = 1 << 2;
pub const RECORD_PROGRAM: u32 = 1 << 3;
}
pub const FEATURES: &[Feature] = &[
Feature {
bit: 0,
code: "CL",
name: "ChannelList",
conform: Conform::OPTIONAL,
},
Feature {
bit: 1,
code: "LI",
name: "LineupInfo",
conform: Conform::OPTIONAL,
},
Feature {
bit: 2,
code: "EG",
name: "ElectronicGuide",
conform: Conform::OPTIONAL,
},
Feature {
bit: 3,
code: "RP",
name: "RecordProgram",
conform: Conform::OPTIONAL,
},
];
pub mod attribute {
use crate::im::AttributeId;
pub const CHANNEL_LIST: AttributeId = 0x00;
pub const LINEUP: AttributeId = 0x01;
pub const CURRENT_CHANNEL: AttributeId = 0x02;
}
pub mod command {
use crate::im::CommandId;
pub const CHANGE_CHANNEL: CommandId = 0x00;
pub const CHANGE_CHANNEL_RESPONSE: CommandId = 0x01;
pub const CHANGE_CHANNEL_BY_NUMBER: CommandId = 0x02;
pub const SKIP_CHANNEL: CommandId = 0x03;
pub const GET_PROGRAM_GUIDE: CommandId = 0x04;
pub const PROGRAM_GUIDE_RESPONSE: CommandId = 0x05;
pub const RECORD_PROGRAM: CommandId = 0x06;
pub const CANCEL_RECORD_PROGRAM: CommandId = 0x07;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ChannelTypeEnum {
Satellite = 0,
Cable = 1,
Terrestrial = 2,
OTT = 3,
}
impl ChannelTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Satellite),
1 => Some(Self::Cable),
2 => Some(Self::Terrestrial),
3 => Some(Self::OTT),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for ChannelTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for ChannelTypeEnum {
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 LineupInfoTypeEnum {
MSO = 0,
}
impl LineupInfoTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::MSO),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for LineupInfoTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for LineupInfoTypeEnum {
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 {
Success = 0,
MultipleMatches = 1,
NoMatches = 2,
}
impl StatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Success),
1 => Some(Self::MultipleMatches),
2 => Some(Self::NoMatches),
_ => 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))
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct RecordingFlagBitmap: u8 {
const SCHEDULED = 1 << 0;
const RECORD_SERIES = 1 << 1;
const RECORDED = 1 << 2;
}
}
impl ToTlv for RecordingFlagBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for RecordingFlagBitmap {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let bits = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_bits(bits).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ChannelInfoStruct<'a> {
pub major_number: u16,
pub minor_number: u16,
pub name: Option<&'a str>,
pub call_sign: Option<&'a str>,
pub affiliate_call_sign: Option<&'a str>,
pub identifier: Option<&'a str>,
pub type_: Option<ChannelTypeEnum>,
}
impl<'a> ToTlv for ChannelInfoStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.major_number.to_tlv(w, Tag::Context(0))?;
self.minor_number.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.name {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.call_sign {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.affiliate_call_sign {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.identifier {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.type_ {
value.to_tlv(w, Tag::Context(6))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ChannelInfoStruct<'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 major_number = None;
let mut minor_number = None;
let mut name = None;
let mut call_sign = None;
let mut affiliate_call_sign = None;
let mut identifier = None;
let mut type_ = 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) => major_number = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => minor_number = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(3) => call_sign = Some(<&'a str>::from_tlv(reader, &field)?),
Some(4) => affiliate_call_sign = Some(<&'a str>::from_tlv(reader, &field)?),
Some(5) => identifier = Some(<&'a str>::from_tlv(reader, &field)?),
Some(6) => type_ = Some(<ChannelTypeEnum>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
major_number: major_number.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
minor_number: minor_number.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
name,
call_sign,
affiliate_call_sign,
identifier,
type_,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ChannelPagingStruct<'a> {
pub previous_token: Option<Nullable<PageTokenStruct<'a>>>,
pub next_token: Option<Nullable<PageTokenStruct<'a>>>,
}
impl<'a> ToTlv for ChannelPagingStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
if let Some(value) = &self.previous_token {
value.to_tlv(w, Tag::Context(0))?;
}
if let Some(value) = &self.next_token {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ChannelPagingStruct<'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 previous_token = None;
let mut next_token = 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) => {
previous_token =
Some(<Nullable<PageTokenStruct<'a>>>::from_tlv(reader, &field)?)
}
Some(1) => {
next_token = Some(<Nullable<PageTokenStruct<'a>>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
previous_token,
next_token,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct LineupInfoStruct<'a> {
pub operator_name: &'a str,
pub lineup_name: Option<&'a str>,
pub postal_code: Option<&'a str>,
pub lineup_info_type: LineupInfoTypeEnum,
}
impl<'a> ToTlv for LineupInfoStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.operator_name.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.lineup_name {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.postal_code {
value.to_tlv(w, Tag::Context(2))?;
}
self.lineup_info_type.to_tlv(w, Tag::Context(3))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for LineupInfoStruct<'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 operator_name = None;
let mut lineup_name = None;
let mut postal_code = None;
let mut lineup_info_type = 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) => operator_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => lineup_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(2) => postal_code = Some(<&'a str>::from_tlv(reader, &field)?),
Some(3) => lineup_info_type = Some(<LineupInfoTypeEnum>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
operator_name: operator_name.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
lineup_name,
postal_code,
lineup_info_type: lineup_info_type
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PageTokenStruct<'a> {
pub limit: Option<u16>,
pub after: Option<&'a str>,
pub before: Option<&'a str>,
}
impl<'a> ToTlv for PageTokenStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
if let Some(value) = &self.limit {
value.to_tlv(w, Tag::Context(0))?;
}
if let Some(value) = &self.after {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.before {
value.to_tlv(w, Tag::Context(2))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for PageTokenStruct<'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 limit = None;
let mut after = None;
let mut before = 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) => limit = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => after = Some(<&'a str>::from_tlv(reader, &field)?),
Some(2) => before = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
limit,
after,
before,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ProgramCastStruct<'a> {
pub name: &'a str,
pub role: &'a str,
}
impl<'a> ToTlv for ProgramCastStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.name.to_tlv(w, Tag::Context(0))?;
self.role.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ProgramCastStruct<'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 name = None;
let mut role = 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) => name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => role = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
name: name.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
role: role.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ProgramCategoryStruct<'a> {
pub category: &'a str,
pub sub_category: Option<&'a str>,
}
impl<'a> ToTlv for ProgramCategoryStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.category.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.sub_category {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ProgramCategoryStruct<'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 category = None;
let mut sub_category = 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) => category = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => sub_category = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
category: category.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
sub_category,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ProgramStruct<'a> {
pub identifier: &'a str,
pub channel: ChannelInfoStruct<'a>,
pub start_time: u32,
pub end_time: u32,
pub title: &'a str,
pub subtitle: Option<&'a str>,
pub description: Option<&'a str>,
pub audio_languages: Option<TlvList<'a, &'a str>>,
pub ratings: Option<TlvList<'a, &'a str>>,
pub thumbnail_url: Option<&'a str>,
pub poster_art_url: Option<&'a str>,
pub dvbi_url: Option<&'a str>,
pub release_date: Option<&'a str>,
pub parental_guidance_text: Option<&'a str>,
pub recording_flag: Option<RecordingFlagBitmap>,
pub series_info: Option<Nullable<SeriesInfoStruct<'a>>>,
pub category_list: Option<TlvList<'a, ProgramCategoryStruct<'a>>>,
pub cast_list: Option<TlvList<'a, ProgramCastStruct<'a>>>,
pub external_id_list:
Option<TlvList<'a, crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>>>,
}
impl<'a> ToTlv for ProgramStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.identifier.to_tlv(w, Tag::Context(0))?;
self.channel.to_tlv(w, Tag::Context(1))?;
self.start_time.to_tlv(w, Tag::Context(2))?;
self.end_time.to_tlv(w, Tag::Context(3))?;
self.title.to_tlv(w, Tag::Context(4))?;
if let Some(value) = &self.subtitle {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.description {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.audio_languages {
value.to_tlv(w, Tag::Context(7))?;
}
if let Some(value) = &self.ratings {
value.to_tlv(w, Tag::Context(8))?;
}
if let Some(value) = &self.thumbnail_url {
value.to_tlv(w, Tag::Context(9))?;
}
if let Some(value) = &self.poster_art_url {
value.to_tlv(w, Tag::Context(10))?;
}
if let Some(value) = &self.dvbi_url {
value.to_tlv(w, Tag::Context(11))?;
}
if let Some(value) = &self.release_date {
value.to_tlv(w, Tag::Context(12))?;
}
if let Some(value) = &self.parental_guidance_text {
value.to_tlv(w, Tag::Context(13))?;
}
if let Some(value) = &self.recording_flag {
value.to_tlv(w, Tag::Context(14))?;
}
if let Some(value) = &self.series_info {
value.to_tlv(w, Tag::Context(15))?;
}
if let Some(value) = &self.category_list {
value.to_tlv(w, Tag::Context(16))?;
}
if let Some(value) = &self.cast_list {
value.to_tlv(w, Tag::Context(17))?;
}
if let Some(value) = &self.external_id_list {
value.to_tlv(w, Tag::Context(18))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ProgramStruct<'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 identifier = None;
let mut channel = None;
let mut start_time = None;
let mut end_time = None;
let mut title = None;
let mut subtitle = None;
let mut description = None;
let mut audio_languages = None;
let mut ratings = None;
let mut thumbnail_url = None;
let mut poster_art_url = None;
let mut dvbi_url = None;
let mut release_date = None;
let mut parental_guidance_text = None;
let mut recording_flag = None;
let mut series_info = None;
let mut category_list = None;
let mut cast_list = None;
let mut external_id_list = 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) => identifier = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => channel = Some(<ChannelInfoStruct<'a>>::from_tlv(reader, &field)?),
Some(2) => start_time = Some(<u32>::from_tlv(reader, &field)?),
Some(3) => end_time = Some(<u32>::from_tlv(reader, &field)?),
Some(4) => title = Some(<&'a str>::from_tlv(reader, &field)?),
Some(5) => subtitle = Some(<&'a str>::from_tlv(reader, &field)?),
Some(6) => description = Some(<&'a str>::from_tlv(reader, &field)?),
Some(7) => {
audio_languages = Some(<TlvList<'a, &'a str>>::from_tlv(reader, &field)?)
}
Some(8) => ratings = Some(<TlvList<'a, &'a str>>::from_tlv(reader, &field)?),
Some(9) => thumbnail_url = Some(<&'a str>::from_tlv(reader, &field)?),
Some(10) => poster_art_url = Some(<&'a str>::from_tlv(reader, &field)?),
Some(11) => dvbi_url = Some(<&'a str>::from_tlv(reader, &field)?),
Some(12) => release_date = Some(<&'a str>::from_tlv(reader, &field)?),
Some(13) => parental_guidance_text = Some(<&'a str>::from_tlv(reader, &field)?),
Some(14) => recording_flag = Some(<RecordingFlagBitmap>::from_tlv(reader, &field)?),
Some(15) => {
series_info = Some(<Nullable<SeriesInfoStruct<'a>>>::from_tlv(reader, &field)?)
}
Some(16) => {
category_list = Some(<TlvList<'a, ProgramCategoryStruct<'a>>>::from_tlv(
reader, &field,
)?)
}
Some(17) => {
cast_list = Some(<TlvList<'a, ProgramCastStruct<'a>>>::from_tlv(
reader, &field,
)?)
}
Some(18) => {
external_id_list = Some(<TlvList<
'a,
crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>,
>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
identifier: identifier.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
channel: channel.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
start_time: start_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
end_time: end_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
title: title.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
subtitle,
description,
audio_languages,
ratings,
thumbnail_url,
poster_art_url,
dvbi_url,
release_date,
parental_guidance_text,
recording_flag,
series_info,
category_list,
cast_list,
external_id_list,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SeriesInfoStruct<'a> {
pub season: &'a str,
pub episode: &'a str,
}
impl<'a> ToTlv for SeriesInfoStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.season.to_tlv(w, Tag::Context(0))?;
self.episode.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SeriesInfoStruct<'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 season = None;
let mut episode = 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) => season = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => episode = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
season: season.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
episode: episode.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ChangeChannelFields<'a> {
pub match_: &'a str,
}
impl<'a> ToTlv for ChangeChannelFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.match_.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ChangeChannelFields<'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 match_ = 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) => match_ = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
match_: match_.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ChangeChannelResponseFields<'a> {
pub status: StatusEnum,
pub data: Option<&'a str>,
}
impl<'a> ToTlv for ChangeChannelResponseFields<'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.data {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ChangeChannelResponseFields<'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 data = 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) => data = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
data,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ChangeChannelByNumberFields {
pub major_number: u16,
pub minor_number: u16,
}
impl ToTlv for ChangeChannelByNumberFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.major_number.to_tlv(w, Tag::Context(0))?;
self.minor_number.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ChangeChannelByNumberFields {
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 major_number = None;
let mut minor_number = 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) => major_number = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => minor_number = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
major_number: major_number.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
minor_number: minor_number.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SkipChannelFields {
pub count: i16,
}
impl ToTlv for SkipChannelFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.count.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SkipChannelFields {
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 count = 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) => count = Some(<i16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
count: count.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GetProgramGuideFields<'a> {
pub start_time: u32,
pub end_time: u32,
pub channel_list: Option<TlvList<'a, ChannelInfoStruct<'a>>>,
pub page_token: Option<Nullable<PageTokenStruct<'a>>>,
pub recording_flag: Option<Nullable<RecordingFlagBitmap>>,
pub external_id_list:
Option<TlvList<'a, crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>>>,
pub data: Option<&'a [u8]>,
}
impl<'a> ToTlv for GetProgramGuideFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.start_time.to_tlv(w, Tag::Context(0))?;
self.end_time.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.channel_list {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.page_token {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.recording_flag {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.external_id_list {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.data {
value.to_tlv(w, Tag::Context(7))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for GetProgramGuideFields<'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 start_time = None;
let mut end_time = None;
let mut channel_list = None;
let mut page_token = None;
let mut recording_flag = None;
let mut external_id_list = None;
let mut data = 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) => start_time = Some(<u32>::from_tlv(reader, &field)?),
Some(1) => end_time = Some(<u32>::from_tlv(reader, &field)?),
Some(2) => {
channel_list = Some(<TlvList<'a, ChannelInfoStruct<'a>>>::from_tlv(
reader, &field,
)?)
}
Some(3) => {
page_token = Some(<Nullable<PageTokenStruct<'a>>>::from_tlv(reader, &field)?)
}
Some(5) => {
recording_flag =
Some(<Nullable<RecordingFlagBitmap>>::from_tlv(reader, &field)?)
}
Some(6) => {
external_id_list = Some(<TlvList<
'a,
crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>,
>>::from_tlv(reader, &field)?)
}
Some(7) => data = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
start_time: start_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
end_time: end_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
channel_list,
page_token,
recording_flag,
external_id_list,
data,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ProgramGuideResponseFields<'a> {
pub paging: ChannelPagingStruct<'a>,
pub program_list: TlvList<'a, ProgramStruct<'a>>,
}
impl<'a> ToTlv for ProgramGuideResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.paging.to_tlv(w, Tag::Context(0))?;
self.program_list.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ProgramGuideResponseFields<'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 paging = None;
let mut program_list = 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) => paging = Some(<ChannelPagingStruct<'a>>::from_tlv(reader, &field)?),
Some(1) => {
program_list = Some(<TlvList<'a, ProgramStruct<'a>>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
paging: paging.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
program_list: program_list.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RecordProgramFields<'a> {
pub program_identifier: &'a str,
pub should_record_series: bool,
pub external_id_list:
Option<TlvList<'a, crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>>>,
pub data: Option<&'a [u8]>,
}
impl<'a> ToTlv for RecordProgramFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.program_identifier.to_tlv(w, Tag::Context(0))?;
self.should_record_series.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.external_id_list {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.data {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for RecordProgramFields<'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 program_identifier = None;
let mut should_record_series = None;
let mut external_id_list = None;
let mut data = 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) => program_identifier = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => should_record_series = Some(<bool>::from_tlv(reader, &field)?),
Some(2) => {
external_id_list = Some(<TlvList<
'a,
crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>,
>>::from_tlv(reader, &field)?)
}
Some(3) => data = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
program_identifier: program_identifier
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
should_record_series: should_record_series
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
external_id_list,
data,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CancelRecordProgramFields<'a> {
pub program_identifier: &'a str,
pub should_record_series: bool,
pub external_id_list:
Option<TlvList<'a, crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>>>,
pub data: Option<&'a [u8]>,
}
impl<'a> ToTlv for CancelRecordProgramFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.program_identifier.to_tlv(w, Tag::Context(0))?;
self.should_record_series.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.external_id_list {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.data {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for CancelRecordProgramFields<'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 program_identifier = None;
let mut should_record_series = None;
let mut external_id_list = None;
let mut data = 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) => program_identifier = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => should_record_series = Some(<bool>::from_tlv(reader, &field)?),
Some(2) => {
external_id_list = Some(<TlvList<
'a,
crate::clusters::generated::content_launcher::AdditionalInfoStruct<'a>,
>>::from_tlv(reader, &field)?)
}
Some(3) => data = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
program_identifier: program_identifier
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
should_record_series: should_record_series
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
external_id_list,
data,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "ChannelList",
kind: "list[ChannelInfoStruct]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0001,
name: "Lineup",
kind: "LineupInfoStruct",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x0002,
name: "CurrentChannel",
kind: "ChannelInfoStruct",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::OnChange,
conform: Conform::OPTIONAL,
},
];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "ChangeChannel",
to_server: true,
response: Some(0x01),
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Any(&[Condition::Feature(0), Condition::Feature(1)]),
}],
},
},
Command {
id: 0x01,
name: "ChangeChannelResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Any(&[Condition::Feature(0), Condition::Feature(1)]),
}],
},
},
Command {
id: 0x02,
name: "ChangeChannelByNumber",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "SkipChannel",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "GetProgramGuide",
to_server: true,
response: Some(0x05),
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(2),
}],
},
},
Command {
id: 0x05,
name: "ProgramGuideResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(2),
}],
},
},
Command {
id: 0x06,
name: "RecordProgram",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::All(&[Condition::Feature(3), Condition::Feature(2)]),
}],
},
},
Command {
id: 0x07,
name: "CancelRecordProgram",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::All(&[Condition::Feature(3), Condition::Feature(2)]),
}],
},
},
];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Channel",
revision: REVISION,
pics: "CHANNEL",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};