Update to rs-matter with HandlerContext (#18)

Author: ivmarkov

.github/workflows/ci.yml

@@ -54,4 +54,4 @@ jobs:
 
       - name: Examples
         if: matrix.features == 'os'
-        run: cargo build --examples --features ${{matrix.features}},nix,log
+        run: cargo build --examples --features ${{matrix.features}},nix,log,examples

README.md

@@ -60,6 +60,7 @@ The [`esp-idf-matter`](https://github.com/ivmarkov/esp-idf-matter) crate provide
 //! its credentials etc. and can assume it "pre-exists".
 //!
 //! The example implements a fictitious Light device (an On-Off Matter cluster).
+#![recursion_limit = "256"]
 
 use core::pin::pin;
 
@@ -88,6 +89,8 @@ use rs_matter_stack::persist::DirKvBlobStore;
 
 use static_cell::StaticCell;
 
+const BUMP_SIZE: usize = 20000;
+
 fn main() -> Result<(), Error> {
     env_logger::Builder::from_env(
         env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
@@ -162,7 +165,7 @@ fn main() -> Result<(), Error> {
 
             // Let the Matter stack know that we have changed
             // the state of our Light device
-            stack.notify_changed();
+            stack.notify_cluster_changed(1, on_off::OnOffHandler::CLUSTER.id);
 
             info!("Light toggled");
         }
@@ -174,7 +177,7 @@ fn main() -> Result<(), Error> {
 
 /// The Matter stack is allocated statically to avoid
 /// program stack blowups.
-static MATTER_STACK: StaticCell<EthMatterStack> = StaticCell::new();
+static MATTER_STACK: StaticCell<EthMatterStack<BUMP_SIZE, ()>> = StaticCell::new();
 
 /// Endpoint 0 (the root endpoint) always runs
 /// the hidden Matter system clusters, so we pick ID=1
@@ -184,7 +187,7 @@ const LIGHT_ENDPOINT_ID: u16 = 1;
 const NODE: Node = Node {
     id: 0,
     endpoints: &[
-        EthMatterStack::<()>::root_endpoint(),
+        EthMatterStack::<0, ()>::root_endpoint(),
         Endpoint {
             id: LIGHT_ENDPOINT_ID,
             device_types: devices!(DEV_TYPE_ON_OFF_LIGHT),

examples/light.rs

@@ -38,6 +38,8 @@ use rs_matter_stack::wireless::WifiMatterStack;
 
 use static_cell::StaticCell;
 
+const BUMP_SIZE: usize = 24000;
+
 fn main() -> Result<(), Error> {
     env_logger::init_from_env(
         env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
@@ -78,7 +80,7 @@ fn main() -> Result<(), Error> {
     // Using `pin!` is completely optional, but saves some memory due to `rustc`
     // not being very intelligent w.r.t. stack usage in async functions
     let store = stack.create_shared_store(DirKvBlobStore::new_default());
-    let mut matter = pin!(stack.run(
+    let mut matter = pin!(stack.run_coex(
         PreexistingWireless::new(
             // The Matter stack needs UDP sockets to communicate with other Matter devices
             edge_nal_std::Stack::new(),
@@ -113,7 +115,7 @@ fn main() -> Result<(), Error> {
 
             // Let the Matter stack know that we have changed
             // the state of our Light device
-            stack.notify_changed();
+            stack.notify_cluster_changed(1, on_off::OnOffHandler::CLUSTER.id);
 
             info!("Light toggled");
         }
@@ -128,7 +130,7 @@ fn main() -> Result<(), Error> {
 /// The Matter stack is allocated statically to avoid
 /// program stack blowups.
 /// It is also a mandatory requirement when the `WifiBle` stack variation is used.
-static MATTER_STACK: StaticCell<WifiMatterStack<StdRawMutex>> = StaticCell::new();
+static MATTER_STACK: StaticCell<WifiMatterStack<BUMP_SIZE, StdRawMutex>> = StaticCell::new();
 
 /// Endpoint 0 (the root endpoint) always runs
 /// the hidden Matter system clusters, so we pick ID=1
@@ -138,7 +140,7 @@ const LIGHT_ENDPOINT_ID: u16 = 1;
 const NODE: Node = Node {
     id: 0,
     endpoints: &[
-        WifiMatterStack::<StdRawMutex, ()>::root_endpoint(),
+        WifiMatterStack::<0, StdRawMutex, ()>::root_endpoint(),
         Endpoint {
             id: LIGHT_ENDPOINT_ID,
             device_types: devices!(DEV_TYPE_ON_OFF_LIGHT),

examples/light_eth.rs

@@ -37,6 +37,8 @@ use rs_matter_stack::persist::DirKvBlobStore;
 
 use static_cell::StaticCell;
 
+const BUMP_SIZE: usize = 20000;
+
 fn main() -> Result<(), Error> {
     env_logger::Builder::from_env(
         env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
@@ -111,7 +113,7 @@ fn main() -> Result<(), Error> {
 
             // Let the Matter stack know that we have changed
             // the state of our Light device
-            stack.notify_changed();
+            stack.notify_cluster_changed(1, on_off::OnOffHandler::CLUSTER.id);
 
             info!("Light toggled");
         }
@@ -123,7 +125,7 @@ fn main() -> Result<(), Error> {
 
 /// The Matter stack is allocated statically to avoid
 /// program stack blowups.
-static MATTER_STACK: StaticCell<EthMatterStack> = StaticCell::new();
+static MATTER_STACK: StaticCell<EthMatterStack<BUMP_SIZE, ()>> = StaticCell::new();
 
 /// Endpoint 0 (the root endpoint) always runs
 /// the hidden Matter system clusters, so we pick ID=1
@@ -133,7 +135,7 @@ const LIGHT_ENDPOINT_ID: u16 = 1;
 const NODE: Node = Node {
     id: 0,
     endpoints: &[
-        EthMatterStack::<()>::root_endpoint(),
+        EthMatterStack::<0, ()>::root_endpoint(),
         Endpoint {
             id: LIGHT_ENDPOINT_ID,
             device_types: devices!(DEV_TYPE_ON_OFF_LIGHT),

src/lib.rs

@@ -29,8 +29,7 @@ use rs_matter::dm::clusters::dev_att::DevAttDataFetcher;
 use rs_matter::dm::clusters::gen_diag::NetifDiag;
 use rs_matter::dm::networks::NetChangeNotif;
 use rs_matter::dm::subscriptions::Subscriptions;
-use rs_matter::dm::IMBuffer;
-use rs_matter::dm::{AsyncHandler, AsyncMetadata};
+use rs_matter::dm::{AsyncHandler, AsyncMetadata, ClusterId, DataModel, EndptId, IMBuffer};
 use rs_matter::error::{Error, ErrorCode};
 use rs_matter::respond::{DefaultResponder, ExchangeHandler, Responder};
 use rs_matter::transport::network::{Address, ChainedNetwork, NetworkReceive, NetworkSend};
@@ -344,13 +343,18 @@ where
     /// Notifies the Matter instance that there is a change in the state
     /// of one of the clusters.
     ///
-    /// User is expected to call this method when user-provided clusters
-    /// change their state.
+    /// User is expected to call this method when a user-provided cluster
+    /// changes its state.
     ///
     /// This is necessary so as the Matter instance can notify clients
     /// that have active subscriptions to some of the changed clusters.
-    pub fn notify_changed(&self) {
-        self.subscriptions.notify_changed();
+    ///
+    /// # Arguments
+    /// - `endpoint_id` - the endpoint ID where the cluster is located
+    /// - `cluster_id` - the ID of the cluster that has changed
+    pub fn notify_cluster_changed(&self, endpoint_id: EndptId, cluster_id: ClusterId) {
+        self.subscriptions
+            .notify_cluster_changed(endpoint_id, cluster_id);
     }
 
     // /// User code hook to get the state of the netif passed to the
@@ -607,10 +611,12 @@ where
         // Reset the Matter transport buffers and all sessions first
         // self.matter().reset_transport()?;
 
-        let mut responder = pin!(self.run_responder(&handler));
-        let mut handler = pin!(handler.run());
+        let dm = DataModel::new(self.matter(), &self.buffers, &self.subscriptions, handler);
+
+        let mut responder = pin!(self.run_responder(&dm));
+        let mut dm_job = pin!(dm.run());
 
-        select(&mut responder, &mut handler).coalesce().await
+        select(&mut responder, &mut dm_job).coalesce().await
     }
 
     async fn run_handler_with_bump<H>(&self, handler: H) -> Result<(), Error>
@@ -621,10 +627,12 @@ where
         // Reset the Matter transport buffers and all sessions first
         // self.matter().reset_transport()?;
 
-        let mut responder = pin_alloc!(self.bump, self.run_responder_with_bump(&handler));
-        let mut handler = pin_alloc!(self.bump, handler.run());
+        let dm = DataModel::new(self.matter(), &self.buffers, &self.subscriptions, handler);
 
-        select(&mut responder, &mut handler).coalesce().await
+        let mut responder = pin_alloc!(self.bump, self.run_responder_with_bump(&dm));
+        let mut dm_job = pin!(dm.run());
+
+        select(&mut responder, &mut dm_job).coalesce().await
     }
 
     fn run_psm<'t, S, C>(
@@ -638,12 +646,14 @@ where
         persist.run()
     }
 
-    async fn run_responder<H>(&self, handler: H) -> Result<(), Error>
+    async fn run_responder<const SN: usize, H>(
+        &self,
+        dm: &DataModel<'_, SN, PooledBuffers<MAX_IM_BUFFERS, NoopRawMutex, IMBuffer>, H>,
+    ) -> Result<(), Error>
     where
         H: AsyncHandler + AsyncMetadata,
     {
-        let responder =
-            DefaultResponder::new(self.matter(), &self.buffers, &self.subscriptions, handler);
+        let responder = DefaultResponder::new(dm);
 
         // Run the responder with up to MAX_RESPONDERS handlers (i.e. MAX_RESPONDERS exchanges can be handled simultenously)
         // Clients trying to open more exchanges than the ones currently running will get "I'm busy, please try again later"
@@ -652,12 +662,14 @@ where
         Ok(())
     }
 
-    async fn run_responder_with_bump<H>(&self, handler: H) -> Result<(), Error>
+    async fn run_responder_with_bump<const SN: usize, H>(
+        &self,
+        dm: &DataModel<'_, SN, PooledBuffers<MAX_IM_BUFFERS, NoopRawMutex, IMBuffer>, H>,
+    ) -> Result<(), Error>
     where
         H: AsyncHandler + AsyncMetadata,
     {
-        let responder =
-            DefaultResponder::new(self.matter(), &self.buffers, &self.subscriptions, handler);
+        let responder = DefaultResponder::new(dm);
 
         let mut actual = pin_alloc!(
             self.bump,