Update Push AV Cluster implementation (project-chip#40484)

sayondeep · web-flow · commit 85b889da0784 · 2025-09-02T15:52:28.000Z
* integrate push av with tls client

* set tls client mgmt delegate in push av

* Update push av unit tests for tls client mgmt integration

* push-av-stream: Add new fields for CMAFContainerOptionsStruct

* CI build fix

* Integrate tls clusters with camera app
diff --git a/examples/all-clusters-app/all-clusters-common/include/push-av-stream-transport-delegate-impl.h b/examples/all-clusters-app/all-clusters-common/include/push-av-stream-transport-delegate-impl.h
@@ -64,6 +64,10 @@ class PushAvStreamTransportManager : public PushAvStreamTransportDelegate
 
     Protocols::InteractionModel::Status SelectVideoStream(StreamUsageEnum streamUsage, uint16_t & videoStreamId) override;
 
+    bool ValidateStreamUsage(StreamUsageEnum streamUsage) override;
+
+    bool ValidateSegmentDuration(uint16_t segmentDuration) override;
+
     Protocols::InteractionModel::Status SelectAudioStream(StreamUsageEnum streamUsage, uint16_t & audioStreamId) override;
 
     Protocols::InteractionModel::Status ValidateVideoStream(uint16_t videoStreamId) override;
diff --git a/examples/all-clusters-app/all-clusters-common/src/push-av-stream-transport-delegate-impl.cpp b/examples/all-clusters-app/all-clusters-common/src/push-av-stream-transport-delegate-impl.cpp
@@ -100,6 +100,16 @@ Protocols::InteractionModel::Status PushAvStreamTransportManager::ManuallyTrigge
     return Status::Success;
 }
 
+bool PushAvStreamTransportManager::ValidateStreamUsage(StreamUsageEnum streamUsage)
+{
+    return true;
+}
+
+bool PushAvStreamTransportManager::ValidateSegmentDuration(uint16_t segmentDuration)
+{
+    return true;
+}
+
 Protocols::InteractionModel::Status
 PushAvStreamTransportManager::ValidateBandwidthLimit(StreamUsageEnum streamUsage,
                                                      const Optional<DataModel::Nullable<uint16_t>> & videoStreamId,
diff --git a/examples/all-clusters-app/linux/main-common.cpp b/examples/all-clusters-app/linux/main-common.cpp
@@ -39,6 +39,7 @@
 #include "rvc-operational-state-delegate-impl.h"
 #include "tcc-mode.h"
 #include "thermostat-delegate-impl.h"
+#include "tls-client-management-instance.h"
 
 #include <Options.h>
 #include <app-common/zap-generated/attributes/Accessors.h>
@@ -72,7 +73,6 @@ using namespace chip::app;
 using namespace chip::DeviceLayer;
 
 using chip::Protocols::InteractionModel::Status;
-
 namespace {
 
 LowPowerManager sLowPowerManager;
@@ -198,6 +198,8 @@ void ApplicationInit()
                     Clusters::UnitLocalization::TempUnitEnum::kFahrenheit) == CHIP_NO_ERROR);
 
     Clusters::PushAvStreamTransport::SetDelegate(chip::EndpointId(1), &gPushAvStreamTransportManager);
+    Clusters::PushAvStreamTransport::SetTLSClientManagementDelegate(chip::EndpointId(1),
+                                                                    &Clusters::TlsClientManagementCommandDelegate::GetInstance());
 
     SetTagList(/* endpoint= */ 0, Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(gEp0TagList));
     SetTagList(/* endpoint= */ 1, Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(gEp1TagList));
diff --git a/examples/camera-app/camera-common/BUILD.gn b/examples/camera-app/camera-common/BUILD.gn
@@ -34,6 +34,8 @@ source_set("camera-lib") {
   public_configs = [ ":config" ]
 
   sources = [
+    "${chip_root}/examples/all-clusters-app/all-clusters-common/src/tls-certificate-management-instance.cpp",
+    "${chip_root}/examples/all-clusters-app/all-clusters-common/src/tls-client-management-instance.cpp",
     "include/camera-app.h",
     "include/camera-avstream-controller/camera-avstream-controller.h",
     "include/camera-device-interface.h",
@@ -47,6 +49,7 @@ source_set("camera-lib") {
     "include/camera-avstream-controller",
     "include/media-controller",
     "include/transport",
+    "${chip_root}/examples/all-clusters-app/all-clusters-common/include",
   ]
 
   deps = [
diff --git a/examples/camera-app/camera-common/src/camera-app.cpp b/examples/camera-app/camera-common/src/camera-app.cpp
@@ -16,6 +16,7 @@
  *    limitations under the License.
  */
 #include "camera-app.h"
+#include "tls-client-management-instance.h"
 #include <app/clusters/push-av-stream-transport-server/CodegenIntegration.h>
 
 using namespace chip;
@@ -46,6 +47,9 @@ CameraApp::CameraApp(chip::EndpointId aClustersEndpoint, CameraDeviceInterface *
 
     Clusters::PushAvStreamTransport::SetDelegate(mEndpoint, &(mCameraDevice->GetPushAVTransportDelegate()));
 
+    Clusters::PushAvStreamTransport::SetTLSClientManagementDelegate(chip::EndpointId(1),
+                                                                    &Clusters::TlsClientManagementCommandDelegate::GetInstance());
+
     // Fetch all initialization parameters for CameraAVStreamMgmt Server
     BitFlags<CameraAvStreamManagement::Feature> avsmFeatures;
     BitFlags<CameraAvStreamManagement::OptionalAttribute> avsmOptionalAttrs;
diff --git a/examples/camera-app/linux/include/clusters/push-av-stream-transport/push-av-stream-manager.h b/examples/camera-app/linux/include/clusters/push-av-stream-transport/push-av-stream-manager.h
@@ -71,6 +71,10 @@ class PushAvStreamTransportManager : public PushAvStreamTransportDelegate
 
     bool ValidateUrl(const std::string & url) override;
 
+    bool ValidateStreamUsage(StreamUsageEnum streamUsage) override;
+
+    bool ValidateSegmentDuration(uint16_t segmentDuration) override;
+
     Protocols::InteractionModel::Status
     ValidateBandwidthLimit(StreamUsageEnum streamUsage, const Optional<DataModel::Nullable<uint16_t>> & videoStreamId,
                            const Optional<DataModel::Nullable<uint16_t>> & audioStreamId) override;
diff --git a/examples/camera-app/linux/src/clusters/push-av-stream-transport/push-av-stream-manager.cpp b/examples/camera-app/linux/src/clusters/push-av-stream-transport/push-av-stream-manager.cpp
@@ -237,6 +237,18 @@ PushAvStreamTransportManager::ValidateBandwidthLimit(StreamUsageEnum streamUsage
     return Status::Success;
 }
 
+bool PushAvStreamTransportManager::ValidateStreamUsage(StreamUsageEnum streamUsage)
+{
+    // TODO: if StreamUsage is present in the StreamUsagePriorities list, return true, false otherwise
+    return true;
+}
+
+bool PushAvStreamTransportManager::ValidateSegmentDuration(uint16_t segmentDuration)
+{
+    // TODO: if Segment Duration is multiple of KeyFrameInterval, return true, false otherwise
+    return true;
+}
+
 bool PushAvStreamTransportManager::ValidateUrl(const std::string & url)
 {
     const std::string https = "https://";
diff --git a/src/app/clusters/push-av-stream-transport-server/BUILD.gn b/src/app/clusters/push-av-stream-transport-server/BUILD.gn
@@ -26,6 +26,7 @@ source_set("push-av-stream-transport-server") {
 
   public_deps = [
     "${chip_root}/src/app/",
+    "${chip_root}/src/app/clusters/tls-client-management-server",
     "${chip_root}/src/app/server-cluster",
     "${chip_root}/src/lib/core:types",
     "${chip_root}/zzz_generated/app-common/clusters/PushAvStreamTransport",
diff --git a/src/app/clusters/push-av-stream-transport-server/CodegenIntegration.cpp b/src/app/clusters/push-av-stream-transport-server/CodegenIntegration.cpp
@@ -116,6 +116,24 @@ void SetDelegate(EndpointId endpointId, PushAvStreamTransportDelegate * delegate
     gServers[arrayIndex].Cluster().Init();
 }
 
+void SetTLSClientManagementDelegate(EndpointId endpointId, TlsClientManagementDelegate * delegate)
+{
+    ChipLogProgress(AppServer, "Setting TLS Client Management delegate on endpoint %u", endpointId);
+    uint16_t arrayIndex =
+        emberAfGetClusterServerEndpointIndex(endpointId, PushAvStreamTransport::Id, kPushAvStreamTransportFixedClusterCount);
+    if (arrayIndex >= kPushAvStreamTransportMaxClusterCount)
+    {
+        return;
+    }
+
+    if (!gServers[arrayIndex].IsConstructed())
+    {
+        ChipLogError(AppServer, "Push AV Stream transport is NOT yet constructed. Cannot set TLS Client Management delegate");
+        return;
+    }
+    gServers[arrayIndex].Cluster().SetTLSClientManagementDelegate(endpointId, delegate);
+}
+
 } // namespace PushAvStreamTransport
 } // namespace Clusters
 } // namespace app
diff --git a/src/app/clusters/push-av-stream-transport-server/CodegenIntegration.h b/src/app/clusters/push-av-stream-transport-server/CodegenIntegration.h
@@ -19,6 +19,7 @@
 #pragma once
 
 #include "push-av-stream-transport-delegate.h"
+#include <app/clusters/tls-client-management-server/tls-client-management-server.h>
 
 namespace chip {
 namespace app {
@@ -28,6 +29,9 @@ namespace PushAvStreamTransport {
 /// Sets the given delegate on an endpoint configured via code-generation
 void SetDelegate(chip::EndpointId endpointId, PushAvStreamTransportDelegate * delegate);
 
+/// Sets the given TLS Client Management delegate on an endpoint configured via code-generation
+void SetTLSClientManagementDelegate(chip::EndpointId endpointId, TlsClientManagementDelegate * delegate);
+
 } // namespace PushAvStreamTransport
 } // namespace Clusters
 } // namespace app
diff --git a/src/app/clusters/push-av-stream-transport-server/constants.h b/src/app/clusters/push-av-stream-transport-server/constants.h
@@ -38,6 +38,9 @@ static constexpr size_t kMinUrlLength       = 13u;
 static constexpr size_t kMaxUrlLength       = 2000u;
 static constexpr size_t kMaxCENCKeyLength   = 16u;
 static constexpr size_t kMaxCENCKeyIDLength = 16u;
+static constexpr size_t kMaxTrackNameLength = 16u;
+static constexpr size_t kMinSegmentDuration = 500u;
+static constexpr size_t kMaxSegmentDuration = 65500u;
 
 enum class PushAvStreamTransportStatusEnum : uint8_t
 {
diff --git a/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-cluster.h b/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-cluster.h
@@ -52,6 +52,11 @@ class PushAvStreamTransportServer : public DefaultServerCluster
 
     void SetDelegate(EndpointId aEndpoint, PushAvStreamTransportDelegate * delegate) { mLogic.SetDelegate(aEndpoint, delegate); }
 
+    void SetTLSClientManagementDelegate(EndpointId aEndpoint, TlsClientManagementDelegate * delegate)
+    {
+        mLogic.SetTLSClientManagementDelegate(aEndpoint, delegate);
+    }
+
     CHIP_ERROR Init() { return mLogic.Init(); }
 
     void Deinit() { mLogic.Shutdown(); }
diff --git a/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-delegate.h b/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-delegate.h
@@ -133,6 +133,22 @@ class PushAvStreamTransportDelegate
      */
     virtual bool ValidateUrl(const std::string & url) = 0;
 
+    /**
+     * @brief Validates the provided StreamUsage.
+     *
+     * @param streamUsage The StreamUsage to validate
+     * @return true if StreamUsage is present in the StreamUsagePriorities list, false otherwise
+     */
+    virtual bool ValidateStreamUsage(PushAvStreamTransport::StreamUsageEnum streamUsage) = 0;
+
+    /**
+     * @brief Validates the provided Segment Duration.
+     *
+     * @param segmentDuration The Segment Duration to validate
+     * @return true if Segment Duration is multiple of KeyFrameInterval, false otherwise
+     */
+    virtual bool ValidateSegmentDuration(uint16_t segmentDuration) = 0;
+
     /**
      * @brief Validates bandwidth requirements against camera's resource management.
      *
diff --git a/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-logic.cpp b/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-logic.cpp
@@ -31,6 +31,7 @@
 #include <protocols/interaction_model/StatusCode.h>
 
 static constexpr uint16_t kMaxConnectionId = 65535; // This is also invalid connectionID
+static constexpr uint16_t kMaxEndpointId   = 65534;
 
 using namespace chip;
 using namespace chip::app;
@@ -273,6 +274,10 @@ Status PushAvStreamTransportServerLogic::ValidateIncomingTransportOptions(
         transportOptions.videoStreamID.HasValue() || transportOptions.audioStreamID.HasValue(), Status::InvalidCommand,
         ChipLogError(Zcl, "Transport Options verification from command data[ep=%d]: Missing videoStreamID and audioStreamID",
                      mEndpointId));
+    VerifyOrReturnValue(transportOptions.endpointID <= kMaxEndpointId, Status::ConstraintError,
+                        ChipLogError(Zcl,
+                                     "Transport Options verification from command data[ep=%d]: EndpointID field Constraint Error",
+                                     mEndpointId));
 
     VerifyOrReturnValue(transportOptions.url.size() >= kMinUrlLength && transportOptions.url.size() <= kMaxUrlLength,
                         Status::ConstraintError,
@@ -427,6 +432,43 @@ Status PushAvStreamTransportServerLogic::ValidateIncomingTransportOptions(
                                          "Transport Options verification from command data[ep=%d]: Missing CMAF Container Options ",
                                          mEndpointId));
 
+        CMAFInterfaceEnum cmafInterface = containerOptions.CMAFContainerOptions.Value().CMAFInterface;
+
+        VerifyOrReturnValue(
+            cmafInterface == CMAFInterfaceEnum::kInterface1 || cmafInterface == CMAFInterfaceEnum::kInterface2DASH ||
+                cmafInterface == CMAFInterfaceEnum::kInterface2HLS,
+            Status::ConstraintError,
+            ChipLogError(Zcl,
+                         "Transport Options verification from command data[ep=%d]: CMAF Container Options CMAFInterface not valid",
+                         mEndpointId));
+
+        uint16_t segmentDuration = containerOptions.CMAFContainerOptions.Value().segmentDuration;
+
+        VerifyOrReturnValue(segmentDuration >= kMinSegmentDuration && segmentDuration <= kMaxSegmentDuration,
+                            Status::ConstraintError,
+                            ChipLogError(Zcl,
+                                         "Transport Options verification from command data[ep=%d]: CMAF Container Options Segment "
+                                         "Duration field not within allowed range",
+                                         mEndpointId));
+
+        uint16_t chunkDuration = containerOptions.CMAFContainerOptions.Value().chunkDuration;
+
+        VerifyOrReturnValue(chunkDuration >= 0 && chunkDuration <= segmentDuration / 2, Status::ConstraintError,
+                            ChipLogError(Zcl,
+                                         "Transport Options verification from command data[ep=%d]: CMAF Container Options Chunk "
+                                         "Duration field not within allowed range",
+                                         mEndpointId));
+
+        VerifyOrReturnValue(
+            containerOptions.CMAFContainerOptions.Value().trackName.size() >= 1 &&
+                containerOptions.CMAFContainerOptions.Value().trackName.size() <= kMaxTrackNameLength,
+            Status::ConstraintError,
+            ChipLogError(Zcl,
+                         "Transport Options verification from command data[ep=%d]: CMAF Container Options Track Name "
+                         "Error, actual length: %" PRIu32 " not "
+                         "within expected range of 1 to 16",
+                         mEndpointId, static_cast<uint32_t>(containerOptions.CMAFContainerOptions.Value().trackName.size())));
+
         if (containerOptions.CMAFContainerOptions.Value().CENCKey.HasValue())
         {
             VerifyOrReturnValue(
@@ -508,7 +550,27 @@ PushAvStreamTransportServerLogic::HandleAllocatePushTransport(CommandHandler & h
         return std::nullopt;
     });
 
-    // Todo: TLSEndpointID Validation
+    TlsClientManagementDelegate::EndpointStructType TLSEndpoint;
+    if (mTLSClientManagementDelegate != nullptr)
+    {
+        Status tlsEndpointValidityStatus = mTLSClientManagementDelegate->FindProvisionedEndpointByID(
+            commandPath.mEndpointId, handler.GetAccessingFabricIndex(), commandData.transportOptions.endpointID, TLSEndpoint);
+
+        VerifyOrDo(tlsEndpointValidityStatus == Status::Success, {
+            ChipLogError(Zcl, "HandleAllocatePushTransport[ep=%d]: TLSEndpointID of command data is not valid/Provisioned",
+                         mEndpointId);
+            auto status = to_underlying(StatusCodeEnum::kInvalidTLSEndpoint);
+            handler.AddClusterSpecificFailure(commandPath, status);
+            return std::nullopt;
+        });
+    }
+    else
+    {
+        ChipLogError(Zcl, "HandleAllocatePushTransport[ep=%d]: TLS Client Management Delegate is not set", mEndpointId);
+        auto status = to_underlying(StatusCodeEnum::kInvalidTLSEndpoint);
+        handler.AddClusterSpecificFailure(commandPath, status);
+        return std::nullopt;
+    }
 
     IngestMethodsEnum ingestMethod = commandData.transportOptions.ingestMethod;
 
@@ -554,7 +616,17 @@ PushAvStreamTransportServerLogic::HandleAllocatePushTransport(CommandHandler & h
         return std::nullopt;
     }
 
-    // Todo:Validate ZoneId
+    bool isValidStreamUsage = mDelegate->ValidateStreamUsage(transportOptions.streamUsage);
+    if (isValidStreamUsage == false)
+    {
+        auto status = to_underlying(StatusCodeEnum::kInvalidStreamUsage);
+        ChipLogError(Zcl, "HandleAllocatePushTransport[ep=%d]: StreamUsage not present in the StreamUsagePriorities list",
+                     mEndpointId);
+        handler.AddClusterSpecificFailure(commandPath, status);
+        return std::nullopt;
+    }
+
+    // Todo:Validate MotionZones
 
     // Validate Bandwidth Requirement
     Status status = mDelegate->ValidateBandwidthLimit(transportOptions.streamUsage, transportOptions.videoStreamID,
@@ -635,6 +707,16 @@ PushAvStreamTransportServerLogic::HandleAllocatePushTransport(CommandHandler & h
         }
     }
 
+    bool isValidSegmentDuration =
+        mDelegate->ValidateSegmentDuration(transportOptions.containerOptions.CMAFContainerOptions.Value().segmentDuration);
+    if (isValidSegmentDuration == false)
+    {
+        auto segmentDurationStatus = to_underlying(StatusCodeEnum::kInvalidOptions);
+        ChipLogError(Zcl, "HandleAllocatePushTransport[ep=%d]: Segment Duration not within allowed range", mEndpointId);
+        handler.AddClusterSpecificFailure(commandPath, segmentDurationStatus);
+        return std::nullopt;
+    }
+
     uint16_t connectionID = GenerateConnectionID();
 
     if (connectionID == kMaxConnectionId)
diff --git a/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-logic.h b/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-logic.h
@@ -6,6 +6,7 @@
 #include <app/clusters/push-av-stream-transport-server/constants.h>
 #include <app/clusters/push-av-stream-transport-server/push-av-stream-transport-delegate.h>
 #include <app/clusters/push-av-stream-transport-server/push-av-stream-transport-storage.h>
+#include <app/clusters/tls-client-management-server/tls-client-management-server.h>
 #include <app/server-cluster/DefaultServerCluster.h>
 #include <protocols/interaction_model/StatusCode.h>
 #include <vector>
@@ -31,6 +32,16 @@ class PushAvStreamTransportServerLogic
         mDelegate->SetEndpointId(aEndpoint);
     }
 
+    void SetTLSClientManagementDelegate(EndpointId aEndpoint, TlsClientManagementDelegate * delegate)
+    {
+        mTLSClientManagementDelegate = delegate;
+        if (mTLSClientManagementDelegate == nullptr)
+        {
+            ChipLogError(Zcl, "Push AV Stream Transport [ep=%d]: Trying to set TLS Client Management delegate to null", aEndpoint);
+            return;
+        }
+    }
+
     enum class UpsertResultEnum : uint8_t
     {
         kInserted = 0x00,
@@ -95,8 +106,8 @@ class PushAvStreamTransportServerLogic
                                   const Optional<PushAvStreamTransport::TriggerActivationReasonEnum> activationReason);
 
 private:
-    PushAvStreamTransportDelegate * mDelegate = nullptr;
-
+    PushAvStreamTransportDelegate * mDelegate                  = nullptr;
+    TlsClientManagementDelegate * mTLSClientManagementDelegate = nullptr;
     /// Convenience method that returns if the internal delegate is null and will log
     /// an error if the check returns true
     bool IsNullDelegateWithLogging(EndpointId endpointIdForLogging);
diff --git a/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-storage.h b/src/app/clusters/push-av-stream-transport-server/push-av-stream-transport-storage.h
diff --git a/src/app/clusters/push-av-stream-transport-server/tests/BUILD.gn b/src/app/clusters/push-av-stream-transport-server/tests/BUILD.gn
diff --git a/src/app/clusters/push-av-stream-transport-server/tests/TestPushAVStreamTransportCluster.cpp b/src/app/clusters/push-av-stream-transport-server/tests/TestPushAVStreamTransportCluster.cpp
diff --git a/src/app/clusters/tls-client-management-server/BUILD.gn b/src/app/clusters/tls-client-management-server/BUILD.gn
