[Fabric-Sync] Integrate fabric bridge functionalities into fabric-sync (#36166)
diff --git a/examples/fabric-sync/bridge/BUILD.gn b/examples/fabric-sync/bridge/BUILD.gn
index cdf3671..310496b 100644
--- a/examples/fabric-sync/bridge/BUILD.gn
+++ b/examples/fabric-sync/bridge/BUILD.gn
@@ -40,7 +40,17 @@
source_set("fabric-bridge-lib") {
public_configs = [ ":config" ]
- sources = [ "include/CHIPProjectAppConfig.h" ]
+ sources = [
+ "include/BridgedAdministratorCommissioning.h",
+ "include/BridgedDevice.h",
+ "include/BridgedDeviceBasicInformationImpl.h",
+ "include/BridgedDeviceManager.h",
+ "include/CHIPProjectAppConfig.h",
+ "src/BridgedAdministratorCommissioning.cpp",
+ "src/BridgedDevice.cpp",
+ "src/BridgedDeviceBasicInformationImpl.cpp",
+ "src/BridgedDeviceManager.cpp",
+ ]
deps = [
"${chip_root}/examples/fabric-sync/bridge:fabric-bridge-common",
diff --git a/examples/fabric-sync/bridge/include/BridgedAdministratorCommissioning.h b/examples/fabric-sync/bridge/include/BridgedAdministratorCommissioning.h
new file mode 100644
index 0000000..06fd902
--- /dev/null
+++ b/examples/fabric-sync/bridge/include/BridgedAdministratorCommissioning.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/AttributeAccessInterfaceRegistry.h>
+
+/**
+ * @brief CADMIN cluster implementation for handling attribute interactions of bridged device endpoints.
+ *
+ * The current Administrator Commissioning Cluster server's zap generated code will automatically
+ * register an Attribute Access Interface for the root node endpoint implementation. In order to
+ * properly respond to a read attribute for bridged devices we are representing, we override the
+ * currently registered Attribute Interface such that we are first to receive any read attribute
+ * request on Administrator Commissioning Cluster, and if it is not an endpoint for a device we
+ * are a bridge for we redirect to the default cluster server implementation of Administrator
+ * Commissioning Cluster.
+ */
+class BridgedAdministratorCommissioning : public chip::app::AttributeAccessInterface
+{
+public:
+ // Register for the AdministratorCommissioning cluster on all endpoints.
+ BridgedAdministratorCommissioning() :
+ AttributeAccessInterface(chip::NullOptional, chip::app::Clusters::AdministratorCommissioning::Id)
+ {}
+
+ CHIP_ERROR Init();
+
+ CHIP_ERROR Read(const chip::app::ConcreteReadAttributePath & aPath, chip::app::AttributeValueEncoder & aEncoder) override;
+
+ // We do not allow writing to CADMIN attributes of a bridged device endpoint. We simply redirect
+ // write requests to the original attribute interface.
+ CHIP_ERROR Write(const chip::app::ConcreteDataAttributePath & aPath, chip::app::AttributeValueDecoder & aDecoder) override
+ {
+ VerifyOrDie(mOriginalAttributeInterface);
+ return mOriginalAttributeInterface->Write(aPath, aDecoder);
+ }
+
+private:
+ // If mOriginalAttributeInterface is removed from here, the class description needs to be updated
+ // to reflect this change.
+ chip::app::AttributeAccessInterface * mOriginalAttributeInterface = nullptr;
+};
diff --git a/examples/fabric-sync/bridge/include/BridgedDevice.h b/examples/fabric-sync/bridge/include/BridgedDevice.h
new file mode 100644
index 0000000..d2c5a64
--- /dev/null
+++ b/examples/fabric-sync/bridge/include/BridgedDevice.h
@@ -0,0 +1,92 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/util/attribute-storage.h>
+
+#include <string>
+
+class BridgedDevice
+{
+public:
+ /// Defines all attributes that we keep track of for a bridged device
+ struct BridgedAttributes
+ {
+ std::string uniqueId;
+ std::string vendorName;
+ uint16_t vendorId = 0;
+ std::string productName;
+ uint16_t productId = 0;
+ std::string nodeLabel;
+ uint16_t hardwareVersion = 0;
+ std::string hardwareVersionString;
+ uint32_t softwareVersion = 0;
+ std::string softwareVersionString;
+ };
+
+ struct AdminCommissioningAttributes
+ {
+ chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum commissioningWindowStatus =
+ chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum::kWindowNotOpen;
+ std::optional<chip::FabricIndex> openerFabricIndex = std::nullopt;
+ std::optional<chip::VendorId> openerVendorId = std::nullopt;
+ };
+
+ BridgedDevice(chip::ScopedNodeId scopedNodeId);
+ virtual ~BridgedDevice() = default;
+
+ [[nodiscard]] bool IsReachable() const { return mReachable; }
+ void SetReachable(bool reachable);
+ // Reachability attribute changed and requires marking attribute as dirty and sending
+ // event.
+ void ReachableChanged(bool reachable);
+
+ void LogActiveChangeEvent(uint32_t promisedActiveDurationMs);
+
+ [[nodiscard]] bool IsIcd() const { return mIsIcd; }
+ void SetIcd(bool icd) { mIsIcd = icd; }
+
+ inline void SetEndpointId(chip::EndpointId id) { mEndpointId = id; };
+ inline chip::EndpointId GetEndpointId() { return mEndpointId; };
+ inline chip::ScopedNodeId GetScopedNodeId() { return mScopedNodeId; };
+ inline void SetParentEndpointId(chip::EndpointId id) { mParentEndpointId = id; };
+ inline chip::EndpointId GetParentEndpointId() { return mParentEndpointId; };
+
+ [[nodiscard]] const BridgedAttributes & GetBridgedAttributes() const { return mAttributes; }
+ void SetBridgedAttributes(const BridgedAttributes & value) { mAttributes = value; }
+
+ void SetAdminCommissioningAttributes(const AdminCommissioningAttributes & aAdminCommissioningAttributes);
+ const AdminCommissioningAttributes & GetAdminCommissioningAttributes() const { return mAdminCommissioningAttributes; }
+
+ /// Convenience method to set just the unique id of a bridged device as it
+ /// is one of the few attributes that is not always bulk-set
+ void SetUniqueId(const std::string & value) { mAttributes.uniqueId = value; }
+
+protected:
+ bool mReachable = false;
+ bool mIsIcd = false;
+
+ chip::ScopedNodeId mScopedNodeId;
+ chip::EndpointId mEndpointId = 0;
+ chip::EndpointId mParentEndpointId = 0;
+
+ BridgedAttributes mAttributes;
+ AdminCommissioningAttributes mAdminCommissioningAttributes;
+};
diff --git a/examples/fabric-sync/bridge/include/BridgedDeviceBasicInformationImpl.h b/examples/fabric-sync/bridge/include/BridgedDeviceBasicInformationImpl.h
new file mode 100644
index 0000000..2340343
--- /dev/null
+++ b/examples/fabric-sync/bridge/include/BridgedDeviceBasicInformationImpl.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/AttributeAccessInterface.h>
+
+class BridgedDeviceBasicInformationImpl : public chip::app::AttributeAccessInterface
+{
+public:
+ BridgedDeviceBasicInformationImpl() :
+ chip::app::AttributeAccessInterface(chip::NullOptional /* endpointId */,
+ chip::app::Clusters::BridgedDeviceBasicInformation::Id)
+ {}
+
+ // AttributeAccessInterface implementation
+ CHIP_ERROR Read(const chip::app::ConcreteReadAttributePath & path, chip::app::AttributeValueEncoder & encoder) override;
+ CHIP_ERROR Write(const chip::app::ConcreteDataAttributePath & path, chip::app::AttributeValueDecoder & decoder) override;
+};
diff --git a/examples/fabric-sync/bridge/include/BridgedDeviceManager.h b/examples/fabric-sync/bridge/include/BridgedDeviceManager.h
new file mode 100644
index 0000000..127898f
--- /dev/null
+++ b/examples/fabric-sync/bridge/include/BridgedDeviceManager.h
@@ -0,0 +1,136 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <platform/CHIPDeviceLayer.h>
+
+#include "BridgedDevice.h"
+
+#include <memory>
+
+class BridgedDeviceManager
+{
+public:
+ BridgedDeviceManager() = default;
+
+ /**
+ * @brief Initializes the BridgedDeviceManager.
+ *
+ * This function sets up the initial state of the BridgedDeviceManager, clearing
+ * any existing devices and setting the starting dynamic endpoint ID.
+ */
+ void Init();
+
+ /**
+ * @brief Adds a device to a dynamic endpoint.
+ *
+ * This function attempts to add a device to a dynamic endpoint. It tries to find an available
+ * endpoint slot and retries the addition process up to a specified maximum number of times if
+ * the endpoint already exists. If the addition is successful, it returns the index of the
+ * dynamic endpoint;
+ *
+ * Ensures that the device has a unique id:
+ * - device MUST set its unique id if any BEFORE calling this method
+ * - if no unique id (i.e. empty string), a new unique id will be generated
+ * - Add will fail if the unique id is not unique
+ *
+ * @param dev A pointer to the device to be added.
+ * @param parentEndpointId The parent endpoint ID. Defaults to an invalid endpoint ID.
+ * @return int The index of the dynamic endpoint if successful, nullopt otherwise
+ */
+ std::optional<unsigned> AddDeviceEndpoint(std::unique_ptr<BridgedDevice> dev,
+ chip::EndpointId parentEndpointId = chip::kInvalidEndpointId);
+
+ /**
+ * @brief Removes a device from a dynamic endpoint.
+ *
+ * This function attempts to remove a device from a dynamic endpoint by iterating through the
+ * available endpoints and checking if the device matches. If the device is found, it clears the
+ * dynamic endpoint, logs the removal, and returns the index of the removed endpoint.
+ * If the device is not found, it returns -1.
+ *
+ * @param dev A pointer to the device to be removed.
+ * @return int The index of the removed dynamic endpoint if successful, -1 otherwise.
+ */
+ int RemoveDeviceEndpoint(BridgedDevice * dev);
+
+ /**
+ * @brief Gets a device from its endpoint ID.
+ *
+ * This function iterates through the available devices and returns the device that matches the
+ * specified endpoint ID. If no device matches the endpoint ID, it returns nullptr.
+ *
+ * @param endpointId The endpoint ID of the device to be retrieved.
+ * @return BridgedDevice* A pointer to the device if found, nullptr otherwise.
+ */
+ BridgedDevice * GetDevice(chip::EndpointId endpointId) const;
+
+ /**
+ * @brief Gets a device from its ScopedNodeId.
+ *
+ * This function iterates through the available devices and returns the device that matches the
+ * specified ScopedNodeId. If no device matches the ScopedNodeId, it returns nullptr.
+ *
+ * @param scopedNodeId The ScopedNodeId of the device to be retrieved.
+ * @return BridgedDevice* A pointer to the device if found, nullptr otherwise.
+ */
+ BridgedDevice * GetDeviceByScopedNodeId(chip::ScopedNodeId scopedNodeId) const;
+
+ /**
+ * @brief Removes a device from a dynamic endpoint by its ScopedNodeId.
+ *
+ * This function attempts to remove a device and the associated dynamic endpoint by iterating through
+ * the available device and checking if the device matches the specified ScopedNodeId. If the device is
+ * found, it removes the dynamic endpoint.
+ *
+ * @param scopedNodeId The ScopedNodeId of the device to be removed.
+ * @return unsigned of the index of the removed dynamic endpoint if successful, nullopt otherwise.
+ */
+ std::optional<unsigned> RemoveDeviceByScopedNodeId(chip::ScopedNodeId scopedNodeId);
+
+ /**
+ * Finds the device with the given unique id (if any)
+ */
+ BridgedDevice * GetDeviceByUniqueId(const std::string & id);
+
+private:
+ friend BridgedDeviceManager & BridgeDeviceMgr();
+
+ /**
+ * Creates a new unique ID that is not used by any other mDevice
+ */
+ std::string GenerateUniqueId();
+
+ static BridgedDeviceManager sInstance;
+
+ chip::EndpointId mCurrentEndpointId;
+ chip::EndpointId mFirstDynamicEndpointId;
+ std::unique_ptr<BridgedDevice> mDevices[CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT + 1];
+};
+
+/**
+ * Returns the public interface of the BridgedDeviceManager singleton object.
+ *
+ * Applications should use this to access features of the BridgedDeviceManager
+ * object.
+ */
+inline BridgedDeviceManager & BridgeDeviceMgr()
+{
+ return BridgedDeviceManager::sInstance;
+}
diff --git a/examples/fabric-sync/bridge/src/BridgedAdministratorCommissioning.cpp b/examples/fabric-sync/bridge/src/BridgedAdministratorCommissioning.cpp
new file mode 100644
index 0000000..a0d87cb
--- /dev/null
+++ b/examples/fabric-sync/bridge/src/BridgedAdministratorCommissioning.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BridgedAdministratorCommissioning.h"
+
+#include "BridgedDevice.h"
+#include "BridgedDeviceManager.h"
+#include <app/AttributeAccessInterfaceRegistry.h>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::AdministratorCommissioning;
+
+CHIP_ERROR BridgedAdministratorCommissioning::Init()
+{
+ // We expect initialization after emberAfInit(). This allows us to unregister the existing
+ // AccessAttributeInterface for AdministratorCommissioning and register ourselves, ensuring we
+ // get the callback for reading attribute. If the read is not intended for a bridged device we will
+ // forward it to the original attribute interface that we are unregistering.
+ mOriginalAttributeInterface = AttributeAccessInterfaceRegistry::Instance().Get(kRootEndpointId, AdministratorCommissioning::Id);
+ VerifyOrReturnError(mOriginalAttributeInterface, CHIP_ERROR_INTERNAL);
+ AttributeAccessInterfaceRegistry::Instance().Unregister(mOriginalAttributeInterface);
+ VerifyOrDie(AttributeAccessInterfaceRegistry::Instance().Register(this));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR BridgedAdministratorCommissioning::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
+{
+ VerifyOrDie(aPath.mClusterId == Clusters::AdministratorCommissioning::Id);
+ EndpointId endpointId = aPath.mEndpointId;
+ BridgedDevice * device = BridgeDeviceMgr().GetDevice(endpointId);
+
+ if (!device)
+ {
+ VerifyOrDie(mOriginalAttributeInterface);
+ return mOriginalAttributeInterface->Read(aPath, aEncoder);
+ }
+ auto attr = device->GetAdminCommissioningAttributes();
+
+ switch (aPath.mAttributeId)
+ {
+ case Attributes::WindowStatus::Id: {
+ return aEncoder.Encode(attr.commissioningWindowStatus);
+ }
+ case Attributes::AdminFabricIndex::Id: {
+ DataModel::Nullable<FabricIndex> encodeableFabricIndex = DataModel::NullNullable;
+ if (attr.openerFabricIndex.has_value())
+ {
+ encodeableFabricIndex.SetNonNull(attr.openerFabricIndex.value());
+ }
+ return aEncoder.Encode(encodeableFabricIndex);
+ }
+ case Attributes::AdminVendorId::Id: {
+ DataModel::Nullable<VendorId> encodeableVendorId = DataModel::NullNullable;
+ if (attr.openerVendorId.has_value())
+ {
+ encodeableVendorId.SetNonNull(attr.openerVendorId.value());
+ }
+ return aEncoder.Encode(encodeableVendorId);
+ }
+ default:
+ break;
+ }
+
+ return CHIP_NO_ERROR;
+}
diff --git a/examples/fabric-sync/bridge/src/BridgedDevice.cpp b/examples/fabric-sync/bridge/src/BridgedDevice.cpp
new file mode 100644
index 0000000..f462d1c
--- /dev/null
+++ b/examples/fabric-sync/bridge/src/BridgedDevice.cpp
@@ -0,0 +1,118 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BridgedDevice.h"
+
+#include <cstdio>
+
+#include <app/EventLogging.h>
+#include <app/reporting/reporting.h>
+#include <platform/CHIPDeviceLayer.h>
+
+using namespace chip;
+using namespace chip::app::Clusters::Actions;
+
+BridgedDevice::BridgedDevice(ScopedNodeId scopedNodeId)
+{
+ mReachable = false;
+ mScopedNodeId = scopedNodeId;
+ mEndpointId = kInvalidEndpointId;
+}
+
+void BridgedDevice::LogActiveChangeEvent(uint32_t promisedActiveDurationMs)
+{
+ EndpointId endpointId = mEndpointId;
+
+ DeviceLayer::SystemLayer().ScheduleLambda([endpointId, promisedActiveDurationMs]() {
+ app::Clusters::BridgedDeviceBasicInformation::Events::ActiveChanged::Type event{};
+ event.promisedActiveDuration = promisedActiveDurationMs;
+ EventNumber eventNumber = 0;
+
+ CHIP_ERROR err = app::LogEvent(event, endpointId, eventNumber);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogProgress(NotSpecified, "LogEvent for ActiveChanged failed %s", err.AsString());
+ }
+ });
+}
+
+void BridgedDevice::SetReachable(bool reachable)
+{
+ mReachable = reachable;
+
+ if (reachable)
+ {
+ ChipLogProgress(NotSpecified, "BridgedDevice[%s]: ONLINE", mAttributes.uniqueId.c_str());
+ }
+ else
+ {
+ ChipLogProgress(NotSpecified, "BridgedDevice[%s]: OFFLINE", mAttributes.uniqueId.c_str());
+ }
+}
+
+void BridgedDevice::ReachableChanged(bool reachable)
+{
+ EndpointId endpointId = mEndpointId;
+ bool reachableChanged = (mReachable != reachable);
+ if (reachableChanged)
+ {
+ SetReachable(reachable);
+ DeviceLayer::SystemLayer().ScheduleLambda([endpointId]() {
+ MatterReportingAttributeChangeCallback(endpointId, app::Clusters::BridgedDeviceBasicInformation::Id,
+ app::Clusters::BridgedDeviceBasicInformation::Attributes::Reachable::Id);
+
+ app::Clusters::BridgedDeviceBasicInformation::Events::ReachableChanged::Type event{};
+ EventNumber eventNumber = 0;
+
+ CHIP_ERROR err = app::LogEvent(event, endpointId, eventNumber);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogProgress(NotSpecified, "LogEvent for ActiveChanged failed %s", err.AsString());
+ }
+ });
+ }
+}
+
+void BridgedDevice::SetAdminCommissioningAttributes(const AdminCommissioningAttributes & aAdminCommissioningAttributes)
+{
+ EndpointId endpointId = mEndpointId;
+ bool windowChanged =
+ (aAdminCommissioningAttributes.commissioningWindowStatus != mAdminCommissioningAttributes.commissioningWindowStatus);
+ bool fabricIndexChanged = (aAdminCommissioningAttributes.openerFabricIndex != mAdminCommissioningAttributes.openerFabricIndex);
+ bool vendorChanged = (aAdminCommissioningAttributes.openerVendorId != mAdminCommissioningAttributes.openerVendorId);
+
+ mAdminCommissioningAttributes = aAdminCommissioningAttributes;
+
+ DeviceLayer::SystemLayer().ScheduleLambda([endpointId, windowChanged, fabricIndexChanged, vendorChanged]() {
+ if (windowChanged)
+ {
+ MatterReportingAttributeChangeCallback(endpointId, app::Clusters::AdministratorCommissioning::Id,
+ app::Clusters::AdministratorCommissioning::Attributes::WindowStatus::Id);
+ }
+ if (fabricIndexChanged)
+ {
+ MatterReportingAttributeChangeCallback(endpointId, app::Clusters::AdministratorCommissioning::Id,
+ app::Clusters::AdministratorCommissioning::Attributes::AdminFabricIndex::Id);
+ }
+ if (vendorChanged)
+ {
+ MatterReportingAttributeChangeCallback(endpointId, app::Clusters::AdministratorCommissioning::Id,
+ app::Clusters::AdministratorCommissioning::Attributes::AdminVendorId::Id);
+ }
+ });
+}
diff --git a/examples/fabric-sync/bridge/src/BridgedDeviceBasicInformationImpl.cpp b/examples/fabric-sync/bridge/src/BridgedDeviceBasicInformationImpl.cpp
new file mode 100644
index 0000000..7fa48a4
--- /dev/null
+++ b/examples/fabric-sync/bridge/src/BridgedDeviceBasicInformationImpl.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2024 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "BridgedDeviceBasicInformationImpl.h"
+
+#include "BridgedDeviceManager.h"
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+
+#include <app/AttributeAccessInterfaceRegistry.h>
+
+static constexpr unsigned kBridgedDeviceBasicInformationClusterRevision = 4;
+
+using namespace ::chip;
+using namespace ::chip::app;
+using namespace ::chip::app::Clusters;
+
+CHIP_ERROR BridgedDeviceBasicInformationImpl::Read(const ConcreteReadAttributePath & path, AttributeValueEncoder & encoder)
+{
+ // Registration is done for the bridged device basic information only
+ VerifyOrDie(path.mClusterId == app::Clusters::BridgedDeviceBasicInformation::Id);
+
+ BridgedDevice * dev = BridgeDeviceMgr().GetDevice(path.mEndpointId);
+ VerifyOrReturnError(dev != nullptr, CHIP_ERROR_NOT_FOUND);
+
+ switch (path.mAttributeId)
+ {
+ case BasicInformation::Attributes::Reachable::Id:
+ encoder.Encode(dev->IsReachable());
+ break;
+ case BasicInformation::Attributes::NodeLabel::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().nodeLabel.c_str()));
+ break;
+ case BasicInformation::Attributes::ClusterRevision::Id:
+ encoder.Encode(kBridgedDeviceBasicInformationClusterRevision);
+ break;
+ case BasicInformation::Attributes::FeatureMap::Id: {
+ BitMask<Clusters::BridgedDeviceBasicInformation::Feature> features;
+ features.Set(Clusters::BridgedDeviceBasicInformation::Feature::kBridgedICDSupport, dev->IsIcd());
+ encoder.Encode(features);
+ }
+ break;
+ case BasicInformation::Attributes::UniqueID::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().uniqueId.c_str()));
+ break;
+ case BasicInformation::Attributes::VendorName::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().vendorName.c_str()));
+ break;
+ case BasicInformation::Attributes::VendorID::Id:
+ encoder.Encode(dev->GetBridgedAttributes().vendorId);
+ break;
+ case BasicInformation::Attributes::ProductName::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().productName.c_str()));
+ break;
+ case BasicInformation::Attributes::ProductID::Id:
+ encoder.Encode(dev->GetBridgedAttributes().productId);
+ break;
+ case BasicInformation::Attributes::HardwareVersion::Id:
+ encoder.Encode(dev->GetBridgedAttributes().hardwareVersion);
+ break;
+ case BasicInformation::Attributes::HardwareVersionString::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().hardwareVersionString.c_str()));
+ break;
+ case BasicInformation::Attributes::SoftwareVersion::Id:
+ encoder.Encode(dev->GetBridgedAttributes().softwareVersion);
+ break;
+ case BasicInformation::Attributes::SoftwareVersionString::Id:
+ encoder.Encode(CharSpan::fromCharString(dev->GetBridgedAttributes().softwareVersionString.c_str()));
+ break;
+ default:
+ return CHIP_ERROR_INVALID_ARGUMENT;
+ }
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR BridgedDeviceBasicInformationImpl::Write(const ConcreteDataAttributePath & path, AttributeValueDecoder & decoder)
+{
+ VerifyOrDie(path.mClusterId == app::Clusters::BridgedDeviceBasicInformation::Id);
+
+ BridgedDevice * dev = BridgeDeviceMgr().GetDevice(path.mEndpointId);
+ VerifyOrReturnError(dev != nullptr, CHIP_ERROR_NOT_FOUND);
+
+ if (!dev->IsReachable())
+ {
+ return CHIP_ERROR_NOT_CONNECTED;
+ }
+
+ ChipLogProgress(NotSpecified, "Bridged device basic information attempt to write attribute: ep=%d", path.mAttributeId);
+
+ // nothing writable right now ...
+
+ return CHIP_ERROR_INVALID_ARGUMENT;
+}
diff --git a/examples/fabric-sync/bridge/src/BridgedDeviceManager.cpp b/examples/fabric-sync/bridge/src/BridgedDeviceManager.cpp
new file mode 100644
index 0000000..0265f91
--- /dev/null
+++ b/examples/fabric-sync/bridge/src/BridgedDeviceManager.cpp
@@ -0,0 +1,345 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BridgedDeviceManager.h"
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/AttributeAccessInterfaceRegistry.h>
+#include <app/ConcreteAttributePath.h>
+#include <app/EventLogging.h>
+#include <app/reporting/reporting.h>
+#include <app/server/Server.h>
+#include <app/util/af-types.h>
+#include <app/util/attribute-storage.h>
+#include <app/util/endpoint-config-api.h>
+#include <app/util/util.h>
+#include <crypto/RandUtils.h>
+#include <lib/support/CHIPMem.h>
+#include <lib/support/ZclString.h>
+
+#include <cstdio>
+#include <optional>
+#include <string>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::Credentials;
+using namespace chip::Inet;
+using namespace chip::Transport;
+using namespace chip::DeviceLayer;
+using namespace chip::app::Clusters;
+
+namespace {
+
+constexpr uint8_t kMaxRetries = 10;
+constexpr int kNodeLabelSize = 32;
+constexpr int kUniqueIdSize = 32;
+constexpr int kVendorNameSize = 32;
+constexpr int kProductNameSize = 32;
+constexpr int kHardwareVersionSize = 64;
+constexpr int kSoftwareVersionSize = 64;
+
+// Current ZCL implementation of Struct uses a max-size array of 254 bytes
+constexpr int kDescriptorAttributeArraySize = 254;
+
+#define ZCL_ADMINISTRATOR_COMMISSIONING_CLUSTER_REVISION (1u)
+
+// ENDPOINT DEFINITIONS:
+// =================================================================================
+//
+// Endpoint definitions will be reused across multiple endpoints for every instance of the
+// endpoint type.
+// There will be no intrinsic storage for the endpoint attributes declared here.
+// Instead, all attributes will be treated as EXTERNAL, and therefore all reads
+// or writes to the attributes must be handled within the emberAfExternalAttributeWriteCallback
+// and emberAfExternalAttributeReadCallback functions declared herein. This fits
+// the typical model of a bridge, since a bridge typically maintains its own
+// state database representing the devices connected to it.
+
+// (taken from matter-devices.xml)
+#define DEVICE_TYPE_BRIDGED_NODE 0x0013
+
+// Device Version for dynamic endpoints:
+#define DEVICE_VERSION_DEFAULT 1
+
+// ---------------------------------------------------------------------------
+//
+// SYNCED DEVICE ENDPOINT: contains the following clusters:
+// - Descriptor
+// - Bridged Device Basic Information
+// - Administrator Commissioning
+
+// clang-format off
+// Declare Descriptor cluster attributes
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(descriptorAttrs)
+ DECLARE_DYNAMIC_ATTRIBUTE(Descriptor::Attributes::DeviceTypeList::Id, ARRAY, kDescriptorAttributeArraySize, 0), /* device list */
+ DECLARE_DYNAMIC_ATTRIBUTE(Descriptor::Attributes::ServerList::Id, ARRAY, kDescriptorAttributeArraySize, 0), /* server list */
+ DECLARE_DYNAMIC_ATTRIBUTE(Descriptor::Attributes::ClientList::Id, ARRAY, kDescriptorAttributeArraySize, 0), /* client list */
+ DECLARE_DYNAMIC_ATTRIBUTE(Descriptor::Attributes::PartsList::Id, ARRAY, kDescriptorAttributeArraySize, 0), /* parts list */
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();
+
+// Declare Bridged Device Basic Information cluster attributes
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(bridgedDeviceBasicAttrs)
+ // The attributes below are MANDATORY in the Bridged Device Information Cluster
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::Reachable::Id, BOOLEAN, 1, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::UniqueID::Id, CHAR_STRING, kUniqueIdSize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::FeatureMap::Id, BITMAP32, 4, 0),
+
+ // The attributes below are OPTIONAL in the bridged device, however they are MANDATORY in the BasicInformation cluster
+ // so they can always be provided if desired
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::VendorName::Id, CHAR_STRING, kVendorNameSize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::VendorID::Id, INT16U, 2, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::ProductName::Id, CHAR_STRING, kProductNameSize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::ProductID::Id, INT16U, 2, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::NodeLabel::Id, CHAR_STRING, kNodeLabelSize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::HardwareVersion::Id, INT16U, 2, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::HardwareVersionString::Id, CHAR_STRING,
+ kHardwareVersionSize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::SoftwareVersion::Id, INT32U, 4, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::SoftwareVersionString::Id, CHAR_STRING,
+ kSoftwareVersionSize, 0),
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();
+
+// Declare Ecosystem Information cluster attributes
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(ecosystemInformationBasicAttrs)
+ DECLARE_DYNAMIC_ATTRIBUTE(EcosystemInformation::Attributes::DeviceDirectory::Id, ARRAY, kDescriptorAttributeArraySize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(EcosystemInformation::Attributes::LocationDirectory::Id, ARRAY, kDescriptorAttributeArraySize, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();
+
+// Declare Administrator Commissioning cluster attributes
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(AdministratorCommissioningAttrs)
+ DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::WindowStatus::Id, ENUM8, 1, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::AdminFabricIndex::Id, FABRIC_IDX, 1, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::AdminVendorId::Id, VENDOR_ID, 2, 0),
+ DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::ClusterRevision::Id, INT16U, ZCL_ADMINISTRATOR_COMMISSIONING_CLUSTER_REVISION, 0),
+DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();
+// clang-format on
+
+constexpr CommandId bridgedDeviceBasicInformationCommands[] = {
+ app::Clusters::BridgedDeviceBasicInformation::Commands::KeepActive::Id,
+ kInvalidCommandId,
+};
+
+constexpr CommandId administratorCommissioningCommands[] = {
+ app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id,
+ app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id,
+ app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id,
+ kInvalidCommandId,
+};
+
+// clang-format off
+// Declare Cluster List for Bridged Node endpoint
+DECLARE_DYNAMIC_CLUSTER_LIST_BEGIN(bridgedNodeClusters)
+ DECLARE_DYNAMIC_CLUSTER(Descriptor::Id, descriptorAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
+ DECLARE_DYNAMIC_CLUSTER(BridgedDeviceBasicInformation::Id, bridgedDeviceBasicAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
+ DECLARE_DYNAMIC_CLUSTER(EcosystemInformation::Id, ecosystemInformationBasicAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
+ DECLARE_DYNAMIC_CLUSTER(AdministratorCommissioning::Id, AdministratorCommissioningAttrs, ZAP_CLUSTER_MASK(SERVER),
+ administratorCommissioningCommands, nullptr)
+DECLARE_DYNAMIC_CLUSTER_LIST_END;
+
+DECLARE_DYNAMIC_CLUSTER_LIST_BEGIN(icdBridgedNodeClusters)
+ DECLARE_DYNAMIC_CLUSTER(Descriptor::Id, descriptorAttrs, ZAP_CLUSTER_MASK(SERVER), nullptr, nullptr),
+ DECLARE_DYNAMIC_CLUSTER(BridgedDeviceBasicInformation::Id, bridgedDeviceBasicAttrs, ZAP_CLUSTER_MASK(SERVER),
+ bridgedDeviceBasicInformationCommands, nullptr),
+ DECLARE_DYNAMIC_CLUSTER(AdministratorCommissioning::Id, AdministratorCommissioningAttrs, ZAP_CLUSTER_MASK(SERVER),
+ administratorCommissioningCommands, nullptr)
+DECLARE_DYNAMIC_CLUSTER_LIST_END;
+// clang-format on
+
+// Declare Bridged Node endpoint
+DECLARE_DYNAMIC_ENDPOINT(sBridgedNodeEndpoint, bridgedNodeClusters);
+DECLARE_DYNAMIC_ENDPOINT(sIcdBridgedNodeEndpoint, icdBridgedNodeClusters);
+
+// TODO: this is a single version array, however we may have many
+// different clusters that are independent.
+DataVersion sBridgedNodeDataVersions[ArraySize(bridgedNodeClusters)];
+
+const EmberAfDeviceType sBridgedDeviceTypes[] = { { DEVICE_TYPE_BRIDGED_NODE, DEVICE_VERSION_DEFAULT } };
+
+} // namespace
+
+// Define the static member
+BridgedDeviceManager BridgedDeviceManager::sInstance;
+
+void BridgedDeviceManager::Init()
+{
+ mFirstDynamicEndpointId = static_cast<chip::EndpointId>(
+ static_cast<int>(emberAfEndpointFromIndex(static_cast<uint16_t>(emberAfFixedEndpointCount() - 1))) + 1);
+ mCurrentEndpointId = mFirstDynamicEndpointId;
+}
+
+std::optional<unsigned> BridgedDeviceManager::AddDeviceEndpoint(std::unique_ptr<BridgedDevice> dev,
+ chip::EndpointId parentEndpointId)
+{
+ EmberAfEndpointType * ep = dev->IsIcd() ? &sIcdBridgedNodeEndpoint : &sBridgedNodeEndpoint;
+
+ const chip::Span<const EmberAfDeviceType> & deviceTypeList = Span<const EmberAfDeviceType>(sBridgedDeviceTypes);
+
+ // TODO: this shares data version among different clusters, which seems incorrect
+ const chip::Span<chip::DataVersion> & dataVersionStorage = Span<DataVersion>(sBridgedNodeDataVersions);
+
+ if (dev->GetBridgedAttributes().uniqueId.empty())
+ {
+ dev->SetUniqueId(GenerateUniqueId());
+ }
+ else if (GetDeviceByUniqueId(dev->GetBridgedAttributes().uniqueId) != nullptr)
+ {
+ ChipLogProgress(NotSpecified, "A device with unique id '%s' already exists", dev->GetBridgedAttributes().uniqueId.c_str());
+ return std::nullopt;
+ }
+
+ for (unsigned index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; index++)
+ {
+ if (mDevices[index])
+ {
+ continue;
+ }
+
+ for (int retryCount = 0; retryCount < kMaxRetries; retryCount++)
+ {
+ DeviceLayer::StackLock lock;
+ dev->SetEndpointId(mCurrentEndpointId);
+ dev->SetParentEndpointId(parentEndpointId);
+ CHIP_ERROR err =
+ emberAfSetDynamicEndpoint(index, mCurrentEndpointId, ep, dataVersionStorage, deviceTypeList, parentEndpointId);
+ if (err == CHIP_NO_ERROR)
+ {
+ ChipLogProgress(NotSpecified, "Added device with Id=[%d:0x" ChipLogFormatX64 "] to dynamic endpoint %d (index=%d)",
+ dev->GetScopedNodeId().GetFabricIndex(), ChipLogValueX64(dev->GetScopedNodeId().GetNodeId()),
+ mCurrentEndpointId, index);
+ mDevices[index] = std::move(dev);
+ return index;
+ }
+ if (err != CHIP_ERROR_ENDPOINT_EXISTS)
+ {
+ return std::nullopt; // Return error as endpoint addition failed due to an error other than endpoint already exists
+ }
+ // Increment the endpoint ID and handle wrap condition
+ if (++mCurrentEndpointId < mFirstDynamicEndpointId)
+ {
+ mCurrentEndpointId = mFirstDynamicEndpointId;
+ }
+ }
+ ChipLogError(NotSpecified, "Failed to add dynamic endpoint after %d retries", kMaxRetries);
+ return std::nullopt; // Return error as all retries are exhausted
+ }
+
+ ChipLogProgress(NotSpecified, "Failed to add dynamic endpoint: No endpoints available!");
+ return std::nullopt;
+}
+
+int BridgedDeviceManager::RemoveDeviceEndpoint(BridgedDevice * dev)
+{
+ uint8_t index = 0;
+ while (index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
+ {
+ if (mDevices[index].get() == dev)
+ {
+ DeviceLayer::StackLock lock;
+ // Silence complaints about unused ep when progress logging
+ // disabled.
+ [[maybe_unused]] EndpointId ep = emberAfClearDynamicEndpoint(index);
+ mDevices[index] = nullptr;
+ ChipLogProgress(NotSpecified, "Removed device %s from dynamic endpoint %d (index=%d)",
+ dev->GetBridgedAttributes().uniqueId.c_str(), ep, index);
+ return index;
+ }
+ index++;
+ }
+ return -1;
+}
+
+BridgedDevice * BridgedDeviceManager::GetDevice(chip::EndpointId endpointId) const
+{
+ for (uint8_t index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
+ {
+ if (mDevices[index] && mDevices[index]->GetEndpointId() == endpointId)
+ {
+ return mDevices[index].get();
+ }
+ }
+ return nullptr;
+}
+
+std::string BridgedDeviceManager::GenerateUniqueId()
+{
+ char rand_buffer[kUniqueIdSize + 1];
+ memset(rand_buffer, 0, sizeof(rand_buffer));
+
+ static const char kRandCharChoices[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ while (true)
+ {
+ /// for nice viewing, prefix the generated value
+ memcpy(rand_buffer, "GEN-", 4);
+ for (unsigned idx = 4; idx < kUniqueIdSize; idx++)
+ {
+ rand_buffer[idx] = kRandCharChoices[Crypto::GetRandU8() % (sizeof(kRandCharChoices) - 1)];
+ }
+
+ // we know zero-terminated due to the memset
+ std::string uniqueIdChoice = rand_buffer;
+
+ if (!GetDeviceByUniqueId(uniqueIdChoice))
+ {
+ return uniqueIdChoice;
+ }
+ }
+}
+
+BridgedDevice * BridgedDeviceManager::GetDeviceByUniqueId(const std::string & id)
+{
+ for (uint8_t index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
+ {
+ if (mDevices[index] && mDevices[index]->GetBridgedAttributes().uniqueId == id)
+ {
+ return mDevices[index].get();
+ }
+ }
+ return nullptr;
+}
+
+BridgedDevice * BridgedDeviceManager::GetDeviceByScopedNodeId(chip::ScopedNodeId scopedNodeId) const
+{
+ for (uint8_t index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
+ {
+ if (mDevices[index] && mDevices[index]->GetScopedNodeId() == scopedNodeId)
+ {
+ return mDevices[index].get();
+ }
+ }
+ return nullptr;
+}
+
+std::optional<unsigned> BridgedDeviceManager::RemoveDeviceByScopedNodeId(chip::ScopedNodeId scopedNodeId)
+{
+ for (unsigned index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
+ {
+ if (mDevices[index] && mDevices[index]->GetScopedNodeId() == scopedNodeId)
+ {
+ DeviceLayer::StackLock lock;
+ EndpointId ep = emberAfClearDynamicEndpoint(index);
+ mDevices[index] = nullptr;
+ ChipLogProgress(NotSpecified, "Removed device with Id=[%d:0x" ChipLogFormatX64 "] from dynamic endpoint %d (index=%d)",
+ scopedNodeId.GetFabricIndex(), ChipLogValueX64(scopedNodeId.GetNodeId()), ep, index);
+ return index;
+ }
+ }
+ return std::nullopt;
+}
