Merge branch 'master' into telink_docker_update

s07641069 · web-flow · commit e8d59d78ec59 · 2025-01-06T23:25:18.000+02:00
diff --git a/.github/workflows/java-tests.yaml b/.github/workflows/java-tests.yaml
@@ -260,9 +260,6 @@ jobs:
                      --factoryreset \
                   '
             - name: Run Pairing Onnetwork and get diagnostic log Test
-              # TODO: test below is disabled because it seems flaky (crashes on pool not being empty on app exit)
-              #       See: https://github.com/project-chip/connectedhomeip/issues/36734
-              if: false
               run: |
                   scripts/run_in_python_env.sh out/venv \
                   './scripts/tests/run_java_test.py \
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt
@@ -9,6 +9,7 @@ import com.matter.controller.commands.pairing.PairingCommand
 import com.matter.controller.commands.pairing.PairingModeType
 import com.matter.controller.commands.pairing.PairingNetworkType
 import java.io.File
+import java.util.concurrent.TimeUnit
 import java.util.logging.Level
 import java.util.logging.Logger
 
@@ -85,12 +86,19 @@ class PairOnNetworkLongDownloadLogCommand(
       )
     logger.log(Level.INFO, "Waiting response : ${getTimeoutMillis()}")
     waitCompleteMs(getTimeoutMillis())
+    // For waiting both side terminating.
+    try {
+      TimeUnit.SECONDS.sleep(WAIT_FOR_TERMINATE)
+    } catch (e: InterruptedException) {
+      throw RuntimeException(e)
+    }
   }
 
   companion object {
     private val logger = Logger.getLogger(PairOnNetworkLongDownloadLogCommand::class.java.name)
 
     private const val MATTER_PORT = 5540
     private const val MS_TO_SEC = 1000
+    private const val WAIT_FOR_TERMINATE = 1L
   }
 }
diff --git a/integrations/docker/images/base/chip-build/version b/integrations/docker/images/base/chip-build/version
@@ -1 +1 @@
-96 : [Telink] Update Docker image (Zephyr update)
+97 : [Telink] Update Docker image (Zephyr update)
diff --git a/integrations/docker/images/stage-2/chip-build-nxp/Dockerfile b/integrations/docker/images/stage-2/chip-build-nxp/Dockerfile
@@ -13,7 +13,7 @@ WORKDIR /opt/nxp/
 ARG NXP_SDK_EXAMPLE_PATH=nxp_matter_support/github_sdk/common_sdk/repo/examples
 
 RUN set -x \
-    && git clone --branch v1.4.0-pvw1 https://github.com/NXP/nxp_matter_support.git \
+    && git clone --branch matter-sdk-2.16.100-support https://github.com/NXP/nxp_matter_support.git \
     && pip3 install --break-system-packages -U --no-cache-dir west \
     && ./nxp_matter_support/scripts/update_nxp_sdk.py \
     && cd $NXP_SDK_EXAMPLE_PATH \
diff --git a/kotlin-detect-config.yaml b/kotlin-detect-config.yaml
@@ -232,6 +232,7 @@ exceptions:
     TooGenericExceptionThrown:
         excludes:
             - "**/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt"
+            - "**/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt"
             - "**/examples/java-matter-controller/java/src/com/matter/controller/commands/discover/DiscoverCommissionablesCommand.kt"
             - "**/src/controller/java/generated/java/**/*"
     ThrowingExceptionsWithoutMessageOrCause:
diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -99,7 +99,7 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Controller, "Make BDX URI failure : %" CHIP_ERROR_FORMAT, err.Format());
-        FinishLogDownloadFromNode(err);
+        FinishLogDownloadFromNode(static_cast<void *>(this), err);
     }
 
     mBdxReceiver =
@@ -132,18 +132,14 @@ void AndroidLogDownloadFromNode::OnDeviceConnectedFn(void * context, Messaging::
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(Controller, "Log Download failure : %" CHIP_ERROR_FORMAT, err.Format());
-        self->FinishLogDownloadFromNode(err);
+        FinishLogDownloadFromNode(context, err);
     }
 }
 
 void AndroidLogDownloadFromNode::OnDeviceConnectionFailureFn(void * context, const ScopedNodeId & peerId, CHIP_ERROR err)
 {
     ChipLogProgress(Controller, "OnDeviceConnectionFailureFn: %" CHIP_ERROR_FORMAT, err.Format());
-
-    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
-    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Device connected failure callback with null context. Ignoring"));
-
-    self->FinishLogDownloadFromNode(err);
+    FinishLogDownloadFromNode(context, err);
 }
 
 void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context,
@@ -162,25 +158,25 @@ void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context,
     {
         CHIP_ERROR err = CHIP_NO_ERROR;
         self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, data.logContent, &err);
-        self->FinishLogDownloadFromNode(err);
+        FinishLogDownloadFromNode(context, err);
     }
     else if (data.status == StatusEnum::kNoLogs)
     {
         CHIP_ERROR err = CHIP_NO_ERROR;
         self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), &err);
-        self->FinishLogDownloadFromNode(err);
+        FinishLogDownloadFromNode(context, err);
     }
     else if (data.status == StatusEnum::kBusy)
     {
-        self->FinishLogDownloadFromNode(CHIP_ERROR_BUSY);
+        FinishLogDownloadFromNode(context, CHIP_ERROR_BUSY);
     }
     else if (data.status == StatusEnum::kDenied)
     {
-        self->FinishLogDownloadFromNode(CHIP_ERROR_ACCESS_DENIED);
+        FinishLogDownloadFromNode(context, CHIP_ERROR_ACCESS_DENIED);
     }
     else
     {
-        self->FinishLogDownloadFromNode(CHIP_ERROR_INVALID_DATA_LIST);
+        FinishLogDownloadFromNode(context, CHIP_ERROR_INVALID_DATA_LIST);
     }
 }
 
@@ -191,48 +187,60 @@ void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
 
-    self->FinishLogDownloadFromNode(err);
+    FinishLogDownloadFromNode(context, err);
 }
 
-void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
+void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(void * context, CHIP_ERROR err)
 {
-    CHIP_ERROR jniErr = CHIP_NO_ERROR;
-    if (mBdxReceiver != nullptr)
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Finish Log Download with null context. Ignoring"));
+
+    if (self->mBdxReceiver != nullptr)
     {
-        if (mTimeout > 0)
+        if (self->mTimeout > 0 && err != CHIP_ERROR_TIMEOUT)
         {
-            mBdxReceiver->CancelBDXTransferTimeout();
+            self->mBdxReceiver->CancelBDXTransferTimeout();
         }
-        delete mBdxReceiver;
-        mBdxReceiver = nullptr;
+        delete self->mBdxReceiver;
+        self->mBdxReceiver = nullptr;
     }
 
-    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    CHIP_ERROR jniErr = CHIP_NO_ERROR;
+    JNIEnv * env      = JniReferences::GetInstance().GetEnvForCurrentThread();
     JniLocalReferenceScope scope(env);
 
+    jobject jCallback   = self->mJavaCallback.ObjectRef();
+    jint jFabricIndex   = self->mController->GetFabricIndex();
+    jlong jremoteNodeId = self->mRemoteNodeId;
+
+    VerifyOrExit(env != nullptr, ChipLogError(Controller, "Could not get JNIEnv for current thread"));
+
     if (err == CHIP_NO_ERROR)
     {
         ChipLogProgress(Controller, "Log Download succeeded.");
         jmethodID onSuccessMethod;
         // Java method signature : boolean onSuccess(int fabricIndex, long nodeId)
-        jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onSuccess", "(IJ)V", &onSuccessMethod);
+        jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onSuccess", "(IJ)V", &onSuccessMethod);
 
-        VerifyOrReturn(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onSuccess method"));
+        VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onSuccess method"));
 
-        env->CallVoidMethod(mJavaCallback.ObjectRef(), onSuccessMethod, static_cast<jint>(mController->GetFabricIndex()),
-                            static_cast<jlong>(mRemoteNodeId));
-        return;
+        env->CallVoidMethod(jCallback, onSuccessMethod, jFabricIndex, jremoteNodeId);
     }
+    else
+    {
+        ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
 
-    ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
+        jmethodID onErrorMethod;
+        // Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)
+        jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onError", "(IJJ)V", &onErrorMethod);
+        VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));
 
-    jmethodID onErrorMethod;
-    // Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)
-    jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &onErrorMethod);
-    VerifyOrReturn(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));
+        env->CallVoidMethod(jCallback, onErrorMethod, jFabricIndex, jremoteNodeId, static_cast<jlong>(err.AsInteger()));
+    }
 
-    env->CallVoidMethod(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()),
-                        static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
+exit:
+    // Finish this function, this object will be deleted.
+    delete self;
 }
 
 void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,
@@ -277,7 +285,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferSuccessCallback(void * context, Fa
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
 
-    self->FinishLogDownloadFromNode(CHIP_NO_ERROR);
+    FinishLogDownloadFromNode(context, CHIP_NO_ERROR);
 }
 
 void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,
@@ -288,7 +296,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, Fa
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
 
-    self->FinishLogDownloadFromNode(status);
+    FinishLogDownloadFromNode(context, status);
 }
 } // namespace Controller
 } // namespace chip
diff --git a/src/controller/java/AndroidLogDownloadFromNode.h b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -54,6 +54,8 @@ class AndroidLogDownloadFromNode
     AndroidLogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent,
                                uint16_t timeout, jobject javaCallback);
 
+    ~AndroidLogDownloadFromNode() {}
+
     DeviceController * mController = nullptr;
 
     chip::Callback::Callback<OnDeviceConnected> mOnDeviceConnectedCallback;
@@ -76,7 +78,7 @@ class AndroidLogDownloadFromNode
     CHIP_ERROR SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
     void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
                             CHIP_ERROR * errInfoOnFailure);
-    void FinishLogDownloadFromNode(CHIP_ERROR err);
+    static void FinishLogDownloadFromNode(void * context, CHIP_ERROR err);
 
     static void OnDeviceConnectedFn(void * context, Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
     static void OnDeviceConnectionFailureFn(void * context, const ScopedNodeId & peerId, CHIP_ERROR error);
diff --git a/src/lib/support/BufferWriter.cpp b/src/lib/support/BufferWriter.cpp
@@ -30,7 +30,7 @@ BufferWriter & BufferWriter::Put(const void * buf, size_t len)
 {
     size_t available = Available();
 
-    if (available > 0)
+    if (available > 0 && len > 0)
     {
         memmove(mBuf + mNeeded, buf, available < len ? available : len);
     }
diff --git a/src/platform/ESP32/CHIPDevicePlatformConfig.h b/src/platform/ESP32/CHIPDevicePlatformConfig.h
@@ -121,7 +121,13 @@
 #define CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX
 #define CHIP_DEVICE_CONFIG_CHIPOBLE_SINGLE_CONNECTION CONFIG_CHIPOBLE_SINGLE_CONNECTION
 #define CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART
-#define CHIP_DEVICE_CONFIG_ENABLE_TEST_SETUP_PARAMS CONFIG_ENABLE_TEST_SETUP_PARAMS
+
+#ifdef CONFIG_ENABLE_TEST_SETUP_PARAMS
+#define CHIP_DEVICE_CONFIG_ENABLE_TEST_SETUP_PARAMS 1
+#else
+#define CHIP_DEVICE_CONFIG_ENABLE_TEST_SETUP_PARAMS 0
+#endif // CONFIG_ENABLE_TEST_SETUP_PARAMS
+
 #define CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER CONFIG_USE_TEST_SERIAL_NUMBER
 
 #ifdef CONFIG_ENABLE_THREAD_TELEMETRY
diff --git a/src/platform/silabs/wifi/SiWx/WifiInterface.cpp b/src/platform/silabs/wifi/SiWx/WifiInterface.cpp
@@ -77,9 +77,9 @@ extern "C" {
 #include "sl_si91x_power_manager.h"
 #endif // CHIP_CONFIG_ENABLE_ICD_SERVER && SLI_SI91X_MCU_INTERFACE
 
-// Temmporary work-around for wifi-init failure in ACX modules with WiseConnect v3.3.3. This can be removed after integrating with
-// WiseConnect v3.4.0
-#if (SL_SI91X_ACX_MODULE == 1)
+// TODO : Temporary work-around for wifi-init failure in 917NCP and 917SOC ACX module boards.
+// Can be removed after Wiseconnect fixes region code for all ACX module boards.
+#if (SL_SI91X_ACX_MODULE == 1) || defined(EXP_BOARD)
 #define REGION_CODE IGNORE_REGION
 #else
 #define REGION_CODE US
diff --git a/src/transport/SessionManager.cpp b/src/transport/SessionManager.cpp
@@ -1297,15 +1297,15 @@ Optional<SessionHandle> SessionManager::FindSecureSessionForNode(ScopedNodeId pe
             {
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT
                 // Set up a TCP transport based session as standby
-                if ((tcpSession == nullptr || tcpSession->GetLastActivityTime() < session->GetLastActivityTime()) &&
+                if ((tcpSession == nullptr || tcpSession->GetLastPeerActivityTime() < session->GetLastPeerActivityTime()) &&
                     session->GetTCPConnection() != nullptr)
                 {
                     tcpSession = session;
                 }
 #endif // INET_CONFIG_ENABLE_TCP_ENDPOINT
             }
 
-            if ((mrpSession == nullptr) || (mrpSession->GetLastActivityTime() < session->GetLastActivityTime()))
+            if ((mrpSession == nullptr) || (mrpSession->GetLastPeerActivityTime() < session->GetLastPeerActivityTime()))
             {
                 mrpSession = session;
             }
diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp
@@ -998,19 +998,19 @@ TEST_F(TestSessionManager, TestFindSecureSessionForNode)
     CHIP_ERROR err = sessionManager.InjectCaseSessionWithTestKey(aliceToBobSession, 2, 1, aliceNodeId, bobNodeId, aliceFabricIndex,
                                                                  peer, CryptoContext::SessionRole::kInitiator);
     EXPECT_EQ(err, CHIP_NO_ERROR);
-    aliceToBobSession->AsSecureSession()->MarkActive();
+    aliceToBobSession->AsSecureSession()->MarkActiveRx();
 
     SessionHolder newAliceToBobSession;
     err = sessionManager.InjectCaseSessionWithTestKey(newAliceToBobSession, 3, 4, aliceNodeId, bobNodeId, aliceFabricIndex, peer,
                                                       CryptoContext::SessionRole::kInitiator);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    while (System::SystemClock().GetMonotonicTimestamp() <= aliceToBobSession->AsSecureSession()->GetLastActivityTime())
+    while (System::SystemClock().GetMonotonicTimestamp() <= aliceToBobSession->AsSecureSession()->GetLastPeerActivityTime())
     {
         // Wait for the clock to advance so the new session is
         // more-recently-active.
     }
-    newAliceToBobSession->AsSecureSession()->MarkActive();
+    newAliceToBobSession->AsSecureSession()->MarkActiveRx();
 
     auto foundSession = sessionManager.FindSecureSessionForNode(ScopedNodeId(bobNodeId, aliceFabricIndex),
                                                                 MakeOptional(SecureSession::Type::kCASE));

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ import com.matter.controller.commands.pairing.PairingCommand`
`9`	`9`	`import com.matter.controller.commands.pairing.PairingModeType`
`10`	`10`	`import com.matter.controller.commands.pairing.PairingNetworkType`
`11`	`11`	`import java.io.File`
	`12`	`+import java.util.concurrent.TimeUnit`
`12`	`13`	`import java.util.logging.Level`
`13`	`14`	`import java.util.logging.Logger`
`14`	`15`
`@@ -85,12 +86,19 @@ class PairOnNetworkLongDownloadLogCommand(`
`85`	`86`	`)`
`86`	`87`	`logger.log(Level.INFO, "Waiting response : ${getTimeoutMillis()}")`
`87`	`88`	`waitCompleteMs(getTimeoutMillis())`
	`89`	`+ // For waiting both side terminating.`
	`90`	`+ try {`
	`91`	`+ TimeUnit.SECONDS.sleep(WAIT_FOR_TERMINATE)`
	`92`	`+ } catch (e: InterruptedException) {`
	`93`	`+ throw RuntimeException(e)`
	`94`	`+ }`
`88`	`95`	`}`
`89`	`96`
`90`	`97`	`companion object {`
`91`	`98`	`private val logger = Logger.getLogger(PairOnNetworkLongDownloadLogCommand::class.java.name)`
`92`	`99`
`93`	`100`	`private const val MATTER_PORT = 5540`
`94`	`101`	`private const val MS_TO_SEC = 1000`
	`102`	`+ private const val WAIT_FOR_TERMINATE = 1L`
`95`	`103`	`}`
`96`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-96 : [Telink] Update Docker image (Zephyr update)`
	`1`	`+97 : [Telink] Update Docker image (Zephyr update)`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan`
`99`	`99`	`if (err != CHIP_NO_ERROR)`
`100`	`100`	`{`
`101`	`101`	`ChipLogError(Controller, "Make BDX URI failure : %" CHIP_ERROR_FORMAT, err.Format());`
`102`		`- FinishLogDownloadFromNode(err);`
	`102`	`+ FinishLogDownloadFromNode(static_cast<void *>(this), err);`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`mBdxReceiver =`
`@@ -132,18 +132,14 @@ void AndroidLogDownloadFromNode::OnDeviceConnectedFn(void * context, Messaging::`
`132`	`132`	`if (err != CHIP_NO_ERROR)`
`133`	`133`	`{`
`134`	`134`	`ChipLogError(Controller, "Log Download failure : %" CHIP_ERROR_FORMAT, err.Format());`
`135`		`- self->FinishLogDownloadFromNode(err);`
	`135`	`+ FinishLogDownloadFromNode(context, err);`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`void AndroidLogDownloadFromNode::OnDeviceConnectionFailureFn(void * context, const ScopedNodeId & peerId, CHIP_ERROR err)`
`140`	`140`	`{`
`141`	`141`	`ChipLogProgress(Controller, "OnDeviceConnectionFailureFn: %" CHIP_ERROR_FORMAT, err.Format());`
`142`		`-`
`143`		`- auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`144`		`- VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Device connected failure callback with null context. Ignoring"));`
`145`		`-`
`146`		`- self->FinishLogDownloadFromNode(err);`
	`142`	`+ FinishLogDownloadFromNode(context, err);`
`147`	`143`	`}`
`148`	`144`
`149`	`145`	`void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context,`
`@@ -162,25 +158,25 @@ void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context,`
`162`	`158`	`{`
`163`	`159`	`CHIP_ERROR err = CHIP_NO_ERROR;`
`164`	`160`	`self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, data.logContent, &err);`
`165`		`- self->FinishLogDownloadFromNode(err);`
	`161`	`+ FinishLogDownloadFromNode(context, err);`
`166`	`162`	`}`
`167`	`163`	`else if (data.status == StatusEnum::kNoLogs)`
`168`	`164`	`{`
`169`	`165`	`CHIP_ERROR err = CHIP_NO_ERROR;`
`170`	`166`	`self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), &err);`
`171`		`- self->FinishLogDownloadFromNode(err);`
	`167`	`+ FinishLogDownloadFromNode(context, err);`
`172`	`168`	`}`
`173`	`169`	`else if (data.status == StatusEnum::kBusy)`
`174`	`170`	`{`
`175`		`- self->FinishLogDownloadFromNode(CHIP_ERROR_BUSY);`
	`171`	`+ FinishLogDownloadFromNode(context, CHIP_ERROR_BUSY);`
`176`	`172`	`}`
`177`	`173`	`else if (data.status == StatusEnum::kDenied)`
`178`	`174`	`{`
`179`		`- self->FinishLogDownloadFromNode(CHIP_ERROR_ACCESS_DENIED);`
	`175`	`+ FinishLogDownloadFromNode(context, CHIP_ERROR_ACCESS_DENIED);`
`180`	`176`	`}`
`181`	`177`	`else`
`182`	`178`	`{`
`183`		`- self->FinishLogDownloadFromNode(CHIP_ERROR_INVALID_DATA_LIST);`
	`179`	`+ FinishLogDownloadFromNode(context, CHIP_ERROR_INVALID_DATA_LIST);`
`184`	`180`	`}`
`185`	`181`	`}`
`186`	`182`
`@@ -191,48 +187,60 @@ void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err`
`191`	`187`	`auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`192`	`188`	`VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));`
`193`	`189`
`194`		`- self->FinishLogDownloadFromNode(err);`
	`190`	`+ FinishLogDownloadFromNode(context, err);`
`195`	`191`	`}`
`196`	`192`
`197`		`-void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)`
	`193`	`+void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(void * context, CHIP_ERROR err)`
`198`	`194`	`{`
`199`		`- CHIP_ERROR jniErr = CHIP_NO_ERROR;`
`200`		`- if (mBdxReceiver != nullptr)`
	`195`	`+ auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
	`196`	`+ VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Finish Log Download with null context. Ignoring"));`
	`197`	`+`
	`198`	`+ if (self->mBdxReceiver != nullptr)`
`201`	`199`	`{`
`202`		`- if (mTimeout > 0)`
	`200`	`+ if (self->mTimeout > 0 && err != CHIP_ERROR_TIMEOUT)`
`203`	`201`	`{`
`204`		`- mBdxReceiver->CancelBDXTransferTimeout();`
	`202`	`+ self->mBdxReceiver->CancelBDXTransferTimeout();`
`205`	`203`	`}`
`206`		`- delete mBdxReceiver;`
`207`		`- mBdxReceiver = nullptr;`
	`204`	`+ delete self->mBdxReceiver;`
	`205`	`+ self->mBdxReceiver = nullptr;`
`208`	`206`	`}`
`209`	`207`
`210`		`- JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();`
	`208`	`+ CHIP_ERROR jniErr = CHIP_NO_ERROR;`
	`209`	`+ JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();`
`211`	`210`	`JniLocalReferenceScope scope(env);`
`212`	`211`
	`212`	`+ jobject jCallback = self->mJavaCallback.ObjectRef();`
	`213`	`+ jint jFabricIndex = self->mController->GetFabricIndex();`
	`214`	`+ jlong jremoteNodeId = self->mRemoteNodeId;`
	`215`	`+`
	`216`	`+ VerifyOrExit(env != nullptr, ChipLogError(Controller, "Could not get JNIEnv for current thread"));`
	`217`	`+`
`213`	`218`	`if (err == CHIP_NO_ERROR)`
`214`	`219`	`{`
`215`	`220`	`ChipLogProgress(Controller, "Log Download succeeded.");`
`216`	`221`	`jmethodID onSuccessMethod;`
`217`	`222`	`// Java method signature : boolean onSuccess(int fabricIndex, long nodeId)`
`218`		`- jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onSuccess", "(IJ)V", &onSuccessMethod);`
	`223`	`+ jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onSuccess", "(IJ)V", &onSuccessMethod);`
`219`	`224`
`220`		`- VerifyOrReturn(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onSuccess method"));`
	`225`	`+ VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onSuccess method"));`
`221`	`226`
`222`		`- env->CallVoidMethod(mJavaCallback.ObjectRef(), onSuccessMethod, static_cast<jint>(mController->GetFabricIndex()),`
`223`		`- static_cast<jlong>(mRemoteNodeId));`
`224`		`- return;`
	`227`	`+ env->CallVoidMethod(jCallback, onSuccessMethod, jFabricIndex, jremoteNodeId);`
`225`	`228`	`}`
	`229`	`+ else`
	`230`	`+ {`
	`231`	`+ ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());`
`226`	`232`
`227`		`- ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());`
	`233`	`+ jmethodID onErrorMethod;`
	`234`	`+ // Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)`
	`235`	`+ jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onError", "(IJJ)V", &onErrorMethod);`
	`236`	`+ VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));`
`228`	`237`
`229`		`- jmethodID onErrorMethod;`
`230`		`- // Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)`
`231`		`- jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &onErrorMethod);`
`232`		`- VerifyOrReturn(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));`
	`238`	`+ env->CallVoidMethod(jCallback, onErrorMethod, jFabricIndex, jremoteNodeId, static_cast<jlong>(err.AsInteger()));`
	`239`	`+ }`
`233`	`240`
`234`		`- env->CallVoidMethod(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()),`
`235`		`- static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));`
	`241`	`+exit:`
	`242`	`+ // Finish this function, this object will be deleted.`
	`243`	`+ delete self;`
`236`	`244`	`}`
`237`	`245`
`238`	`246`	`void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,`
`@@ -277,7 +285,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferSuccessCallback(void * context, Fa`
`277`	`285`	`auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`278`	`286`	`VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));`
`279`	`287`
`280`		`- self->FinishLogDownloadFromNode(CHIP_NO_ERROR);`
	`288`	`+ FinishLogDownloadFromNode(context, CHIP_NO_ERROR);`
`281`	`289`	`}`
`282`	`290`
`283`	`291`	`void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,`
`@@ -288,7 +296,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, Fa`
`288`	`296`	`auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`289`	`297`	`VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));`
`290`	`298`
`291`		`- self->FinishLogDownloadFromNode(status);`
	`299`	`+ FinishLogDownloadFromNode(context, status);`
`292`	`300`	`}`
`293`	`301`	`} // namespace Controller`
`294`	`302`	`} // namespace chip`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ BufferWriter & BufferWriter::Put(const void * buf, size_t len)`
`30`	`30`	`{`
`31`	`31`	`size_t available = Available();`
`32`	`32`
`33`		`- if (available > 0)`
	`33`	`+ if (available > 0 && len > 0)`
`34`	`34`	`{`
`35`	`35`	`memmove(mBuf + mNeeded, buf, available < len ? available : len);`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1297,15 +1297,15 @@ Optional<SessionHandle> SessionManager::FindSecureSessionForNode(ScopedNodeId pe`
`1297`	`1297`	`{`
`1298`	`1298`	`#if INET_CONFIG_ENABLE_TCP_ENDPOINT`
`1299`	`1299`	`// Set up a TCP transport based session as standby`
`1300`		`- if ((tcpSession == nullptr \|\| tcpSession->GetLastActivityTime() < session->GetLastActivityTime()) &&`
	`1300`	`+ if ((tcpSession == nullptr \|\| tcpSession->GetLastPeerActivityTime() < session->GetLastPeerActivityTime()) &&`
`1301`	`1301`	`session->GetTCPConnection() != nullptr)`
`1302`	`1302`	`{`
`1303`	`1303`	`tcpSession = session;`
`1304`	`1304`	`}`
`1305`	`1305`	`#endif // INET_CONFIG_ENABLE_TCP_ENDPOINT`
`1306`	`1306`	`}`
`1307`	`1307`
`1308`		`- if ((mrpSession == nullptr) \|\| (mrpSession->GetLastActivityTime() < session->GetLastActivityTime()))`
	`1308`	`+ if ((mrpSession == nullptr) \|\| (mrpSession->GetLastPeerActivityTime() < session->GetLastPeerActivityTime()))`
`1309`	`1309`	`{`
`1310`	`1310`	`mrpSession = session;`
`1311`	`1311`	`}`