Merge branch 'master' into create_TC_IDM_3_2_python3_test

Author: j-ororke

config/esp32/components/chip/Kconfig

@@ -1161,7 +1161,7 @@ menu "CHIP Device Layer"
             int "MRP local active retry interval for Thread network in milliseconds"
             depends on ENABLE_MATTER_OVER_THREAD
             range 0 3600000
-            default 800
+            default 2000
             help
                 Base retry interval of the present Thread node when it is in the active state.
 
@@ -1177,7 +1177,7 @@ menu "CHIP Device Layer"
             int "MRP local idle retry interval for Thread network in milliseconds"
             depends on ENABLE_MATTER_OVER_THREAD
             range 0 3600000
-            default 800
+            default 2000
             help
                 Base retry interval of the present Thread node when it is in the idle state.
 
@@ -1193,7 +1193,7 @@ menu "CHIP Device Layer"
             int "MRP retransmission delta timeout for Thread network in milliseconds"
             depends on ENABLE_MATTER_OVER_THREAD
             range 0 3600000
-            default 500
+            default 1500
             help
                 A constant value added to the calculated retransmission timeout.
 

examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter

@@ -5775,7 +5775,7 @@ cluster AudioOutput = 1291 {
 
 /** This cluster provides an interface for launching content on a media player device such as a TV or Speaker. */
 cluster ApplicationLauncher = 1292 {
-  revision 1; // NOTE: Default/not specifically set
+  revision 2;
 
   enum StatusEnum : enum8 {
     kSuccess = 0;
@@ -5790,7 +5790,7 @@ cluster ApplicationLauncher = 1292 {
     kApplicationPlatform = 0x1;
   }
 
-  shared struct ApplicationStruct {
+  struct ApplicationStruct {
     int16u catalogVendorID = 0;
     char_string applicationID = 1;
   }
@@ -5826,17 +5826,17 @@ cluster ApplicationLauncher = 1292 {
     optional octet_string data = 1;
   }
 
-  /** Upon receipt, this SHALL launch the specified app with optional data. The TV Device SHALL launch and bring to foreground the identified application in the command if the application is not already launched and in foreground. The TV Device SHALL update state attribute on the Application Basic cluster of the Endpoint corresponding to the launched application. This command returns a Launch Response. */
+  /** Upon receipt of this command, the server SHALL launch the application with optional data. */
   command LaunchApp(LaunchAppRequest): LauncherResponse = 0;
-  /** Upon receipt on a Video Player endpoint this SHALL stop the specified application if it is running. */
+  /** Upon receipt of this command, the server SHALL stop the application if it is running. */
   command StopApp(StopAppRequest): LauncherResponse = 1;
-  /** Upon receipt on a Video Player endpoint this SHALL hide the specified application if it is running and visible. */
+  /** Upon receipt of this command, the server SHALL hide the application. */
   command HideApp(HideAppRequest): LauncherResponse = 2;
 }
 
 /** This cluster provides information about an application running on a TV or media player device which is represented as an endpoint. */
 cluster ApplicationBasic = 1293 {
-  revision 1; // NOTE: Default/not specifically set
+  revision 1;
 
   enum ApplicationStatusEnum : enum8 {
     kStopped = 0;
@@ -5845,7 +5845,7 @@ cluster ApplicationBasic = 1293 {
     kActiveVisibleNotFocus = 3;
   }
 
-  shared struct ApplicationStruct {
+  struct ApplicationStruct {
     int16u catalogVendorID = 0;
     char_string applicationID = 1;
   }

examples/camera-app/linux/include/webrtc-abstract.h

@@ -42,8 +42,15 @@ enum class MediaType : uint8_t
     Video,
 };
 
+struct ICECandidateInfo
+{
+    std::string candidate;
+    std::string mid;
+    int mlineIndex;
+};
+
 using OnLocalDescriptionCallback = std::function<void(const std::string & sdp, SDPType type)>;
-using OnICECandidateCallback     = std::function<void(const std::string & candidate)>;
+using OnICECandidateCallback     = std::function<void(const ICECandidateInfo & candidateInfo)>;
 using OnConnectionStateCallback  = std::function<void(bool connected)>;
 using OnTrackCallback            = std::function<void(std::shared_ptr<WebRTCTrack> track)>;
 

examples/camera-app/linux/include/webrtc-transport.h

@@ -105,9 +105,9 @@ class WebrtcTransport : public Transport
 
     void SetSdpAnswer(std::string localSdp) { mLocalSdp = localSdp; }
 
-    std::vector<std::string> GetCandidates() { return mLocalCandidates; }
+    const std::vector<ICECandidateInfo> & GetCandidates() { return mLocalCandidates; }
 
-    void SetCandidates(std::vector<std::string> candidates) { mLocalCandidates = candidates; }
+    void SetCandidates(std::vector<ICECandidateInfo> candidates) { mLocalCandidates = candidates; }
 
     void AddRemoteCandidate(const std::string & candidate, const std::string & mid);
 
@@ -119,7 +119,7 @@ class WebrtcTransport : public Transport
 
     // WebRTC Callbacks
     void OnLocalDescription(const std::string & sdp, SDPType type);
-    void OnICECandidate(const std::string & candidate);
+    void OnICECandidate(const ICECandidateInfo & candidateInfo);
     void OnConnectionStateChanged(bool connected);
     void OnTrack(std::shared_ptr<WebRTCTrack> track);
 
@@ -138,7 +138,7 @@ class WebrtcTransport : public Transport
 
     std::string mLocalSdp;
     SDPType mLocalSdpType;
-    std::vector<std::string> mLocalCandidates;
+    std::vector<ICECandidateInfo> mLocalCandidates;
 
     RequestArgs mRequestArgs;
     OnTransportLocalDescriptionCallback mOnLocalDescription = nullptr;

examples/camera-app/linux/src/clusters/webrtc-provider/webrtc-provider-manager.cpp

@@ -887,42 +887,47 @@ void WebRTCProviderManager::OnConnectionStateChanged(bool connected, const uint1
     }
     else
     {
-        WebrtcTransport * transport = GetTransport(sessionId);
-        if (transport == nullptr)
-        {
+        // Schedule cleanup on Matter thread to ensure proper locking when calling RemoveSession.
+        // Safe to capture 'this' by value: WebRTCProviderManager is a member of the global CameraDevice
+        // object which has static storage duration and lives for the entire program lifetime.
+        DeviceLayer::SystemLayer().ScheduleLambda([this, sessionId]() {
+            WebrtcTransport * transport = GetTransport(sessionId);
+            if (transport == nullptr)
+            {
+                ChipLogProgress(Camera,
+                                "Transport not found for session %u during disconnect; session may have already been cleaned up",
+                                sessionId);
+                return;
+            }
 
-            ChipLogProgress(Camera,
-                            "Transport not found for session %u during disconnect; session may have already been cleaned up",
-                            sessionId);
-            return;
-        }
+            // Connection was closed/disconnected by the peer - clean up the session
+            ChipLogProgress(Camera, "Peer connection closed for session %u, cleaning up resources", sessionId);
 
-        // Connection was closed/disconnected by the peer - clean up the session
-        ChipLogProgress(Camera, "Peer connection closed for session %u, cleaning up resources", sessionId);
+            // Release the Video and Audio Streams from the CameraAVStreamManagement
+            // cluster and update the reference counts.
+            ReleaseAudioVideoStreams(sessionId);
 
-        // Release the Video and Audio Streams from the CameraAVStreamManagement
-        // cluster and update the reference counts.
-        ReleaseAudioVideoStreams(sessionId);
-
-        // Capture args before unregistering in case the transport is invalidated
-        WebrtcTransport::RequestArgs args = transport->GetRequestArgs();
+            // Capture args before unregistering in case the transport is invalidated
+            WebrtcTransport::RequestArgs args = transport->GetRequestArgs();
 
-        // Unregister the transport from the media controller
-        UnregisterWebrtcTransport(sessionId);
+            // Unregister the transport from the media controller
+            UnregisterWebrtcTransport(sessionId);
 
-        // Remove from session maps
-        mSessionIdMap.erase(ScopedNodeId(args.peerNodeId, args.fabricIndex));
+            // Remove from session maps
+            mSessionIdMap.erase(ScopedNodeId(args.peerNodeId, args.fabricIndex));
 
-        // Remove from current sessions list in the WebRTC Transport Provider
-        if (mWebRTCTransportProvider != nullptr)
-        {
-            mWebRTCTransportProvider->RemoveSession(sessionId);
-        }
+            // Remove from current sessions list in the WebRTC Transport Provider
+            // This MUST be called on the Matter thread with the stack lock held
+            if (mWebRTCTransportProvider != nullptr)
+            {
+                mWebRTCTransportProvider->RemoveSession(sessionId);
+            }
 
-        // Finally, remove and destroy the transport
-        mWebrtcTransportMap.erase(sessionId);
+            // Finally, remove and destroy the transport
+            mWebrtcTransportMap.erase(sessionId);
 
-        ChipLogProgress(Camera, "Session %u cleanup completed", sessionId);
+            ChipLogProgress(Camera, "Session %u cleanup completed", sessionId);
+        });
     }
 }
 
@@ -975,7 +980,9 @@ CHIP_ERROR WebRTCProviderManager::SendICECandidatesCommand(Messaging::ExchangeMa
         ChipLogError(Camera, "WebTransport not found for the sessionId: %u", sessionId);
         return CHIP_ERROR_INTERNAL;
     }
-    std::vector<std::string> localCandidates = transport->GetCandidates();
+
+    const std::vector<ICECandidateInfo> & localCandidates = transport->GetCandidates();
+
     // Build the command
     WebRTCTransportRequestor::Commands::ICECandidates::Type command;
 
@@ -986,9 +993,31 @@ CHIP_ERROR WebRTCProviderManager::SendICECandidatesCommand(Messaging::ExchangeMa
     }
 
     std::vector<ICECandidateStruct> iceCandidateStructList;
-    for (const auto & candidate : localCandidates)
+    for (const auto & candidateInfo : localCandidates)
     {
-        ICECandidateStruct iceCandidate = { CharSpan::fromCharString(candidate.c_str()) };
+        ICECandidateStruct iceCandidate;
+        iceCandidate.candidate = CharSpan(candidateInfo.candidate.data(), candidateInfo.candidate.size());
+
+        // Set SDPMid if available
+        if (!candidateInfo.mid.empty())
+        {
+            iceCandidate.SDPMid.SetNonNull(CharSpan(candidateInfo.mid.data(), candidateInfo.mid.size()));
+        }
+        else
+        {
+            iceCandidate.SDPMid.SetNull();
+        }
+
+        // Set SDPMLineIndex if valid
+        if (candidateInfo.mlineIndex >= 0)
+        {
+            iceCandidate.SDPMLineIndex.SetNonNull(static_cast<uint16_t>(candidateInfo.mlineIndex));
+        }
+        else
+        {
+            iceCandidate.SDPMLineIndex.SetNull();
+        }
+
         iceCandidateStructList.push_back(iceCandidate);
     }
 

examples/camera-app/linux/src/webrtc-libdatachannel.cpp

@@ -291,10 +291,38 @@ class LibDataChannelPeerConnection : public WebRTCPeerConnection
     void SetCallbacks(OnLocalDescriptionCallback onLocalDescription, OnICECandidateCallback onICECandidate,
                       OnConnectionStateCallback onConnectionState, OnTrackCallback onTrack) override
     {
-        mPeerConnection->onLocalDescription(
-            [onLocalDescription](rtc::Description desc) { onLocalDescription(std::string(desc), RtcTypeToSDPType(desc.type())); });
+        mPeerConnection->onLocalDescription([onLocalDescription, onICECandidate](rtc::Description desc) {
+            // First, notify about the local description
+            onLocalDescription(std::string(desc), RtcTypeToSDPType(desc.type()));
 
-        mPeerConnection->onLocalCandidate([onICECandidate](rtc::Candidate candidate) { onICECandidate(std::string(candidate)); });
+            // Extract any candidates embedded in the SDP description
+            std::vector<rtc::Candidate> candidates = desc.candidates();
+            ChipLogProgress(Camera, "Extracted %lu candidates from SDP description", candidates.size());
+
+            for (const auto & candidate : candidates)
+            {
+                ICECandidateInfo candidateInfo;
+                candidateInfo.candidate  = std::string(candidate);
+                candidateInfo.mid        = candidate.mid();
+                candidateInfo.mlineIndex = -1; // libdatachannel doesn't provide mlineIndex
+
+                ChipLogProgress(Camera, "[From SDP] Candidate: %s, mid: %s", candidateInfo.candidate.c_str(),
+                                candidateInfo.mid.c_str());
+
+                onICECandidate(candidateInfo);
+            }
+        });
+
+        mPeerConnection->onLocalCandidate([onICECandidate](rtc::Candidate candidate) {
+            ICECandidateInfo candidateInfo;
+            candidateInfo.candidate = std::string(candidate);
+            candidateInfo.mid       = candidate.mid();
+
+            // Note: libdatachannel doesn't directly provide mlineIndex, so we use -1 to indicate it is not present.
+            candidateInfo.mlineIndex = -1;
+
+            onICECandidate(candidateInfo);
+        });
 
         mPeerConnection->onStateChange([onConnectionState](rtc::PeerConnection::State state) {
             ChipLogProgress(Camera, "[PeerConnection State: %s]", GetPeerConnectionStateStr(state));

examples/camera-app/linux/src/webrtc-transport.cpp

@@ -146,7 +146,7 @@ void WebrtcTransport::Start()
     mPeerConnection = CreateWebRTCPeerConnection();
 
     mPeerConnection->SetCallbacks([this](const std::string & sdp, SDPType type) { this->OnLocalDescription(sdp, type); },
-                                  [this](const std::string & candidate) { this->OnICECandidate(candidate); },
+                                  [this](const ICECandidateInfo & candidateInfo) { this->OnICECandidate(candidateInfo); },
                                   [this](bool connected) { this->OnConnectionStateChanged(connected); },
                                   [this](std::shared_ptr<WebRTCTrack> track) { this->OnTrack(track); });
 }
@@ -208,12 +208,13 @@ bool WebrtcTransport::ClosePeerConnection()
     return true;
 }
 
-void WebrtcTransport::OnICECandidate(const std::string & candidate)
+void WebrtcTransport::OnICECandidate(const ICECandidateInfo & candidateInfo)
 {
     ChipLogProgress(Camera, "ICE Candidate received for sessionID: %u", mRequestArgs.sessionId);
-    mLocalCandidates.push_back(candidate);
+    mLocalCandidates.push_back(candidateInfo);
     ChipLogProgress(Camera, "Local Candidate:");
-    ChipLogProgress(Camera, "%s", candidate.c_str());
+    ChipLogProgress(Camera, "%s", candidateInfo.candidate.c_str());
+    ChipLogProgress(Camera, "  mid: %s, mlineIndex: %d", candidateInfo.mid.c_str(), candidateInfo.mlineIndex);
 }
 
 void WebrtcTransport::OnConnectionStateChanged(bool connected)

examples/camera-controller/webrtc-manager/WebRTCManager.cpp

@@ -277,13 +277,38 @@ CHIP_ERROR WebRTCManager::Connnect(Controller::DeviceCommissioner & commissioner
         mLocalDescription = std::string(desc);
         ChipLogProgress(Camera, "Local Description:");
         ChipLogProgress(Camera, "%s", mLocalDescription.c_str());
+
+        // Extract any candidates embedded in the SDP description
+        std::vector<rtc::Candidate> candidates = desc.candidates();
+        ChipLogProgress(Camera, "Extracted %lu candidates from SDP description", candidates.size());
+
+        for (const auto & candidate : candidates)
+        {
+            ICECandidateInfo candidateInfo;
+            candidateInfo.candidate  = std::string(candidate);
+            candidateInfo.mid        = candidate.mid();
+            candidateInfo.mlineIndex = -1; // libdatachannel doesn't provide mlineIndex
+
+            ChipLogProgress(Camera, "[From SDP] Candidate: %s, mid: %s", candidateInfo.candidate.c_str(),
+                            candidateInfo.mid.c_str());
+
+            mLocalCandidates.push_back(candidateInfo);
+        }
     });
 
     mPeerConnection->onLocalCandidate([this](rtc::Candidate candidate) {
-        std::string candidateStr = std::string(candidate);
-        mLocalCandidates.push_back(candidateStr);
+        ICECandidateInfo candidateInfo;
+        candidateInfo.candidate = std::string(candidate);
+        candidateInfo.mid       = candidate.mid();
+
+        // Note: libdatachannel doesn't directly provide mlineIndex, so we use -1 to indicate it is not present.
+        candidateInfo.mlineIndex = -1;
+
         ChipLogProgress(Camera, "Local Candidate:");
-        ChipLogProgress(Camera, "%s", candidateStr.c_str());
+        ChipLogProgress(Camera, "%s", candidateInfo.candidate.c_str());
+        ChipLogProgress(Camera, "  mid: %s, mlineIndex: %d", candidateInfo.mid.c_str(), candidateInfo.mlineIndex);
+
+        mLocalCandidates.push_back(candidateInfo);
     });
 
     mPeerConnection->onStateChange([this](rtc::PeerConnection::State state) {

examples/camera-controller/webrtc-manager/WebRTCManager.h

@@ -26,6 +26,13 @@
 #include <webrtc-manager/WebRTCProviderClient.h>
 #include <webrtc-manager/WebRTCRequestorDelegate.h>
 
+struct ICECandidateInfo
+{
+    std::string candidate;
+    std::string mid;
+    int mlineIndex;
+};
+
 class WebRTCManager
 {
 public:
@@ -87,8 +94,8 @@ class WebRTCManager
     uint16_t mPendingSessionId = 0;
     std::string mLocalDescription;
 
-    // Local vector to store the ICE Candidate strings coming from the WebRTC stack
-    std::vector<std::string> mLocalCandidates;
+    // Local vector to store the ICE Candidate info coming from the WebRTC stack
+    std::vector<ICECandidateInfo> mLocalCandidates;
 
     std::shared_ptr<rtc::Track> mTrack;
     std::shared_ptr<rtc::Track> mAudioTrack;