Sequential Exchange API

Author: ivmarkov

examples/onoff_light/src/main.rs

@@ -23,28 +23,23 @@ use log::info;
 use matter::core::{CommissioningData, Matter};
 use matter::data_model::cluster_basic_information::BasicInfoConfig;
 use matter::data_model::cluster_on_off;
-use matter::data_model::core::DataModel;
 use matter::data_model::device_types::DEV_TYPE_ON_OFF_LIGHT;
 use matter::data_model::objects::*;
 use matter::data_model::root_endpoint;
 use matter::data_model::system_model::descriptor;
 use matter::error::Error;
-use matter::interaction_model::core::InteractionModel;
 use matter::mdns::{DefaultMdns, DefaultMdnsRunner};
 use matter::secure_channel::spake2p::VerifierData;
-use matter::transport::network::{Address, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
-use matter::transport::{
-    core::RecvAction, core::Transport, packet::MAX_RX_BUF_SIZE, packet::MAX_TX_BUF_SIZE,
-    udp::UdpListener,
-};
+use matter::transport::network::{Ipv4Addr, Ipv6Addr};
+use matter::transport::runner::{RxBuf, TransportRunner, TxBuf};
 use matter::utils::select::EitherUnwrap;
 
 mod dev_att;
 
 #[cfg(feature = "std")]
 fn main() -> Result<(), Error> {
     let thread = std::thread::Builder::new()
-        .stack_size(120 * 1024)
+        .stack_size(140 * 1024)
         .spawn(run)
         .unwrap();
 
@@ -62,10 +57,10 @@ fn run() -> Result<(), Error> {
     initialize_logger();
 
     info!(
-        "Matter memory: mDNS={}, Matter={}, Transport={}",
+        "Matter memory: mDNS={}, Matter={}, TransportRunner={}",
         core::mem::size_of::<DefaultMdns>(),
         core::mem::size_of::<Matter>(),
-        core::mem::size_of::<Transport>(),
+        core::mem::size_of::<TransportRunner>(),
     );
 
     let dev_det = BasicInfoConfig {
@@ -92,6 +87,8 @@ fn run() -> Result<(), Error> {
 
     let mut mdns_runner = DefaultMdnsRunner::new(&mdns);
 
+    info!("mDNS initialized: {:p}, {:p}", &mdns, &mdns_runner);
+
     let dev_att = dev_att::HardCodedDevAtt::new();
 
     #[cfg(feature = "std")]
@@ -118,36 +115,25 @@ fn run() -> Result<(), Error> {
         matter::MATTER_PORT,
     );
 
-    let psm_path = std::env::temp_dir().join("matter-iot");
-    info!("Persisting from/to {}", psm_path.display());
-
-    #[cfg(all(feature = "std", not(target_os = "espidf")))]
-    let psm = matter::persist::FilePsm::new(psm_path)?;
+    info!("Matter initialized: {:p}", &matter);
 
-    let mut buf = [0; 4096];
-    let buf = &mut buf;
+    let mut runner = TransportRunner::new(&matter);
 
-    #[cfg(all(feature = "std", not(target_os = "espidf")))]
-    {
-        if let Some(data) = psm.load("acls", buf)? {
-            matter.load_acls(data)?;
-        }
+    info!("Transport Runner initialized: {:p}", &runner);
 
-        if let Some(data) = psm.load("fabrics", buf)? {
-            matter.load_fabrics(data)?;
-        }
-    }
+    let mut tx_buf = TxBuf::uninit();
+    let mut rx_buf = RxBuf::uninit();
 
-    let mut transport = Transport::new(&matter);
+    // #[cfg(all(feature = "std", not(target_os = "espidf")))]
+    // {
+    //     if let Some(data) = psm.load("acls", buf)? {
+    //         matter.load_acls(data)?;
+    //     }
 
-    transport.start(
-        CommissioningData {
-            // TODO: Hard-coded for now
-            verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
-            discriminator: 250,
-        },
-        buf,
-    )?;
+    //     if let Some(data) = psm.load("fabrics", buf)? {
+    //         matter.load_fabrics(data)?;
+    //     }
+    // }
 
     let node = Node {
         id: 0,
@@ -161,69 +147,48 @@ fn run() -> Result<(), Error> {
         ],
     };
 
-    let mut handler = handler(&matter);
+    let handler = HandlerCompat(handler(&matter));
 
-    let mut im = InteractionModel(DataModel::new(matter.borrow(), &node, &mut handler));
-
-    let mut rx_buf = [0; MAX_RX_BUF_SIZE];
-    let mut tx_buf = [0; MAX_TX_BUF_SIZE];
-
-    let im = &mut im;
-    let mdns_runner = &mut mdns_runner;
-    let transport = &mut transport;
-    let rx_buf = &mut rx_buf;
+    let matter = &matter;
+    let node = &node;
+    let handler = &handler;
+    let runner = &mut runner;
     let tx_buf = &mut tx_buf;
+    let rx_buf = &mut rx_buf;
 
-    let mut io_fut = pin!(async move {
-        // NOTE (no_std): On no_std, the `UdpListener` implementation is a no-op so you might want to
-        // replace it with your own UDP stack
-        let udp = UdpListener::new(SocketAddr::new(
-            IpAddr::V6(Ipv6Addr::UNSPECIFIED),
-            matter::MATTER_PORT,
-        ))
-        .await?;
-
-        loop {
-            let (len, addr) = udp.recv(rx_buf).await?;
-
-            let mut completion = transport.recv(Address::Udp(addr), &mut rx_buf[..len], tx_buf);
-
-            while let Some(action) = completion.next_action()? {
-                match action {
-                    RecvAction::Send(addr, buf) => {
-                        udp.send(addr.unwrap_udp(), buf).await?;
-                    }
-                    RecvAction::Interact(mut ctx) => {
-                        if im.handle(&mut ctx)? && ctx.send()? {
-                            udp.send(ctx.tx.peer.unwrap_udp(), ctx.tx.as_slice())
-                                .await?;
-                        }
-                    }
-                }
-            }
-
-            #[cfg(all(feature = "std", not(target_os = "espidf")))]
-            {
-                if let Some(data) = transport.matter().store_fabrics(buf)? {
-                    psm.store("fabrics", data)?;
-                }
-
-                if let Some(data) = transport.matter().store_acls(buf)? {
-                    psm.store("acls", data)?;
-                }
-            }
-        }
-
-        #[allow(unreachable_code)]
-        Ok::<_, matter::error::Error>(())
-    });
+    info!(
+        "About to run wth node {:p}, handler {:p}, transport runner {:p}, mdns_runner {:p}",
+        node, handler, runner, &mdns_runner
+    );
+
+    let mut fut = pin!(async move {
+        // NOTE (no_std): On no_std, the `run_udp` is a no-op so you might want to replace it with `run` and
+        // connect the pipes of the `run` method with your own UDP stack
+        let mut transport = pin!(runner.run_udp(
+            tx_buf,
+            rx_buf,
+            CommissioningData {
+                // TODO: Hard-coded for now
+                verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
+                discriminator: 250,
+            },
+            &handler,
+        ));
 
-    // NOTE (no_std): On no_std, the `run_udp` is a no-op so you might want to replace it with `run` and
-    // connect the pipes of the `run` method with your own UDP stack
-    let mut mdns_fut = pin!(async move { mdns_runner.run_udp().await });
+        // NOTE (no_std): On no_std, the `run_udp` is a no-op so you might want to replace it with `run` and
+        // connect the pipes of the `run` method with your own UDP stack
+        let mut mdns = pin!(mdns_runner.run_udp());
 
-    let mut fut = pin!(async move { select(&mut io_fut, &mut mdns_fut).await.unwrap() });
+        select(
+            &mut transport,
+            &mut mdns,
+            //save(transport, &psm),
+        )
+        .await
+        .unwrap()
+    });
 
+    // NOTE: For no_std, replace with your own no_std way of polling the future
     #[cfg(feature = "std")]
     smol::block_on(&mut fut)?;
 
@@ -235,18 +200,33 @@ fn run() -> Result<(), Error> {
     Ok(())
 }
 
-fn handler<'a>(matter: &'a Matter<'a>) -> impl Handler + 'a {
-    root_endpoint::handler(0, matter)
-        .chain(
-            1,
-            descriptor::ID,
-            descriptor::DescriptorCluster::new(*matter.borrow()),
-        )
-        .chain(
-            1,
-            cluster_on_off::ID,
-            cluster_on_off::OnOffCluster::new(*matter.borrow()),
-        )
+const NODE: Node<'static> = Node {
+    id: 0,
+    endpoints: &[
+        root_endpoint::endpoint(0),
+        Endpoint {
+            id: 1,
+            device_type: DEV_TYPE_ON_OFF_LIGHT,
+            clusters: &[descriptor::CLUSTER, cluster_on_off::CLUSTER],
+        },
+    ],
+};
+
+fn handler<'a>(matter: &'a Matter<'a>) -> impl Metadata + NonBlockingHandler + 'a {
+    (
+        NODE,
+        root_endpoint::handler(0, matter)
+            .chain(
+                1,
+                descriptor::ID,
+                descriptor::DescriptorCluster::new(*matter.borrow()),
+            )
+            .chain(
+                1,
+                cluster_on_off::ID,
+                cluster_on_off::OnOffCluster::new(*matter.borrow()),
+            ),
+    )
 }
 
 // NOTE (no_std): For no_std, implement here your own way of initializing the logger

matter/src/data_model/cluster_on_off.rs

@@ -15,12 +15,12 @@
  *    limitations under the License.
  */
 
-use core::convert::TryInto;
+use core::{cell::Cell, convert::TryInto};
 
 use super::objects::*;
 use crate::{
-    attribute_enum, cmd_enter, command_enum, error::Error, interaction_model::core::Transaction,
-    tlv::TLVElement, utils::rand::Rand,
+    attribute_enum, cmd_enter, command_enum, error::Error, tlv::TLVElement,
+    transport::exchange::Exchange, utils::rand::Rand,
 };
 use log::info;
 use strum::{EnumDiscriminants, FromRepr};
@@ -66,20 +66,20 @@ pub const CLUSTER: Cluster<'static> = Cluster {
 
 pub struct OnOffCluster {
     data_ver: Dataver,
-    on: bool,
+    on: Cell<bool>,
 }
 
 impl OnOffCluster {
     pub fn new(rand: Rand) -> Self {
         Self {
             data_ver: Dataver::new(rand),
-            on: false,
+            on: Cell::new(false),
         }
     }
 
-    pub fn set(&mut self, on: bool) {
-        if self.on != on {
-            self.on = on;
+    pub fn set(&self, on: bool) {
+        if self.on.get() != on {
+            self.on.set(on);
             self.data_ver.changed();
         }
     }
@@ -90,15 +90,15 @@ impl OnOffCluster {
                 CLUSTER.read(attr.attr_id, writer)
             } else {
                 match attr.attr_id.try_into()? {
-                    Attributes::OnOff(codec) => codec.encode(writer, self.on),
+                    Attributes::OnOff(codec) => codec.encode(writer, self.on.get()),
                 }
             }
         } else {
             Ok(())
         }
     }
 
-    pub fn write(&mut self, attr: &AttrDetails, data: AttrData) -> Result<(), Error> {
+    pub fn write(&self, attr: &AttrDetails, data: AttrData) -> Result<(), Error> {
         let data = data.with_dataver(self.data_ver.get())?;
 
         match attr.attr_id.try_into()? {
@@ -111,8 +111,8 @@ impl OnOffCluster {
     }
 
     pub fn invoke(
-        &mut self,
-        transaction: &mut Transaction,
+        &self,
+        _exchange: &Exchange,
         cmd: &CmdDetails,
         _data: &TLVElement,
         _encoder: CmdDataEncoder,
@@ -128,12 +128,10 @@ impl OnOffCluster {
             }
             Commands::Toggle => {
                 cmd_enter!("Toggle");
-                self.set(!self.on);
+                self.set(!self.on.get());
             }
         }
 
-        transaction.complete();
-
         self.data_ver.changed();
 
         Ok(())
@@ -145,18 +143,18 @@ impl Handler for OnOffCluster {
         OnOffCluster::read(self, attr, encoder)
     }
 
-    fn write(&mut self, attr: &AttrDetails, data: AttrData) -> Result<(), Error> {
+    fn write(&self, attr: &AttrDetails, data: AttrData) -> Result<(), Error> {
         OnOffCluster::write(self, attr, data)
     }
 
     fn invoke(
-        &mut self,
-        transaction: &mut Transaction,
+        &self,
+        exchange: &Exchange,
         cmd: &CmdDetails,
         data: &TLVElement,
         encoder: CmdDataEncoder,
     ) -> Result<(), Error> {
-        OnOffCluster::invoke(self, transaction, cmd, data, encoder)
+        OnOffCluster::invoke(self, exchange, cmd, data, encoder)
     }
 }