Merge branch 'project-chip:master' into remove_PICS_from_timesync_tests

docs/guides/simulated_device_linux.md

@@ -61,7 +61,7 @@ Now that the building is completed there is a `chip-app1` binary created. This
 binary can be executed on a linux os with test commands.
 
 ```
-./scripts/tests/yaml/runner.py [TEST NAME] app1
+./scripts/tests/chipyaml/runner.py [TEST NAME] app1
 ```
 
 ## Interacting with the simulated app

docs/testing/yaml.md

@@ -347,12 +347,12 @@ Compile chip-tool:
 
 NOTE: use the target appropriate to your system
 
-[chiptool.py](https://github.com/project-chip/connectedhomeip/blob/master/scripts/tests/yaml/chiptool.py)
+[chiptool.py](https://github.com/project-chip/connectedhomeip/blob/master/scripts/tests/chipyaml/chiptool.py)
 can be used to run tests against a commissioned DUT (commissioned by chip-tool).
 This will start an interactive instance of chip-tool automatically.
 
 ```
-./scripts/tests/yaml/chiptool.py tests Test_TC_OO_2_1 --server_path ./out/linux-x64-chip-tool/chip-tool
+./scripts/tests/chipyaml/chiptool.py tests Test_TC_OO_2_1 --server_path ./out/linux-x64-chip-tool/chip-tool
 
 ```
 
@@ -361,14 +361,14 @@ NOTE: substitute the appropriate test name and chip-tool path as appropriate.
 A list of available tests can be generated using:
 
 ```
-./scripts/tests/yaml/chiptool.py list
+./scripts/tests/chipyaml/chiptool.py list
 ```
 
 Config variables can be passed to chiptool.py after the script by separating
 with --
 
 ```
-./scripts/tests/yaml/chiptool.py tests Test_TC_OO_2_1 --server_path ./out/linux-x64-chip-tool/chip-tool -- nodeId 0x12344321
+./scripts/tests/chipyaml/chiptool.py tests Test_TC_OO_2_1 --server_path ./out/linux-x64-chip-tool/chip-tool -- nodeId 0x12344321
 
 ```
 

examples/chip-tool/commands/clusters/ModelCommand.cpp

@@ -44,8 +44,11 @@ CHIP_ERROR ModelCommand::RunCommand()
         return SendCommand(commissioneeDeviceProxy, mEndPointId);
     }
 
+    // Check whether the session needs to allow large payload support.
+    TransportPayloadCapability transportPayloadCapability =
+        AllowLargePayload() ? TransportPayloadCapability::kLargePayload : TransportPayloadCapability::kMRPPayload;
     return CurrentCommissioner().GetConnectedDevice(mDestinationId, &mOnDeviceConnectedCallback,
-                                                    &mOnDeviceConnectionFailureCallback);
+                                                    &mOnDeviceConnectionFailureCallback, transportPayloadCapability);
 }
 
 void ModelCommand::OnDeviceConnectedFn(void * context, chip::Messaging::ExchangeManager & exchangeMgr,
@@ -134,3 +137,8 @@ bool ModelCommand::IsPeerLIT()
     CheckPeerICDType();
     return mIsPeerLIT.ValueOr(false);
 }
+
+bool ModelCommand::AllowLargePayload()
+{
+    return mAllowLargePayload.ValueOr(false);
+}

examples/chip-tool/commands/clusters/ModelCommand.h

@@ -57,6 +57,9 @@ class ModelCommand : public CHIPCommand
             "Whether to treat the peer as a LIT ICD. false: Always no, true: Always yes, (not set): Yes if the peer is registered "
             "to this controller.");
         AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
+        AddArgument("allow-large-payload", 0, 1, &mAllowLargePayload,
+                    "If true, indicates that the session should allow large application payloads (which requires a TCP connection)."
+                    "Defaults to false, which uses a UDP+MRP session.");
     }
 
     /////////// CHIPCommand Interface /////////
@@ -82,9 +85,12 @@ class ModelCommand : public CHIPCommand
     chip::NodeId mDestinationId;
     std::vector<chip::EndpointId> mEndPointId;
     chip::Optional<bool> mIsPeerLIT;
+    chip::Optional<bool> mAllowLargePayload;
 
     void CheckPeerICDType();
 
+    bool AllowLargePayload();
+
     static void OnDeviceConnectedFn(void * context, chip::Messaging::ExchangeManager & exchangeMgr,
                                     const chip::SessionHandle & sessionHandle);
     static void OnDeviceConnectionFailureFn(void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error);

examples/fabric-bridge-app/linux/Device.cpp

@@ -25,11 +25,11 @@
 
 using namespace chip::app::Clusters::Actions;
 
-Device::Device(chip::NodeId nodeId, const char * name)
+Device::Device(chip::NodeId nodeId)
 {
-    chip::Platform::CopyString(mName, name);
     mReachable  = false;
-    mEndpointId = 0;
+    mNodeId     = nodeId;
+    mEndpointId = chip::kInvalidEndpointId;
 }
 
 bool Device::IsReachable()

examples/fabric-bridge-app/linux/DeviceManager.cpp

@@ -46,6 +46,77 @@ using namespace chip::app::Clusters;
 namespace {
 
 constexpr uint8_t kMaxRetries = 10;
+constexpr int kNodeLabelSize  = 32;
+
+// Current ZCL implementation of Struct uses a max-size array of 254 bytes
+constexpr int kDescriptorAttributeArraySize = 254;
+
+// 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
+
+// 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)
+DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::NodeLabel::Id, CHAR_STRING, kNodeLabelSize, 0), /* NodeLabel */
+    DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::Reachable::Id, BOOLEAN, 1, 0),              /* Reachable */
+    DECLARE_DYNAMIC_ATTRIBUTE(BridgedDeviceBasicInformation::Attributes::FeatureMap::Id, BITMAP32, 4, 0), /* feature map */
+    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),              /* NodeLabel */
+    DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::AdminFabricIndex::Id, FABRIC_IDX, 1, 0), /* Reachable */
+    DECLARE_DYNAMIC_ATTRIBUTE(AdministratorCommissioning::Attributes::AdminVendorId::Id, VENDOR_ID, 2, 0),     /* Reachable */
+    DECLARE_DYNAMIC_ATTRIBUTE_LIST_END();
+
+constexpr CommandId administratorCommissioningCommands[] = {
+    app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id,
+    app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id,
+    app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id,
+    kInvalidCommandId,
+};
+
+// 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(AdministratorCommissioning::Id, AdministratorCommissioningAttrs, ZAP_CLUSTER_MASK(SERVER),
+                            administratorCommissioningCommands, nullptr) DECLARE_DYNAMIC_CLUSTER_LIST_END;
+
+// Declare Bridged Node endpoint
+DECLARE_DYNAMIC_ENDPOINT(sBridgedNodeEndpoint, bridgedNodeClusters);
+DataVersion sBridgedNodeDataVersions[ArraySize(bridgedNodeClusters)];
+
+const EmberAfDeviceType sBridgedDeviceTypes[] = { { DEVICE_TYPE_BRIDGED_NODE, DEVICE_VERSION_DEFAULT } };
 
 } // namespace
 
@@ -60,11 +131,13 @@ void DeviceManager::Init()
     mCurrentEndpointId = mFirstDynamicEndpointId;
 }
 
-int DeviceManager::AddDeviceEndpoint(Device * dev, EmberAfEndpointType * ep,
-                                     const chip::Span<const EmberAfDeviceType> & deviceTypeList,
-                                     const chip::Span<chip::DataVersion> & dataVersionStorage, chip::EndpointId parentEndpointId)
+int DeviceManager::AddDeviceEndpoint(Device * dev, chip::EndpointId parentEndpointId)
 {
-    uint8_t index = 0;
+    uint8_t index                                              = 0;
+    EmberAfEndpointType * ep                                   = &sBridgedNodeEndpoint;
+    const chip::Span<const EmberAfDeviceType> & deviceTypeList = Span<const EmberAfDeviceType>(sBridgedDeviceTypes);
+    const chip::Span<chip::DataVersion> & dataVersionStorage   = Span<DataVersion>(sBridgedNodeDataVersions);
+
     while (index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
     {
         if (nullptr == mDevices[index])
@@ -81,8 +154,9 @@ int DeviceManager::AddDeviceEndpoint(Device * dev, EmberAfEndpointType * ep,
                     emberAfSetDynamicEndpoint(index, mCurrentEndpointId, ep, dataVersionStorage, deviceTypeList, parentEndpointId);
                 if (err == CHIP_NO_ERROR)
                 {
-                    ChipLogProgress(NotSpecified, "Added device %s to dynamic endpoint %d (index=%d)", dev->GetName(),
-                                    mCurrentEndpointId, index);
+                    ChipLogProgress(NotSpecified,
+                                    "Added device with nodeId=0x" ChipLogFormatX64 " to dynamic endpoint %d (index=%d)",
+                                    ChipLogValueX64(dev->GetNodeId()), mCurrentEndpointId, index);
                     return index;
                 }
                 if (err != CHIP_ERROR_ENDPOINT_EXISTS)
@@ -125,11 +199,43 @@ int DeviceManager::RemoveDeviceEndpoint(Device * dev)
     return -1;
 }
 
-Device * DeviceManager::GetDevice(uint16_t index) const
+Device * DeviceManager::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];
+        }
+    }
+    return nullptr;
+}
+
+Device * DeviceManager::GetDeviceByNodeId(chip::NodeId nodeId) const
 {
-    if (index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT)
+    for (uint8_t index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
     {
-        return mDevices[index];
+        if (mDevices[index] && mDevices[index]->GetNodeId() == nodeId)
+        {
+            return mDevices[index];
+        }
     }
     return nullptr;
 }
+
+int DeviceManager::RemoveDeviceByNodeId(chip::NodeId nodeId)
+{
+    for (uint8_t index = 0; index < CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT; ++index)
+    {
+        if (mDevices[index] && mDevices[index]->GetNodeId() == nodeId)
+        {
+            DeviceLayer::StackLock lock;
+            EndpointId ep   = emberAfClearDynamicEndpoint(index);
+            mDevices[index] = nullptr;
+            ChipLogProgress(NotSpecified, "Removed device with NodeId=0x" ChipLogFormatX64 " from dynamic endpoint %d (index=%d)",
+                            ChipLogValueX64(nodeId), ep, index);
+            return index;
+        }
+    }
+    return -1;
+}

examples/fabric-bridge-app/linux/RpcClient.cpp

@@ -65,7 +65,7 @@ CHIP_ERROR InitRpcClient(uint16_t rpcServerPort)
 
 CHIP_ERROR OpenCommissioningWindow(NodeId nodeId)
 {
-    ChipLogProgress(NotSpecified, "OpenCommissioningWindow\n");
+    ChipLogProgress(NotSpecified, "OpenCommissioningWindow with Node Id 0x:" ChipLogFormatX64, ChipLogValueX64(nodeId));
 
     if (openCommissioningWindowCall.active())
     {

examples/fabric-bridge-app/linux/RpcServer.cpp

@@ -20,26 +20,49 @@
 #include "pw_rpc_system_server/rpc_server.h"
 #include "pw_rpc_system_server/socket.h"
 
-#include <system/SystemClock.h>
+#include <lib/core/CHIPError.h>
+
+#include <string>
 #include <thread>
 
 #if defined(PW_RPC_FABRIC_BRIDGE_SERVICE) && PW_RPC_FABRIC_BRIDGE_SERVICE
 #include "pigweed/rpc_services/FabricBridge.h"
 #endif
 
+#include "Device.h"
+#include "DeviceManager.h"
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+
 namespace {
 
 #if defined(PW_RPC_FABRIC_BRIDGE_SERVICE) && PW_RPC_FABRIC_BRIDGE_SERVICE
 class FabricBridge final : public chip::rpc::FabricBridge
 {
 public:
-    pw::Status AddSynchronizedDevice(const chip_rpc_SynchronizedDevice & request, pw_protobuf_Empty & response) override
+    pw::Status AddSynchronizedDevice(const chip_rpc_SynchronizedDevice & request, pw_protobuf_Empty & response) override;
+};
+
+pw::Status FabricBridge::AddSynchronizedDevice(const chip_rpc_SynchronizedDevice & request, pw_protobuf_Empty & response)
+{
+    NodeId nodeId = request.node_id;
+    ChipLogProgress(NotSpecified, "Received AddSynchronizedDevice: " ChipLogFormatX64, ChipLogValueX64(nodeId));
+
+    Device * device = new Device(nodeId);
+    device->SetReachable(true);
+
+    int result = DeviceMgr().AddDeviceEndpoint(device, 1);
+    if (result == -1)
     {
-        chip::NodeId nodeId = request.node_id;
-        ChipLogProgress(NotSpecified, "Received AddSynchronizedDevice: " ChipLogFormatX64, ChipLogValueX64(nodeId));
-        return pw::OkStatus();
+        delete device;
+        ChipLogError(NotSpecified, "Failed to add device with nodeId=0x" ChipLogFormatX64, ChipLogValueX64(nodeId));
+        return pw::Status::Unknown();
     }
-};
+
+    return pw::OkStatus();
+}
 
 FabricBridge fabric_bridge_service;
 #endif // defined(PW_RPC_FABRIC_BRIDGE_SERVICE) && PW_RPC_FABRIC_BRIDGE_SERVICE

examples/fabric-bridge-app/linux/include/Device.h

@@ -32,7 +32,7 @@ class Device
 public:
     static const int kDeviceNameSize = 32;
 
-    Device(chip::NodeId nodeId, const char * name);
+    Device(chip::NodeId nodeId);
     virtual ~Device() {}
 
     bool IsReachable();
@@ -41,6 +41,7 @@ class Device
     void SetLocation(std::string location) { mLocation = location; };
     inline void SetEndpointId(chip::EndpointId id) { mEndpointId = id; };
     inline chip::EndpointId GetEndpointId() { return mEndpointId; };
+    inline chip::NodeId GetNodeId() { return mNodeId; };
     inline void SetParentEndpointId(chip::EndpointId id) { mParentEndpointId = id; };
     inline chip::EndpointId GetParentEndpointId() { return mParentEndpointId; };
     inline char * GetName() { return mName; };