Add terminate sleep time

joonhaengHeo · joonhaengHeo · commit 570a31bb07ec · 2024-12-20T16:18:07.000+09:00
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/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,53 +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, CHIP_ERROR_INCORRECT_STATE);
+
     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);
 
         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));
+        env->CallVoidMethod(jCallback, onSuccessMethod, jFabricIndex, jremoteNodeId);
     }
     else
     {
         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, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &onErrorMethod);
+        jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onError", "(IJJ)V", &onErrorMethod);
         VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));
 
-        env->CallVoidMethod(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()),
-                            static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
+        env->CallVoidMethod(jCallback, onErrorMethod, jFabricIndex, jremoteNodeId, static_cast<jlong>(err.AsInteger()));
     }
 
 exit:
     // Finish this function, this object will be deleted.
-    delete this;
+    delete self;
 }
 
 void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,
@@ -282,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,
@@ -293,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);

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
`@@ -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,53 +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, CHIP_ERROR_INCORRECT_STATE);`
	`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`	`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));`
	`227`	`+ env->CallVoidMethod(jCallback, onSuccessMethod, jFabricIndex, jremoteNodeId);`
`224`	`228`	`}`
`225`	`229`	`else`
`226`	`230`	`{`
`227`	`231`	`ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());`
`228`	`232`
`229`	`233`	`jmethodID onErrorMethod;`
`230`	`234`	`// Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)`
`231`		`- jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &onErrorMethod);`
	`235`	`+ jniErr = JniReferences::GetInstance().FindMethod(env, jCallback, "onError", "(IJJ)V", &onErrorMethod);`
`232`	`236`	`VerifyOrExit(jniErr == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onError method"));`
`233`	`237`
`234`		`- env->CallVoidMethod(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()),`
`235`		`- static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));`
	`238`	`+ env->CallVoidMethod(jCallback, onErrorMethod, jFabricIndex, jremoteNodeId, static_cast<jlong>(err.AsInteger()));`
`236`	`239`	`}`
`237`	`240`
`238`	`241`	`exit:`
`239`	`242`	`// Finish this function, this object will be deleted.`
`240`		`- delete this;`
	`243`	`+ delete self;`
`241`	`244`	`}`
`242`	`245`
`243`	`246`	`void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,`
`@@ -282,7 +285,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferSuccessCallback(void * context, Fa`
`282`	`285`	`auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`283`	`286`	`VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));`
`284`	`287`
`285`		`- self->FinishLogDownloadFromNode(CHIP_NO_ERROR);`
	`288`	`+ FinishLogDownloadFromNode(context, CHIP_NO_ERROR);`
`286`	`289`	`}`
`287`	`290`
`288`	`291`	`void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,`
`@@ -293,7 +296,7 @@ void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, Fa`
`293`	`296`	`auto * self = static_cast<AndroidLogDownloadFromNode *>(context);`
`294`	`297`	`VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));`
`295`	`298`
`296`		`- self->FinishLogDownloadFromNode(status);`
	`299`	`+ FinishLogDownloadFromNode(context, status);`
`297`	`300`	`}`
`298`	`301`	`} // namespace Controller`
`299`	`302`	`} // namespace chip`