Struct Responder 

pub struct Responder<'a, T> { /* private fields */ }

A generic responder utility for accepting and handling exchanges received by the provided Matter stack, by applying the provided ExchangeHandler instance to each accepted exchange.

This responder uses an intra-task concurrency model - without an external executor - where all handling is done as a single future.

Implementations

impl<'a, T> Responder<'a, T>

where T: ExchangeHandler,

pub const fn new( name: &'a str, handler: T, matter: &'a Matter<'a>, respond_after_ms: u32, ) -> Responder<'a, T>

Create a new responder.

The respond_after_ms parameter instructs the responder how much time to wait before accepting an exchange.

This is useful when utilizing multiple responders on a single Matter instance, where e.g. the first (main) responder is the actual one, responsible for handling the incoming exchanges, while e.g. another one - with a non-zero respond_after_ms - is answerring all exchanges not accepted in time by the main responder with a simple “I’m busy, try again later” handling.

pub const fn name(&self) -> &str

Get the name of this responder

pub fn handler(&self) -> &T

Get a reference to the ExchangeHandler instance used by this responder

pub async fn run<const N: usize>(&self) -> Result<(), Error>

Run the responder with a given number of handlers.

pub async fn handle(&self, handler_id: impl Display) -> Result<(), Error>

A handler for one exchange.

pub async fn respond_once(&self, handler_id: impl Display) -> Result<(), Error>

Respond to a single exchange. Useful in e.g. integration tests, where we know that we are expecting to respond to a single exchange within the run of the test.

impl<'d, 'a, C, B, T, K, N, NC, R, const NS: usize, const NE: usize> Responder<'a, ChainedExchangeHandler<&'d InteractionModel<'a, C, B, T, K, N, NC, R, NS, NE>, SecureChannel<'d, &'d C>>>

where B: Buffers<Vec<u8, rs_matter::::transport::exchange::Buffer::{constant#0}>>,

pub const fn new_default( data_model: &'d InteractionModel<'a, C, B, T, K, N, NC, R, NS, NE>, ) -> Responder<'a, ChainedExchangeHandler<&'d InteractionModel<'a, C, B, T, K, N, NC, R, NS, NE>, SecureChannel<'d, &'d C>>>

where C: Crypto, T: DataModel, K: KvBlobStoreAccess, N: Networks, R: ReportDataHandler,

Creates a “default” responder. This is a responder that composes and uses the rs-matter-provided ExchangeHandler implementations (SecureChannel and InteractionModel) for handling the Secure Channel protocol and the Interaction Model protocol.

impl<'a> Responder<'a, ChainedExchangeHandler<BusyInteractionModel, BusySecureChannel>>

pub const fn new_busy( matter: &'a Matter<'a>, respond_after_ms: u32, ) -> Responder<'a, ChainedExchangeHandler<BusyInteractionModel, BusySecureChannel>>

Creates a simple “busy” responder, which is answering all exchanges with a simple “I’m busy, try again later” handling. The resonder is using the rs-matter-provided ExchangeHandler instances (BusySecureChannel and BusyInteractionModel) capable of answering with “busy” messages the SC and IM protocols, respectively.

Exchanges which are not accepted after the specified milliseconds are answered by this responder, as the assumption is that the main responder is busy and cannot answer these right now.