Simplify main user-facing API

Author: ivmarkov

examples/onoff_light/src/main.rs

@@ -27,7 +27,6 @@ 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::sdm::dev_att::DevAttDataFetcher;
 use matter::data_model::system_model::descriptor;
 use matter::error::Error;
 use matter::interaction_model::core::InteractionModel;
@@ -36,7 +35,7 @@ use matter::persist;
 use matter::secure_channel::spake2p::VerifierData;
 use matter::transport::network::{Address, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use matter::transport::{
-    mgr::RecvAction, mgr::TransportMgr, packet::MAX_RX_BUF_SIZE, packet::MAX_TX_BUF_SIZE,
+    core::RecvAction, core::Transport, packet::MAX_RX_BUF_SIZE, packet::MAX_TX_BUF_SIZE,
     udp::UdpListener,
 };
 use matter::utils::select::EitherUnwrap;
@@ -66,7 +65,7 @@ fn run() -> Result<(), Error> {
     info!(
         "Matter memory: mDNS={}, Transport={} (of which Matter={})",
         core::mem::size_of::<Mdns>(),
-        core::mem::size_of::<TransportMgr>(),
+        core::mem::size_of::<Transport>(),
         core::mem::size_of::<Matter>(),
     );
 
@@ -83,9 +82,11 @@ fn run() -> Result<(), Error> {
     //let (mut mdns, mdns_runner) = (matter::mdns::astro::AstroMdns::new()?, core::future::pending::pending());
     //let (mut mdns, mdns_runner) = (matter::mdns::DummyMdns {}, core::future::pending::pending());
 
+    let dev_att = dev_att::HardCodedDevAtt::new();
+
     let matter = Matter::new_default(
         // vid/pid should match those in the DAC
-        &BasicInfoConfig {
+        BasicInfoConfig {
             vid: 0xFFF1,
             pid: 0x8000,
             hw_ver: 2,
@@ -94,12 +95,11 @@ fn run() -> Result<(), Error> {
             serial_no: "aabbccdd",
             device_name: "OnOff Light",
         },
+        &dev_att,
         &mut mdns,
         matter::MATTER_PORT,
     );
 
-    let dev_att = dev_att::HardCodedDevAtt::new();
-
     let psm_path = std::env::temp_dir().join("matter-iot");
     info!("Persisting from/to {}", psm_path.display());
 
@@ -115,7 +115,9 @@ fn run() -> Result<(), Error> {
         matter.load_fabrics(data)?;
     }
 
-    matter.start(
+    let mut transport = Transport::new(&matter);
+
+    transport.start(
         CommissioningData {
             // TODO: Hard-coded for now
             verifier: VerifierData::new_with_pw(123456, *matter.borrow()),
@@ -125,10 +127,7 @@ fn run() -> Result<(), Error> {
     )?;
 
     let matter = &matter;
-    let dev_att = &dev_att;
     let mdns_runner = &mut mdns_runner;
-
-    let mut transport = TransportMgr::new(matter);
     let transport = &mut transport;
 
     let mut io_fut = pin!(async move {
@@ -165,7 +164,7 @@ fn run() -> Result<(), Error> {
                             ],
                         };
 
-                        let mut handler = handler(matter, dev_att);
+                        let mut handler = handler(matter);
 
                         let mut im =
                             InteractionModel(DataModel::new(matter.borrow(), &node, &mut handler));
@@ -180,11 +179,11 @@ fn run() -> Result<(), Error> {
                 }
             }
 
-            if let Some(data) = matter.store_fabrics(&mut buf)? {
+            if let Some(data) = transport.matter().store_fabrics(&mut buf)? {
                 psm.store("fabrics", data)?;
             }
 
-            if let Some(data) = matter.store_acls(&mut buf)? {
+            if let Some(data) = transport.matter().store_acls(&mut buf)? {
                 psm.store("acls", data)?;
             }
         }
@@ -202,8 +201,8 @@ fn run() -> Result<(), Error> {
     Ok::<_, matter::error::Error>(())
 }
 
-fn handler<'a>(matter: &'a Matter<'a>, dev_att: &'a dyn DevAttDataFetcher) -> impl Handler + 'a {
-    root_endpoint::handler(0, dev_att, matter)
+fn handler<'a>(matter: &'a Matter<'a>) -> impl Handler + 'a {
+    root_endpoint::handler(0, matter)
         .chain(
             1,
             descriptor::ID,

matter/src/core.rs

@@ -19,7 +19,10 @@ use core::{borrow::Borrow, cell::RefCell};
 
 use crate::{
     acl::AclMgr,
-    data_model::{cluster_basic_information::BasicInfoConfig, sdm::failsafe::FailSafe},
+    data_model::{
+        cluster_basic_information::BasicInfoConfig,
+        sdm::{dev_att::DevAttDataFetcher, failsafe::FailSafe},
+    },
     error::*,
     fabric::FabricMgr,
     mdns::{Mdns, MdnsMgr},
@@ -48,17 +51,24 @@ pub struct Matter<'a> {
     pub mdns_mgr: RefCell<MdnsMgr<'a>>,
     pub epoch: Epoch,
     pub rand: Rand,
-    pub dev_det: &'a BasicInfoConfig<'a>,
+    pub dev_det: BasicInfoConfig<'a>,
+    pub dev_att: &'a dyn DevAttDataFetcher,
+    pub port: u16,
 }
 
 impl<'a> Matter<'a> {
     #[cfg(feature = "std")]
     #[inline(always)]
-    pub fn new_default(dev_det: &'a BasicInfoConfig, mdns: &'a mut dyn Mdns, port: u16) -> Self {
+    pub fn new_default(
+        dev_det: BasicInfoConfig<'a>,
+        dev_att: &'a dyn DevAttDataFetcher,
+        mdns: &'a mut dyn Mdns,
+        port: u16,
+    ) -> Self {
         use crate::utils::epoch::sys_epoch;
         use crate::utils::rand::sys_rand;
 
-        Self::new(dev_det, mdns, sys_epoch, sys_rand, port)
+        Self::new(dev_det, dev_att, mdns, sys_epoch, sys_rand, port)
     }
 
     /// Creates a new Matter object
@@ -69,7 +79,8 @@ impl<'a> Matter<'a> {
     /// this object to return the device attestation details when queried upon.
     #[inline(always)]
     pub fn new(
-        dev_det: &'a BasicInfoConfig,
+        dev_det: BasicInfoConfig<'a>,
+        dev_att: &'a dyn DevAttDataFetcher,
         mdns: &'a mut dyn Mdns,
         epoch: Epoch,
         rand: Rand,
@@ -90,11 +101,21 @@ impl<'a> Matter<'a> {
             epoch,
             rand,
             dev_det,
+            dev_att,
+            port,
         }
     }
 
-    pub fn dev_det(&self) -> &BasicInfoConfig {
-        self.dev_det
+    pub fn dev_det(&self) -> &BasicInfoConfig<'_> {
+        &self.dev_det
+    }
+
+    pub fn dev_att(&self) -> &dyn DevAttDataFetcher {
+        self.dev_att
+    }
+
+    pub fn port(&self) -> u16 {
+        self.port
     }
 
     pub fn load_fabrics(&self, data: &[u8]) -> Result<(), Error> {
@@ -119,11 +140,15 @@ impl<'a> Matter<'a> {
         self.acl_mgr.borrow().is_changed() || self.fabric_mgr.borrow().is_changed()
     }
 
-    pub fn start(&self, dev_comm: CommissioningData, buf: &mut [u8]) -> Result<(), Error> {
-        let open_comm_window = self.fabric_mgr.borrow().is_empty();
-        if open_comm_window {
+    pub fn start_comissioning(
+        &self,
+        dev_comm: CommissioningData,
+        buf: &mut [u8],
+    ) -> Result<bool, Error> {
+        if !self.pase_mgr.borrow().is_pase_session_enabled() && self.fabric_mgr.borrow().is_empty()
+        {
             print_pairing_code_and_qr(
-                self.dev_det,
+                &self.dev_det,
                 &dev_comm,
                 DiscoveryCapabilities::default(),
                 buf,
@@ -134,9 +159,11 @@ impl<'a> Matter<'a> {
                 dev_comm.discriminator,
                 &mut self.mdns_mgr.borrow_mut(),
             )?;
-        }
 
-        Ok(())
+            Ok(true)
+        } else {
+            Ok(false)
+        }
     }
 }
 

matter/src/data_model/root_endpoint.rs

@@ -55,15 +55,11 @@ pub fn endpoint(id: EndptId) -> Endpoint<'static> {
     }
 }
 
-pub fn handler<'a>(
-    endpoint_id: u16,
-    dev_att: &'a dyn DevAttDataFetcher,
-    matter: &'a Matter<'a>,
-) -> RootEndpointHandler<'a> {
+pub fn handler<'a>(endpoint_id: u16, matter: &'a Matter<'a>) -> RootEndpointHandler<'a> {
     wrap(
         endpoint_id,
         matter.dev_det(),
-        dev_att,
+        matter.dev_att(),
         matter.borrow(),
         matter.borrow(),
         matter.borrow(),

matter/src/secure_channel/core.rs

@@ -15,7 +15,7 @@
  *    limitations under the License.
  */
 
-use core::cell::RefCell;
+use core::{borrow::Borrow, cell::RefCell};
 
 use crate::{
     error::*,
@@ -24,7 +24,7 @@ use crate::{
     secure_channel::common::*,
     tlv,
     transport::{proto_ctx::ProtoCtx, session::CloneData},
-    utils::rand::Rand,
+    utils::{epoch::Epoch, rand::Rand},
 };
 use log::{error, info};
 use num;
@@ -42,14 +42,32 @@ pub struct SecureChannel<'a> {
 
 impl<'a> SecureChannel<'a> {
     #[inline(always)]
-    pub fn new(
+    pub fn new<
+        T: Borrow<RefCell<FabricMgr>>
+            + Borrow<RefCell<PaseMgr>>
+            + Borrow<RefCell<MdnsMgr<'a>>>
+            + Borrow<Epoch>
+            + Borrow<Rand>,
+    >(
+        matter: &'a T,
+    ) -> Self {
+        Self::wrap(
+            matter.borrow(),
+            matter.borrow(),
+            matter.borrow(),
+            *matter.borrow(),
+        )
+    }
+
+    #[inline(always)]
+    pub fn wrap(
         pase: &'a RefCell<PaseMgr>,
-        fabric_mgr: &'a RefCell<FabricMgr>,
+        fabric: &'a RefCell<FabricMgr>,
         mdns: &'a RefCell<MdnsMgr<'a>>,
         rand: Rand,
     ) -> Self {
-        SecureChannel {
-            case: Case::new(fabric_mgr, rand),
+        Self {
+            case: Case::new(fabric, rand),
             pase,
             mdns,
         }

matter/src/secure_channel/pake.rs

@@ -59,6 +59,10 @@ impl PaseMgr {
         }
     }
 
+    pub fn is_pase_session_enabled(&self) -> bool {
+        matches!(&self.state, PaseMgrState::Enabled(_, _, _))
+    }
+
     pub fn enable_pase_session(
         &mut self,
         verifier: VerifierData,