Merge branch 'master' into nodiscard_prep

Author: gmarcosb

examples/dishwasher-app/silabs/include/ElectricalEnergyMeasurementInstance.h

@@ -21,6 +21,7 @@
 #include "AppConfig.h"
 #include "AppEvent.h"
 #include "ElectricalPowerMeasurementDelegate.h"
+#include <app/clusters/electrical-energy-measurement-server/ElectricalEnergyMeasurementCluster.h>
 #include <app/clusters/electrical-energy-measurement-server/electrical-energy-measurement-server.h>
 #include <cmsis_os2.h>
 

examples/tv-casting-app/android/App/app/src/main/jni/com/matter/casting/core/CastingPlayer.java

@@ -177,4 +177,10 @@ MatterError verifyOrEstablishConnection(
    * @returns A String representation of the CastingPlayer's current connectation.
    */
   String getConnectionStateNative();
+
+  /**
+   * @brief Removes any fabric associated with this player in order to cause the UDC flow when
+   *     verifyOrEstablishConnection is called
+   */
+  void removeFabric();
 }

examples/tv-casting-app/android/App/app/src/main/jni/com/matter/casting/core/MatterCastingPlayer.java

@@ -269,6 +269,9 @@ public MatterError continueConnecting() {
   @Override
   public native void disconnect();
 
+  @Override
+  public native void removeFabric();
+
   /**
    * @brief Get CastingPlayer's current ConnectionState.
    * @throws IllegalArgumentException or NullPointerException when native layer returns invalid

examples/tv-casting-app/android/App/app/src/main/jni/cpp/core/MatterCastingPlayer-JNI.cpp

@@ -165,6 +165,19 @@ JNI_METHOD(void, disconnect)
     castingPlayer->Disconnect();
 }
 
+JNI_METHOD(void, removeFabric)
+(JNIEnv * env, jobject thiz)
+{
+    chip::DeviceLayer::StackLock lock;
+    ChipLogProgress(AppServer, "MatterCastingPlayer-JNI::removeFabric()");
+
+    core::CastingPlayer * castingPlayer = support::convertCastingPlayerFromJavaToCpp(thiz);
+    VerifyOrReturn(castingPlayer != nullptr,
+                   ChipLogError(AppServer, "MatterCastingPlayer-JNI::removeFabric() castingPlayer == nullptr"));
+
+    castingPlayer->RemoveFabric();
+}
+
 JNI_METHOD(jstring, getConnectionStateNative)
 (JNIEnv * env, jobject thiz)
 {

examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/MCCastingPlayer.h

@@ -158,6 +158,12 @@ typedef enum {
  */
 - (void)disconnect;
 
+/**
+ * @brief Removes any fabric associated with this player in order to cause the UDC flow when
+ *     verifyOrEstablishConnection is called
+ */
+- (void)removeFabric;
+
 /**
  * @brief Get the CastingPlayer's connection state
  * @param state The current connection state that will be return.

examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/MCCastingPlayer.mm

@@ -190,6 +190,17 @@ - (void)disconnect
     });
 }
 
+- (void)removeFabric
+{
+    ChipLogProgress(AppServer, "MCCastingPlayer.removeFabric() called");
+    VerifyOrReturn([[MCCastingApp getSharedInstance] isRunning], ChipLogError(AppServer, "MCCastingPlayer.removeFabric() MCCastingApp NOT running"));
+
+    dispatch_queue_t workQueue = [[MCCastingApp getSharedInstance] getWorkQueue];
+    dispatch_sync(workQueue, ^{
+        _cppCastingPlayer->RemoveFabric();
+    });
+}
+
 - (NSError * _Nullable)getConnectionState:(MCCastingPlayerConnectionState * _Nonnull)state;
 {
     ChipLogProgress(AppServer, "MCCastingPlayer.getConnectionState() called");

examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/compat-shim/CastingServerBridge.h

@@ -168,6 +168,15 @@ __attribute__((deprecated("Use the APIs described in /examples/tv-casting-app/AP
  */
 - (void)disconnect:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler;
 
+/*!
+ @brief  Removes any fabric associated with this player in order to cause the UDC flow when verifyOrEstablishConnection is called.
+
+ @param clientQueue Queue to invoke callbacks on
+
+ @param requestSentHandler Called after the request has been sent
+ */
+- (void)removeFabric:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler;
+
 /*!
  @brief Purge data cached by the Matter casting library
 

examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/compat-shim/CastingServerBridge.mm

@@ -339,6 +339,18 @@ - (void)disconnect:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nu
     });
 }
 
+- (void)removeFabric:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler
+{
+    ChipLogProgress(AppServer, "CastingServerBridge().removeFabric() called");
+    MCCastingPlayer * castingPlayer = [MCCastingPlayer getTargetCastingPlayer];
+    if (castingPlayer != nil) {
+        [castingPlayer removeFabric];
+    }
+    dispatch_async(clientQueue, ^{
+        requestSentHandler();
+    });
+}
+
 - (void)purgeCache:(dispatch_queue_t _Nonnull)clientQueue responseHandler:(void (^)(MatterError * _Nonnull))responseHandler
 {
     ChipLogProgress(AppServer, "CastingServerBridge().purgeCache() called");

examples/tv-casting-app/tv-casting-common/core/CastingPlayer.cpp

@@ -119,40 +119,71 @@ void CastingPlayer::VerifyOrEstablishConnection(ConnectionCallbacks connectionCa
                 ChipLogProgress(
                     AppServer,
                     "CastingPlayer::VerifyOrEstablishConnection() Attempting to Re-establish CASE with cached CastingPlayer");
+
+                // Preserve the IP addresses from the discovered CastingPlayer before overwriting with cached data
+                unsigned int discoveredNumIPs = mAttributes.numIPs;
+                chip::Inet::IPAddress discoveredIpAddresses[chip::Dnssd::CommonResolutionData::kMaxIPAddresses];
+                for (unsigned int i = 0; i < discoveredNumIPs; i++)
+                {
+                    discoveredIpAddresses[i] = mAttributes.ipAddresses[i];
+                }
+                chip::Inet::InterfaceId discoveredInterfaceId = mAttributes.interfaceId;
+
                 *this                          = cachedCastingPlayers[index];
                 mConnectionState               = CASTING_PLAYER_CONNECTING;
                 mOnCompleted                   = connectionCallbacks.mOnConnectionComplete;
                 mCommissioningWindowTimeoutSec = commissioningWindowTimeoutSec;
 
-                FindOrEstablishSession(
-                    nullptr,
-                    [](void * context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle) {
-                        ChipLogProgress(AppServer,
-                                        "CastingPlayer::VerifyOrEstablishConnection() FindOrEstablishSession Connection to "
-                                        "CastingPlayer successful");
-                        CastingPlayer::GetTargetCastingPlayer()->mConnectionState = CASTING_PLAYER_CONNECTED;
-
-                        // this async call will Load all the endpoints with their respective attributes into the TargetCastingPlayer
-                        // persist the TargetCastingPlayer information into the CastingStore and call mOnCompleted()
-                        support::EndpointListLoader::GetInstance()->Initialize(&exchangeMgr, &sessionHandle);
-                        support::EndpointListLoader::GetInstance()->Load();
-                    },
-                    [](void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error) {
-                        ChipLogError(AppServer,
-                                     "CastingPlayer::VerifyOrEstablishConnection() FindOrEstablishSession Connection to "
-                                     "CastingPlayer failed");
-                        CastingPlayer::GetTargetCastingPlayer()->mConnectionState = CASTING_PLAYER_NOT_CONNECTED;
-                        CHIP_ERROR e = support::CastingStore::GetInstance()->Delete(*CastingPlayer::GetTargetCastingPlayer());
-                        if (e != CHIP_NO_ERROR)
-                        {
-                            ChipLogError(AppServer, "CastingStore::Delete() failed. Err: %" CHIP_ERROR_FORMAT, e.Format());
-                        }
-
-                        VerifyOrReturn(CastingPlayer::GetTargetCastingPlayer()->mOnCompleted);
-                        CastingPlayer::GetTargetCastingPlayer()->mOnCompleted(error, nullptr);
-                        mTargetCastingPlayer.reset();
-                    });
-                return; // FindOrEstablishSession called. Return early.
+                // Restore the IP addresses from the discovered CastingPlayer
+                mAttributes.numIPs = discoveredNumIPs;
+                for (unsigned int i = 0; i < discoveredNumIPs; i++)
+                {
+                    mAttributes.ipAddresses[i] = discoveredIpAddresses[i];
+                }
+                mAttributes.interfaceId = discoveredInterfaceId;
+                ChipLogProgress(AppServer, "Restored discovered CastingPlayer numIPs: %u", mAttributes.numIPs);
+
+                // make sure to copy fields passed in which are needed for UDC
+                mIdOptions                                     = idOptions;
+                mClientProvidedCommissionerDeclarationCallback = connectionCallbacks.mCommissionerDeclarationCallback != nullptr;
+
+                // don't attempt to connect with the cached CastingPlayer if the nodeId is not set
+                // instead, fall through to trigger UDC
+                if (mAttributes.nodeId != 0)
+                {
+                    FindOrEstablishSession(
+                        nullptr,
+                        [](void * context, chip::Messaging::ExchangeManager & exchangeMgr,
+                           const chip::SessionHandle & sessionHandle) {
+                            ChipLogProgress(AppServer,
+                                            "CastingPlayer::VerifyOrEstablishConnection() FindOrEstablishSession Connection to "
+                                            "CastingPlayer successful");
+                            CastingPlayer::GetTargetCastingPlayer()->mConnectionState = CASTING_PLAYER_CONNECTED;
+
+                            // this async call will Load all the endpoints with their respective attributes into the
+                            // TargetCastingPlayer.
+                            //
+                            // persist the TargetCastingPlayer information into the CastingStore and call mOnCompleted()
+                            support::EndpointListLoader::GetInstance()->Initialize(&exchangeMgr, &sessionHandle);
+                            support::EndpointListLoader::GetInstance()->Load();
+                        },
+                        [](void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error) {
+                            ChipLogError(AppServer,
+                                         "CastingPlayer::VerifyOrEstablishConnection() FindOrEstablishSession Connection to "
+                                         "CastingPlayer failed");
+                            CastingPlayer::GetTargetCastingPlayer()->mConnectionState = CASTING_PLAYER_NOT_CONNECTED;
+                            CHIP_ERROR e = support::CastingStore::GetInstance()->Delete(*CastingPlayer::GetTargetCastingPlayer());
+                            if (e != CHIP_NO_ERROR)
+                            {
+                                ChipLogError(AppServer, "CastingStore::Delete() failed. Err: %" CHIP_ERROR_FORMAT, e.Format());
+                            }
+
+                            VerifyOrReturn(CastingPlayer::GetTargetCastingPlayer()->mOnCompleted);
+                            CastingPlayer::GetTargetCastingPlayer()->mOnCompleted(error, nullptr);
+                            mTargetCastingPlayer.reset();
+                        });
+                    return; // FindOrEstablishSession called. Return early.
+                }
             }
         }
     }
@@ -315,6 +346,20 @@ void CastingPlayer::Disconnect()
     CastingPlayerDiscovery::GetInstance()->ClearCastingPlayersInternal();
 }
 
+void CastingPlayer::RemoveFabric()
+{
+    ChipLogProgress(AppServer, "CastingPlayer::RemoveFabric()");
+    chip::Server::GetInstance().GetFabricTable().Delete(mAttributes.fabricIndex);
+    mAttributes.fabricIndex = 0;
+    mAttributes.nodeId      = 0;
+
+    CHIP_ERROR err = support::CastingStore::GetInstance()->AddOrUpdate(*this);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(AppServer, "CastingStore::AddOrUpdate() failed. Err: %" CHIP_ERROR_FORMAT, err.Format());
+    }
+}
+
 void CastingPlayer::RegisterEndpoint(const memory::Strong<Endpoint> endpoint)
 {
     ChipLogProgress(AppServer, "CastingPlayer::RegisterEndpoint() EndpointID: %d, VendorID: %d, ProductID: %d", endpoint->GetId(),

examples/tv-casting-app/tv-casting-common/core/CastingPlayer.h

@@ -222,6 +222,14 @@ class CastingPlayer : public std::enable_shared_from_this<CastingPlayer>
      */
     void Disconnect();
 
+    /**
+     * @brief Removes any fabric associated with this player in order to cause the UDC flow when
+     * verifyOrEstablishConnection is called
+     *
+     * @note This method will set nodeId and fabricIndex to 0.
+     */
+    void RemoveFabric();
+
     /**
      * @brief Find an existing session for this CastingPlayer, or trigger a new session
      * request.