From b915dbdfa22651eca5f8404cf182a77ab40a32f8 Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Thu, 21 Nov 2024 18:44:07 +0900
Subject: [PATCH 01/11] Implement Android DiagnosticLog

---
 .../CHIPTool/app/src/main/AndroidManifest.xml |   9 +
 .../chip/chiptool/SelectActionFragment.kt     |   5 +
 .../clusterclient/DiagnosticLogFragment.kt    | 139 ++++++++++
 .../res/layout/diagnostic_log_fragment.xml    |  75 +++++
 .../res/layout/select_action_fragment.xml     |   8 +
 .../app/src/main/res/values/strings.xml       |   4 +
 .../app/src/main/res/xml/file_paths.xml       |   4 +
 examples/java-matter-controller/BUILD.gn      |   1 +
 .../java/src/com/matter/controller/Main.kt    |  11 +
 .../commands/bdx/DownloadLogCommand.kt        |  68 +++++
 .../java/AndroidLogDownloadFromNode.cpp       | 260 ++++++++++++++++++
 .../java/AndroidLogDownloadFromNode.h         |  87 ++++++
 src/controller/java/BUILD.gn                  |   6 +
 .../java/BdxDiagnosticLogsReceiver.cpp        | 102 +++++++
 .../java/BdxDiagnosticLogsReceiver.h          |  60 ++++
 .../java/CHIPDeviceController-JNI.cpp         |  18 ++
 .../ChipDeviceController.java                 |   6 +
 .../devicecontroller/DiagnosticLogType.java   |  52 ++++
 .../devicecontroller/DownloadLogCallback.java |  26 ++
 .../bdx/BdxTransferDiagnosticLog.cpp          |   2 +-
 src/protocols/bdx/BdxTransferServerDelegate.h |  12 +-
 src/protocols/bdx/BdxUri.h                    |   2 +
 22 files changed, 955 insertions(+), 2 deletions(-)
 create mode 100644 examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
 create mode 100644 examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
 create mode 100644 examples/android/CHIPTool/app/src/main/res/xml/file_paths.xml
 create mode 100644 examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
 create mode 100644 src/controller/java/AndroidLogDownloadFromNode.cpp
 create mode 100644 src/controller/java/AndroidLogDownloadFromNode.h
 create mode 100644 src/controller/java/BdxDiagnosticLogsReceiver.cpp
 create mode 100644 src/controller/java/BdxDiagnosticLogsReceiver.h
 create mode 100644 src/controller/java/src/chip/devicecontroller/DiagnosticLogType.java
 create mode 100644 src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java

diff --git a/examples/android/CHIPTool/app/src/main/AndroidManifest.xml b/examples/android/CHIPTool/app/src/main/AndroidManifest.xml
index 0526dc5a78160d..efd089817efe68 100644
--- a/examples/android/CHIPTool/app/src/main/AndroidManifest.xml
+++ b/examples/android/CHIPTool/app/src/main/AndroidManifest.xml
@@ -46,6 +46,15 @@
                 <data android:scheme="mt" android:host="modelinfo" /> <!-- Process Redirect URIs -->
             </intent-filter>
         </activity>
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.provider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
     </application>
 
     <queries>
diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/SelectActionFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/SelectActionFragment.kt
index 69bfdc109912c9..fb8141e72d33a8 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/SelectActionFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/SelectActionFragment.kt
@@ -72,6 +72,7 @@ class SelectActionFragment : Fragment() {
     binding.provisionCustomFlowBtn.setOnClickListener { handleProvisionCustomFlowClicked() }
     binding.wildcardBtn.setOnClickListener { handleWildcardClicked() }
     binding.unpairDeviceBtn.setOnClickListener { handleUnpairDeviceClicked() }
+    binding.diagnosticLogBtn.setOnClickListener { handleDiagnosticLogClicked() }
     binding.groupSettingBtn.setOnClickListener { handleGroupSettingClicked() }
     binding.otaProviderBtn.setOnClickListener { handleOTAProviderClicked() }
     binding.icdBtn.setOnClickListener { handleICDClicked() }
@@ -225,6 +226,10 @@ class SelectActionFragment : Fragment() {
     showFragment(OtaProviderClientFragment.newInstance())
   }
 
+  private fun handleDiagnosticLogClicked() {
+    showFragment(DiagnosticLogFragment.newInstance())
+  }
+
   /** Notifies listener of provision-WiFi-credentials button click. */
   private fun handleProvisionWiFiCredentialsClicked() {
     getCallback()?.setNetworkType(ProvisionNetworkType.WIFI)
diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
new file mode 100644
index 00000000000000..8f0622e4a76424
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -0,0 +1,139 @@
+package com.google.chip.chiptool.clusterclient
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.os.Environment
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ArrayAdapter
+import androidx.core.content.FileProvider
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.lifecycleScope
+import chip.devicecontroller.ChipDeviceController
+import chip.devicecontroller.DiagnosticLogType
+import chip.devicecontroller.DownloadLogCallback
+import com.google.chip.chiptool.ChipClient
+import com.google.chip.chiptool.R
+import com.google.chip.chiptool.databinding.DiagnosticLogFragmentBinding
+import kotlinx.coroutines.*
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+
+class DiagnosticLogFragment : Fragment() {
+  private val deviceController: ChipDeviceController
+    get() = ChipClient.getDeviceController(requireContext())
+
+  private lateinit var scope: CoroutineScope
+
+  private lateinit var addressUpdateFragment: AddressUpdateFragment
+
+  private var _binding: DiagnosticLogFragmentBinding? = null
+  private val binding
+    get() = _binding!!
+
+  private val timeout: Int
+    get() = binding.timeoutEd.text.toString().toUIntOrNull()?.toInt() ?: 0
+
+  private val diagnosticLogTypeList = DiagnosticLogType.values()
+  private val diagnosticLogType: DiagnosticLogType
+    get() = diagnosticLogTypeList[binding.diagnosticTypeSp.selectedItemPosition]
+
+  private var mDownloadFile: File? = null
+  private var mDownloadFileOutputStream: FileOutputStream? = null
+
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?
+  ): View {
+    _binding = DiagnosticLogFragmentBinding.inflate(inflater, container, false)
+    scope = viewLifecycleOwner.lifecycleScope
+
+    addressUpdateFragment =
+      childFragmentManager.findFragmentById(R.id.addressUpdateFragment) as AddressUpdateFragment
+
+    binding.getDiagnosticLogBtn.setOnClickListener { scope.launch { getDiagnosticLogClick() } }
+
+    binding.diagnosticTypeSp.adapter =
+      ArrayAdapter(requireContext(), android.R.layout.simple_spinner_dropdown_item, diagnosticLogTypeList)
+
+    return binding.root
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+    _binding = null
+  }
+
+  inner class ChipDownloadLogCallback : DownloadLogCallback {
+      override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+        Log.d(TAG, "onError: $fabricIndex, ${nodeId.toULong()}, $errorCode")
+      }
+
+      override fun onTransferData(
+        fabricIndex: Int,
+        nodeId: Long,
+        data: ByteArray,
+        isEof: Boolean
+      ): Boolean {
+          Log.d(TAG, "onTransferData : ${data.size}, $isEof")
+        if (mDownloadFileOutputStream == null || mDownloadFile == null) {
+            Log.d(TAG, "mDownloadFileOutputStream or mDownloadFile is null")
+            return false
+        }
+        try {
+            mDownloadFileOutputStream!!.write(data)
+            if (isEof) {
+                mDownloadFileOutputStream!!.flush()
+                showNotification(mDownloadFile!!)
+            }
+        } catch (e: IOException) {
+            Log.d(TAG, "IOException", e)
+            return false
+        }
+        return true
+      }
+  }
+
+  private fun getDiagnosticLogClick() {
+    mDownloadFile = createLogFile(deviceController.fabricIndex.toUInt(), addressUpdateFragment.deviceId.toULong(), diagnosticLogType)
+    mDownloadFileOutputStream = FileOutputStream(mDownloadFile)
+    deviceController.downloadLogFromNode(addressUpdateFragment.deviceId, diagnosticLogType, timeout, ChipDownloadLogCallback())
+  }
+
+  private fun isExternalStorageWritable(): Boolean {
+    return Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED
+  }
+
+  private fun createLogFile(fabricIndex: UInt, nodeId: ULong, type:DiagnosticLogType) : File? {
+    if (!isExternalStorageWritable()) {
+      return null
+    }
+    val now = System.currentTimeMillis()
+    val fileName = "${type}_${fabricIndex}_${nodeId}_$now.txt"
+    return File(requireContext().getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS), fileName)
+  }
+
+  private fun showNotification(file: File) {
+        val intent = Intent(Intent.ACTION_VIEW).apply {
+            setDataAndType(getFileUri(file), "text/plain")
+            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+
+      requireActivity().startActivity(intent)
+    }
+
+    private fun getFileUri(file: File): Uri {
+        return FileProvider.getUriForFile(requireContext(), "${requireContext().packageName}.provider", file)
+    }
+
+  companion object {
+    private const val TAG = "DiagnosticLogFragment"
+
+    fun newInstance(): DiagnosticLogFragment = DiagnosticLogFragment()
+  }
+}
diff --git a/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml b/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
new file mode 100644
index 00000000000000..6233bee067b992
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    xmlns:app="http://schemas.android.com/apk/res-auto">
+
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/addressUpdateFragment"
+        android:name="com.google.chip.chiptool.clusterclient.AddressUpdateFragment"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"/>
+
+    <TextView
+        android:id="@+id/titleDiagnosticType"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/diagnostic_log_type_title_text"
+        android:textSize="16sp"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/addressUpdateFragment" />
+
+    <Spinner
+        android:id="@+id/diagnosticTypeSp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:inputType="text"
+        android:spinnerMode="dropdown"
+        android:textSize="16sp"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/titleDiagnosticType" />
+
+    <EditText
+        android:id="@+id/timeoutTv"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentStart="true"
+        android:layout_marginStart="8dp"
+        android:layout_marginEnd="8dp"
+        android:enabled="false"
+        android:padding="8dp"
+        android:text="@string/diagnostic_log_timeout_title_text"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toStartOf="@id/timeoutEd"
+        app:layout_constraintTop_toBottomOf="@id/diagnosticTypeSp"
+        android:textSize="16sp" />
+
+    <EditText
+        android:id="@+id/timeoutEd"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="8dp"
+        android:layout_marginEnd="8dp"
+        android:autofillHints="@string/diagnostic_log_timeout_title_text"
+        android:inputType="numberDecimal"
+        android:padding="8dp"
+        app:layout_constraintStart_toEndOf="@id/timeoutTv"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/diagnosticTypeSp"
+        android:textSize="16sp" />
+
+    <Button
+        android:id="@+id/getDiagnosticLogBtn"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_margin="10dp"
+        android:text="@string/diagnostic_log_btn_text"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/timeoutTv"/>
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/examples/android/CHIPTool/app/src/main/res/layout/select_action_fragment.xml b/examples/android/CHIPTool/app/src/main/res/layout/select_action_fragment.xml
index 5824e8061a4e03..db999600999741 100644
--- a/examples/android/CHIPTool/app/src/main/res/layout/select_action_fragment.xml
+++ b/examples/android/CHIPTool/app/src/main/res/layout/select_action_fragment.xml
@@ -112,6 +112,14 @@
             android:layout_marginTop="8dp"
             android:text="@string/unpair_device_btn_text" />
 
+        <Button
+            android:id="@+id/diagnosticLogBtn"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="8dp"
+            android:layout_marginTop="8dp"
+            android:text="@string/diagnostic_log_btn_text" />
+
         <Button
             android:id="@+id/groupSettingBtn"
             android:layout_width="wrap_content"
diff --git a/examples/android/CHIPTool/app/src/main/res/values/strings.xml b/examples/android/CHIPTool/app/src/main/res/values/strings.xml
index 75112ffd9bad73..d056c262fd9e70 100644
--- a/examples/android/CHIPTool/app/src/main/res/values/strings.xml
+++ b/examples/android/CHIPTool/app/src/main/res/values/strings.xml
@@ -232,6 +232,10 @@
 
     <string name="unpair_device_btn_text">Unpair</string>
 
+    <string name="diagnostic_log_btn_text">Get Diagnostic Log</string>
+    <string name="diagnostic_log_type_title_text">Log Type</string>
+    <string name="diagnostic_log_timeout_title_text">Timeout(Sec)</string>
+
     <string name="group_setting_btn_text">Group Setting</string>
     <string name="group_setting_group_text">Group :</string>
     <string name="group_setting_key_text">Key :</string>
diff --git a/examples/android/CHIPTool/app/src/main/res/xml/file_paths.xml b/examples/android/CHIPTool/app/src/main/res/xml/file_paths.xml
new file mode 100644
index 00000000000000..4aef315b769fd5
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/res/xml/file_paths.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <external-files-path name="external_files" path="." />
+</paths>
\ No newline at end of file
diff --git a/examples/java-matter-controller/BUILD.gn b/examples/java-matter-controller/BUILD.gn
index 76acd190eade16..9cc452e75afeaf 100644
--- a/examples/java-matter-controller/BUILD.gn
+++ b/examples/java-matter-controller/BUILD.gn
@@ -29,6 +29,7 @@ kotlin_binary("java-matter-controller") {
 
   sources = [
     "java/src/com/matter/controller/Main.kt",
+    "java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt",
     "java/src/com/matter/controller/commands/common/Argument.kt",
     "java/src/com/matter/controller/commands/common/ArgumentType.kt",
     "java/src/com/matter/controller/commands/common/Command.kt",
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/Main.kt b/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
index a1a66a8420b196..1ed725ba08d5df 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
@@ -19,6 +19,7 @@ package com.matter.controller
 
 import chip.devicecontroller.ChipDeviceController
 import chip.devicecontroller.ControllerParams
+import com.matter.controller.commands.bdx.*
 import com.matter.controller.commands.common.*
 import com.matter.controller.commands.discover.*
 import com.matter.controller.commands.icd.*
@@ -80,6 +81,15 @@ private fun getICDCommands(
   )
 }
 
+private fun getBdxCommands(
+  controller: ChipDeviceController,
+  credentialsIssuer: CredentialsIssuer
+): List<Command> {
+  return listOf(
+    DownloadLogCommand(controller, credentialsIssuer),
+  )
+}
+
 fun main(args: Array<String>) {
   val controller =
     ChipDeviceController(
@@ -96,6 +106,7 @@ fun main(args: Array<String>) {
   commandManager.register("pairing", getPairingCommands(controller, credentialsIssuer))
   commandManager.register("im", getImCommands(controller, credentialsIssuer))
   commandManager.register("icd", getICDCommands(controller, credentialsIssuer))
+  commandManager.register("bdx", getBdxCommands(controller, credentialsIssuer))
 
   try {
     commandManager.run(args)
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
new file mode 100644
index 00000000000000..89cecdce0678b4
--- /dev/null
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -0,0 +1,68 @@
+/*
+ *   Copyright (c) 2023 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package com.matter.controller.commands.bdx
+
+import chip.devicecontroller.ChipDeviceController
+import chip.devicecontroller.DiagnosticLogType
+import chip.devicecontroller.DownloadLogCallback
+import com.matter.controller.commands.common.CredentialsIssuer
+import com.matter.controller.commands.common.MatterCommand
+import java.nio.ByteBuffer
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+
+class DownloadLogCommand(
+  controller: ChipDeviceController,
+  credsIssuer: CredentialsIssuer?
+) : MatterCommand(controller, credsIssuer, "downloadLog") {
+  private val nodeId: AtomicLong = AtomicLong()
+  private val logType: StringBuffer = StringBuffer()
+  private val timeout: AtomicInteger = AtomicInteger()
+  private val buffer: StringBuffer = StringBuffer()
+
+  init {
+    addArgument("nodeid", 0, Long.MAX_VALUE, nodeId, null, false)
+    addArgument("logType", logType, null, false)
+    addArgument("timeout", 0, Int.MAX_VALUE, timeout, null, false)
+  }
+  override fun runCommand() {
+    currentCommissioner().downloadLogFromNode(nodeId.toLong(), DiagnosticLogType.value(logType.toString()), timeout.toInt(), object: DownloadLogCallback {
+      override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+        println("error :")
+        println("FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode")
+      }
+
+      override fun onTransferData(fabricIndex: Int, nodeId: Long, data: ByteArray, isEof: Boolean): Boolean {
+        buffer.append(String(data))
+        if (isEof) {
+          println()
+          println("FabricIndex : $fabricIndex, NodeID : $nodeId")
+          println(buffer.toString())
+          println("Log Download Finish!")
+        }
+        return true
+      }
+    })
+    try {
+      TimeUnit.SECONDS.sleep(timeout.toLong())
+    } catch (e: InterruptedException) {
+      throw RuntimeException(e)
+    }
+  }
+}
diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
new file mode 100644
index 00000000000000..b550ce5723ce87
--- /dev/null
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -0,0 +1,260 @@
+/*
+ *
+ *    Copyright (c) 2024 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "AndroidLogDownloadFromNode.h"
+
+#include <controller/CHIPDeviceControllerFactory.h>
+#include <protocols/bdx/BdxUri.h>
+#include <app-common/zap-generated/cluster-enums.h>
+#include <app-common/zap-generated/cluster-objects.h>
+
+using namespace chip::app::Clusters;
+
+namespace chip {
+namespace Controller {
+
+// Max Length is below 8
+CharSpan toIntentCharSpan(DiagnosticLogs::IntentEnum intent)
+{    
+    switch (intent) {
+    case DiagnosticLogs::IntentEnum::kEndUserSupport:
+        return CharSpan::fromCharString("EndUser");
+    case DiagnosticLogs::IntentEnum::kNetworkDiag:
+        return CharSpan::fromCharString("Network");
+    case DiagnosticLogs::IntentEnum::kCrashLogs:
+        return CharSpan::fromCharString("Crash");
+    default:
+        return CharSpan();
+    }
+}
+
+AndroidLogDownloadFromNode::AndroidLogDownloadFromNode(chip::Controller::DeviceController * controller, NodeId remoteNodeId, DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jCallbackObject)
+ : mController(controller), mOnDeviceConnectedCallback(&OnDeviceConnectedFn, this),
+    mOnDeviceConnectionFailureCallback(&OnDeviceConnectionFailureFn, this),
+    mOnBdxTransferCallback(&OnBdxTransferCallback, this),
+    mOnBdxTransferFailureCallback(&OnBdxTransferFailureCallback, this)
+{
+    mRemoteNodeId = remoteNodeId;
+    mIntent = intent;
+    mTimeout = timeout;
+
+    if (mJavaCallback.Init(jCallbackObject) != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Fail to init mJavaObjectRef");
+        return;
+    }
+}
+
+CHIP_ERROR AndroidLogDownloadFromNode::LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jcallback)
+{
+    VerifyOrReturnValue(controller != nullptr && jcallback != nullptr && remoteNodeId != kUndefinedNodeId, CHIP_ERROR_INVALID_ARGUMENT);
+
+    auto * logDownload = new AndroidLogDownloadFromNode(controller, remoteNodeId, intent, timeout, jcallback);
+    VerifyOrReturnValue(logDownload != nullptr, CHIP_ERROR_NO_MEMORY);
+
+    CHIP_ERROR err = logDownload->GetConnectedDevice();
+
+    if (err != CHIP_NO_ERROR)
+    {
+        delete logDownload;
+        logDownload = nullptr;
+    }
+    // Else will clean up when the callback is called.
+    return err;
+}
+
+CHIP_ERROR AndroidLogDownloadFromNode::GetConnectedDevice()
+{
+    return mController->GetConnectedDevice(mRemoteNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
+}
+
+CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)
+{
+    DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
+    request.intent = mIntent;
+    request.requestedProtocol = DiagnosticLogs::TransferProtocolEnum::kBdx;
+
+    CHIP_ERROR err = chip::bdx::MakeURI(mRemoteNodeId, toIntentCharSpan(mIntent), mFileDesignator);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Make BDX URI failure : %" CHIP_ERROR_FORMAT, err.Format());
+        FinishLogDownloadFromNode(err);
+    }
+
+    mBdxReceiver = new BdxDiagnosticLogsReceiver(&mOnBdxTransferCallback, &mOnBdxTransferFailureCallback, mController->GetFabricIndex(), mRemoteNodeId, mFileDesignator);
+    VerifyOrReturnValue(mBdxReceiver != nullptr, CHIP_ERROR_NO_MEMORY);
+
+    auto systemState = DeviceControllerFactory::GetInstance().GetSystemState();
+    systemState->BDXTransferServer()->SetDelegate(mBdxReceiver);
+
+    if (mTimeout > 0)
+    {
+        mBdxReceiver->StartBDXTransferTimeout(mTimeout);
+    }
+    
+    request.transferFileDesignator = MakeOptional(mFileDesignator);
+    ClusterBase cluster(exchangeMgr, sessionHandle, 0);
+
+    return cluster.InvokeCommand(request, this, OnResponseRetrieveLogs, OnCommandFailure);
+}
+
+void AndroidLogDownloadFromNode::OnDeviceConnectedFn(void * context, Messaging::ExchangeManager & exchangeMgr,
+                                               const SessionHandle & sessionHandle)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    auto * self    = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Device connected callback with null context. Ignoring"));
+
+    err = self->SendRetrieveLogsRequest(exchangeMgr, sessionHandle);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Log Download failure : %" CHIP_ERROR_FORMAT, err.Format());
+        self->FinishLogDownloadFromNode(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);
+}
+
+void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context, const DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data)
+{
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr,
+                   ChipLogProgress(Controller, "Success Read Current Fabric index callback with null context. Ignoring"));
+
+    using namespace chip::app::Clusters::DiagnosticLogs;
+    if (data.status == StatusEnum::kSuccess)
+    {
+        ChipLogProgress(Controller, "Success. Will receive log from BDX protocol.")
+    }
+    else if (data.status == StatusEnum::kExhausted)
+    {
+        CHIP_ERROR err = CHIP_NO_ERROR;
+        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, data.logContent, true, &err);
+        self->FinishLogDownloadFromNode(err);
+    }
+    else if (data.status == StatusEnum::kNoLogs)
+    {
+        CHIP_ERROR err = CHIP_NO_ERROR;
+        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), true, &err);
+        self->FinishLogDownloadFromNode(err);
+    }
+    else if (data.status == StatusEnum::kBusy)
+    {
+        self->FinishLogDownloadFromNode(CHIP_ERROR_BUSY);
+    }
+    else if (data.status == StatusEnum::kDenied)
+    {
+        self->FinishLogDownloadFromNode(CHIP_ERROR_ACCESS_DENIED);
+    }
+    else
+    {
+        self->FinishLogDownloadFromNode(CHIP_ERROR_INVALID_DATA_LIST);
+    }
+}
+
+void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err)
+{
+    ChipLogProgress(Controller, "OnCommandFailure %" CHIP_ERROR_FORMAT, err.Format());
+
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
+
+    self->FinishLogDownloadFromNode(err);
+}
+
+void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
+{
+    if (err == CHIP_NO_ERROR)
+    {
+        ChipLogProgress(Controller, "Log Download succeeded.");
+        return;
+    }
+
+    if (mBdxReceiver != nullptr)
+    {
+        if (mTimeout > 0)
+        {
+            mBdxReceiver->CancelBDXTransferTimeout();
+        }
+        delete mBdxReceiver;
+        mBdxReceiver = nullptr;
+    }
+
+    ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
+    
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    JniLocalReferenceScope scope(env);
+
+    jmethodID onErrorMethod;
+    // Java method signiture : void onError(int fabricIndex, long nodeId, long errorCode)
+    CHIP_ERROR 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(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()), static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
+}
+
+void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure)
+{
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
+
+    self->OnTransferCallback(fabricIndex, remoteNodeId, data, isEof, errInfoOnFailure);
+}
+
+void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure)
+{
+    VerifyOrReturn(mJavaCallback.HasValidObjectRef(), ChipLogError(Controller, "mJavaCallback is invalid"));
+
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    JniLocalReferenceScope scope(env);
+
+    jmethodID onTransferDataMethod;
+    // Java method signiture : boolean onTransferData(int fabricIndex, long nodeId, byte[] data, boolean isEof)
+    *errInfoOnFailure = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onTransferData",
+                                                             "(IJ[BZ)Z", &onTransferDataMethod);
+    VerifyOrReturn(*errInfoOnFailure == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onTransferData method"));
+    chip::ByteArray dataByteArray(env, data);
+
+    jboolean ret = env->CallBooleanMethod(mJavaCallback.ObjectRef(), onTransferDataMethod, static_cast<jint>(fabricIndex), static_cast<jlong>(remoteNodeId), dataByteArray.jniValue(), isEof ? JNI_TRUE : JNI_FALSE);
+
+    if (ret != JNI_TRUE)
+    {
+        ChipLogError(Controller, "Transfer will be rejected.")
+        *errInfoOnFailure = CHIP_ERROR_INTERNAL;
+    }
+}
+
+void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status)
+{
+    ChipLogProgress(Controller, "OnBdxTransferFailureCallback: %" CHIP_ERROR_FORMAT, status.Format());
+
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
+
+    self->FinishLogDownloadFromNode(status);
+}
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/AndroidLogDownloadFromNode.h b/src/controller/java/AndroidLogDownloadFromNode.h
new file mode 100644
index 00000000000000..bf64d46701121e
--- /dev/null
+++ b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -0,0 +1,87 @@
+/*
+ *
+ *    Copyright (c) 2024 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include <app/OperationalSessionSetup.h>
+#include <controller/CHIPDeviceController.h>
+#include <lib/core/CHIPCallback.h>
+#include <lib/support/JniReferences.h>
+#include <lib/support/JniTypeWrappers.h>
+
+#include "BdxDiagnosticLogsReceiver.h"
+
+namespace chip {
+namespace Controller {
+
+/**
+ * A helper class to download diagnostic log given some parameters.
+ */
+class AndroidLogDownloadFromNode
+{
+public:
+    /*
+     * @brief
+     *   Try to look up the device attached to our controller with the given
+     *   remote node id and ask it to download diagnostic log.
+     *   If function returns an error, callback will never be be executed. Otherwise, callback will always be executed.
+     *
+     * @param[in] remoteNodeId The remote device Id
+     * @param[in] intent Diagnostic log type
+     * @param[in] timeout Download log timeout value. If this value is 0, controller does not handle timeouts.
+     * @param[in] callback The callback to call when Log Download data is received and when an error occurs
+     */
+    static CHIP_ERROR LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jCallbackObject);
+
+private:
+    AndroidLogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject javaCallback);
+
+    DeviceController * mController;
+
+    chip::Callback::Callback<OnDeviceConnected> mOnDeviceConnectedCallback;
+    chip::Callback::Callback<OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
+    chip::Callback::Callback<OnBdxTransfer> mOnBdxTransferCallback;
+    chip::Callback::Callback<OnBdxTransferFailure> mOnBdxTransferFailureCallback;
+
+    chip::JniGlobalReference mJavaCallback;
+    NodeId mRemoteNodeId;
+    app::Clusters::DiagnosticLogs::IntentEnum mIntent;
+    uint16_t mTimeout;
+
+    char mFileDesignatorBuffer[bdx::DiagnosticLogs::kMaxFileDesignatorLen];
+    MutableCharSpan mFileDesignator = MutableCharSpan(mFileDesignatorBuffer, bdx::DiagnosticLogs::kMaxFileDesignatorLen);
+
+    BdxDiagnosticLogsReceiver *mBdxReceiver = nullptr;
+    
+    CHIP_ERROR GetConnectedDevice();
+    CHIP_ERROR SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
+    void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+    void FinishLogDownloadFromNode(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);
+
+    static void OnResponseRetrieveLogs(void * context, const app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
+    static void OnCommandFailure(void * context, CHIP_ERROR err);
+
+    static void OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+    static void OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
+};
+
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index c1e05cff40fb42..c5a36dbaef978e 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -132,10 +132,14 @@ shared_library("jni") {
     "AndroidCurrentFabricRemover.h",
     "AndroidDeviceControllerWrapper.cpp",
     "AndroidDeviceControllerWrapper.h",
+    "AndroidLogDownloadFromNode.cpp",
+    "AndroidLogDownloadFromNode.h",
     "AndroidOperationalCredentialsIssuer.cpp",
     "AndroidOperationalCredentialsIssuer.h",
     "AttestationTrustStoreBridge.cpp",
     "AttestationTrustStoreBridge.h",
+    "BdxDiagnosticLogsReceiver.cpp",
+    "BdxDiagnosticLogsReceiver.h",
     "CHIPDeviceController-JNI.cpp",
     "CHIPP256KeypairBridge.cpp",
     "CHIPP256KeypairBridge.h",
@@ -637,6 +641,8 @@ android_library("java") {
     "src/chip/devicecontroller/ControllerParams.java",
     "src/chip/devicecontroller/DeviceAttestation.java",
     "src/chip/devicecontroller/DeviceAttestationDelegate.java",
+    "src/chip/devicecontroller/DiagnosticLogType.java",
+    "src/chip/devicecontroller/DownloadLogCallback.java",
     "src/chip/devicecontroller/DiscoveredDevice.java",
     "src/chip/devicecontroller/GroupKeySecurityPolicy.java",
     "src/chip/devicecontroller/ICDCheckInDelegate.java",
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.cpp b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
new file mode 100644
index 00000000000000..20de07ca5a4990
--- /dev/null
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
@@ -0,0 +1,102 @@
+/*
+ *
+ *    Copyright (c) 2024 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "BdxDiagnosticLogsReceiver.h"
+
+#include <platform/CHIPDeviceLayer.h>
+
+namespace chip {
+namespace Controller {
+
+using namespace ::chip::DeviceLayer;
+
+BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator)
+{
+    mOnBdxTransferCallback = onTransfer;
+    mOnBdxTransferFailureCallback = onFailure;
+
+    mFabricIndex = fabricIndex;
+    mNodeId = nodeId;
+    mFileDesignator = fileDesignator;
+}
+
+CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferBegin(chip::bdx::BDXTransferProxy * transfer)
+{
+    chip::CharSpan fileDesignator = transfer->GetFileDesignator();
+    chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
+    chip::NodeId nodeId = transfer->GetPeerNodeId();
+
+    if (mFileDesignator.data_equal(fileDesignator) && mFabricIndex == fabricIndex && mNodeId == nodeId)
+    {
+        transfer->Accept();
+    }
+    else
+    {
+        transfer->Reject(CHIP_ERROR_INVALID_DESTINATION_NODE_ID);
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferEnd(chip::bdx::BDXTransferProxy * transfer, CHIP_ERROR error)
+{
+    ChipLogProgress(Controller, "OnTransferEnd: %" CHIP_ERROR_FORMAT, error.Format());
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data, bool isEof)
+{
+    ChipLogProgress(Controller, "OnTransferData : %u", isEof);
+    chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
+    chip::NodeId nodeId = transfer->GetPeerNodeId();
+
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    mOnBdxTransferCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId, data, isEof, &err);
+
+    if (err == CHIP_NO_ERROR)
+    {
+        transfer->Continue();
+    }
+    else
+    {
+        transfer->Reject(err);
+    }
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR BdxDiagnosticLogsReceiver::StartBDXTransferTimeout(uint16_t timeoutInSeconds)
+{
+  ChipLogProgress(Controller, "StartBDXTransferTimeout %u", timeoutInSeconds);
+  return chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds16(timeoutInSeconds), OnTransferTimeout, static_cast<void *>(this));
+}
+
+void BdxDiagnosticLogsReceiver::CancelBDXTransferTimeout()
+{
+  ChipLogProgress(Controller, "CancelBDXTransferTimeout");
+  chip::DeviceLayer::SystemLayer().CancelTimer(OnTransferTimeout, static_cast<void *>(this));
+}
+
+void BdxDiagnosticLogsReceiver::OnTransferTimeout(chip::System::Layer * layer, void * context)
+{
+  ChipLogProgress(Controller, "OnTransferTimeout");
+  auto * self    = static_cast<BdxDiagnosticLogsReceiver *>(context);
+  self->mOnBdxTransferFailureCallback->mCall(self->mOnBdxTransferFailureCallback->mContext, self->mFabricIndex, self->mNodeId, CHIP_ERROR_TIMEOUT);
+}
+}
+}
\ No newline at end of file
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.h b/src/controller/java/BdxDiagnosticLogsReceiver.h
new file mode 100644
index 00000000000000..a082d271dc02e1
--- /dev/null
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.h
@@ -0,0 +1,60 @@
+/*
+ *   Copyright (c) 2024 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+#pragma once
+
+#include <messaging/ExchangeMgr.h>
+#include <protocols/bdx/BdxTransferProxy.h>
+#include <protocols/bdx/BdxTransferServerDelegate.h>
+#include <protocols/bdx/BdxUri.h>
+#include <protocols/bdx/TransferFacilitator.h>
+
+namespace chip {
+namespace Controller {
+
+typedef void (*OnBdxTransfer)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+typedef void (*OnBdxTransferFailure)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
+
+constexpr uint32_t kMaxBDXReceiverURILen = 256;
+
+class BdxDiagnosticLogsReceiver : public chip::bdx::BDXTransferServerDelegate
+{
+public:
+    BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator);
+
+    ~BdxDiagnosticLogsReceiver() {}
+
+    /////////// BdxDiagnosticLogsReceiver Interface /////////
+    CHIP_ERROR OnTransferBegin(chip::bdx::BDXTransferProxy * transfer) override;
+    CHIP_ERROR OnTransferEnd(chip::bdx::BDXTransferProxy * transfer, CHIP_ERROR error) override;
+    CHIP_ERROR OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data, bool isEof) override;
+
+    CHIP_ERROR StartBDXTransferTimeout(uint16_t timeoutInSeconds);
+    void CancelBDXTransferTimeout();
+
+private:
+    static void OnTransferTimeout(chip::System::Layer * layer, void * context);
+    
+    chip::Callback::Callback<OnBdxTransfer> * mOnBdxTransferCallback;
+    chip::Callback::Callback<OnBdxTransferFailure> * mOnBdxTransferFailureCallback;
+
+    chip::FabricIndex mFabricIndex = kUndefinedFabricIndex;
+    chip::NodeId mNodeId = kUndefinedNodeId;
+    chip::CharSpan mFileDesignator;
+};
+}
+}
\ No newline at end of file
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index 65f0d13f01d06e..9f07ed43d95d19 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -25,6 +25,7 @@
 #include "AndroidCommissioningWindowOpener.h"
 #include "AndroidCurrentFabricRemover.h"
 #include "AndroidDeviceControllerWrapper.h"
+#include "AndroidLogDownloadFromNode.h"
 #include "AndroidInteractionClient.h"
 #include <controller/java/ControllerConfig.h>
 #include <lib/support/CHIPJNIError.h>
@@ -2059,6 +2060,23 @@ JNI_METHOD(jboolean, openPairingWindowWithPINCallback)
     return true;
 }
 
+JNI_METHOD(void, downloadLogFromNode)(JNIEnv * env, jobject self, jlong handle, jlong deviceId, jint typeEnum, jint timeout, jobject downloadLogCallback)
+{
+    chip::DeviceLayer::StackLock lock;
+    CHIP_ERROR err                           = CHIP_NO_ERROR;
+    AndroidDeviceControllerWrapper * wrapper = AndroidDeviceControllerWrapper::FromJNIHandle(handle);
+
+    ChipLogProgress(Controller, "downloadLogFromNode() called with device ID and callback object");
+
+    err = AndroidLogDownloadFromNode::LogDownloadFromNode(wrapper->Controller(), static_cast<NodeId>(deviceId), static_cast<chip::app::Clusters::DiagnosticLogs::IntentEnum>(typeEnum), static_cast<uint16_t>(timeout), downloadLogCallback);
+
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Failed to download Log the device.");
+        JniReferences::GetInstance().ThrowError(env, sChipDeviceControllerExceptionCls, err);
+    }
+}
+
 JNI_METHOD(void, shutdownCommissioning)
 (JNIEnv * env, jobject self, jlong handle)
 {
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index 4a59b178f85ef6..5f55b3f47fbbf4 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -883,6 +883,10 @@ public boolean openPairingWindowWithPINCallback(
         deviceControllerPtr, devicePtr, duration, iteration, discriminator, setupPinCode, callback);
   }
 
+  public boolean downloadLogFromNode(long deviceId, DiagnosticLogType type, int timeout, DownloadLogCallback callback) {
+    return downloadLogFromNode(deviceControllerPtr, deviceId, type.getValue(), timeout, callback);
+  }
+
   public int getFabricIndex() {
     return getFabricIndex(deviceControllerPtr);
   }
@@ -1727,6 +1731,8 @@ private native boolean openPairingWindowWithPINCallback(
       @Nullable Long setupPinCode,
       OpenCommissioningCallback callback);
 
+  private native boolean downloadLogFromNode(long deviceControllerPtr, long deviceId, int typeEnum, long timeout, DownloadLogCallback callback);
+
   private native byte[] getAttestationChallenge(long deviceControllerPtr, long devicePtr);
 
   private native void setUseJavaCallbackForNOCRequest(
diff --git a/src/controller/java/src/chip/devicecontroller/DiagnosticLogType.java b/src/controller/java/src/chip/devicecontroller/DiagnosticLogType.java
new file mode 100644
index 00000000000000..9617bf664c4f13
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/DiagnosticLogType.java
@@ -0,0 +1,52 @@
+/*
+ *   Copyright (c) 2024 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller;
+
+public enum DiagnosticLogType {
+  EndUserSupport(0),
+  NetworkDiagnostics(1),
+  CrashLogs(2);
+
+  private final int value;
+
+  DiagnosticLogType(int value) {
+    this.value = value;
+  }
+
+  public static DiagnosticLogType value(int value) {
+    for (DiagnosticLogType type : DiagnosticLogType.values()) {
+      if (type.value == value) {
+        return type;
+      }
+    }
+    throw new IllegalArgumentException("Invalid value: " + value);
+  }
+
+  public static DiagnosticLogType value(String value) {
+    for (DiagnosticLogType type : DiagnosticLogType.values()) {
+      if (type.toString().equals(value)) {
+        return type;
+      }
+    }
+    throw new IllegalArgumentException("Invalid value: " + value);
+  }
+
+  public int getValue() {
+    return value;
+  }
+}
diff --git a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
new file mode 100644
index 00000000000000..0c622156895327
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
@@ -0,0 +1,26 @@
+/*
+ *   Copyright (c) 2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package chip.devicecontroller;
+
+import javax.annotation.Nonnull;
+
+public interface DownloadLogCallback {
+  public void onError(int fabricIndex, long nodeId, long errorCode);
+
+  public boolean onTransferData(int fabricIndex, long nodeId, @Nonnull byte[] data, boolean isEof);
+}
diff --git a/src/protocols/bdx/BdxTransferDiagnosticLog.cpp b/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
index 4804a01c578c26..9ab1054a3305d1 100644
--- a/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
+++ b/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
@@ -156,7 +156,7 @@ CHIP_ERROR BdxTransferDiagnosticLog::OnBlockReceived(TransferSession::OutputEven
     VerifyOrReturnError(nullptr != mDelegate, CHIP_ERROR_INCORRECT_STATE);
 
     ByteSpan blockData(event.blockdata.Data, event.blockdata.Length);
-    return mDelegate->OnTransferData(&mTransferProxy, blockData);
+    return mDelegate->OnTransferData(&mTransferProxy, blockData, event.blockdata.IsEof);
 }
 
 void BdxTransferDiagnosticLog::AbortTransferOnFailure(CHIP_ERROR error)
diff --git a/src/protocols/bdx/BdxTransferServerDelegate.h b/src/protocols/bdx/BdxTransferServerDelegate.h
index e151ed8c5f09f9..16d81209b4375b 100644
--- a/src/protocols/bdx/BdxTransferServerDelegate.h
+++ b/src/protocols/bdx/BdxTransferServerDelegate.h
@@ -46,7 +46,17 @@ class BDXTransferServerDelegate
      * @brief
      *  This method is invoked when a block is received.
      */
-    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data) = 0;
+    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data)
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
+    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data, bool isEof)
+    {
+        (void) isEof;
+
+        return OnTransferData(transfer, data);
+    }
 };
 
 } // namespace bdx
diff --git a/src/protocols/bdx/BdxUri.h b/src/protocols/bdx/BdxUri.h
index 00fe0ee34be3bf..caba2a0cc2a201 100644
--- a/src/protocols/bdx/BdxUri.h
+++ b/src/protocols/bdx/BdxUri.h
@@ -16,6 +16,8 @@
  *    limitations under the License.
  */
 
+#pragma once
+
 #include <lib/core/NodeId.h>
 #include <lib/support/Span.h>
 

From de3da7c1e5a0124ba5272feda40dd6d3b5f7ff05 Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Fri, 29 Nov 2024 15:31:45 +0900
Subject: [PATCH 02/11] Update from comment

---
 .../clusterclient/DiagnosticLogFragment.kt    | 108 +++++++++++-------
 .../res/layout/diagnostic_log_fragment.xml    |  12 ++
 .../commands/bdx/DownloadLogCommand.kt        |  49 ++++----
 .../java/AndroidLogDownloadFromNode.cpp       |  47 +++++---
 .../java/AndroidLogDownloadFromNode.h         |   6 +-
 .../java/BdxDiagnosticLogsReceiver.cpp        |  19 ++-
 .../java/BdxDiagnosticLogsReceiver.h          |   8 +-
 .../devicecontroller/DownloadLogCallback.java |   4 +-
 .../bdx/BdxTransferDiagnosticLog.cpp          |   2 +-
 src/protocols/bdx/BdxTransferServerDelegate.h |  12 +-
 10 files changed, 172 insertions(+), 95 deletions(-)

diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
index 8f0622e4a76424..26d09051814746 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -18,10 +18,10 @@ import chip.devicecontroller.DownloadLogCallback
 import com.google.chip.chiptool.ChipClient
 import com.google.chip.chiptool.R
 import com.google.chip.chiptool.databinding.DiagnosticLogFragmentBinding
-import kotlinx.coroutines.*
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
+import kotlinx.coroutines.*
 
 class DiagnosticLogFragment : Fragment() {
   private val deviceController: ChipDeviceController
@@ -45,6 +45,8 @@ class DiagnosticLogFragment : Fragment() {
   private var mDownloadFile: File? = null
   private var mDownloadFileOutputStream: FileOutputStream? = null
 
+  private var mReceiveFileLen = 0U
+
   override fun onCreateView(
     inflater: LayoutInflater,
     container: ViewGroup?,
@@ -59,7 +61,11 @@ class DiagnosticLogFragment : Fragment() {
     binding.getDiagnosticLogBtn.setOnClickListener { scope.launch { getDiagnosticLogClick() } }
 
     binding.diagnosticTypeSp.adapter =
-      ArrayAdapter(requireContext(), android.R.layout.simple_spinner_dropdown_item, diagnosticLogTypeList)
+      ArrayAdapter(
+        requireContext(),
+        android.R.layout.simple_spinner_dropdown_item,
+        diagnosticLogTypeList
+      )
 
     return binding.root
   }
@@ -70,66 +76,90 @@ class DiagnosticLogFragment : Fragment() {
   }
 
   inner class ChipDownloadLogCallback : DownloadLogCallback {
-      override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
-        Log.d(TAG, "onError: $fabricIndex, ${nodeId.toULong()}, $errorCode")
-      }
+    override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+      Log.d(TAG, "onError: $fabricIndex, ${nodeId.toULong()}, $errorCode")
+      mDownloadFileOutputStream?.flush() ?: return
+    }
+
+    override fun onSuccess(fabricIndex: Int, nodeId: Long) {
+      Log.d(TAG, "onSuccess: $fabricIndex, ${nodeId.toULong()}")
+      mDownloadFileOutputStream?.flush() ?: return
+      mDownloadFile?.let { showNotification(it) } ?: return
+    }
 
-      override fun onTransferData(
-        fabricIndex: Int,
-        nodeId: Long,
-        data: ByteArray,
-        isEof: Boolean
-      ): Boolean {
-          Log.d(TAG, "onTransferData : ${data.size}, $isEof")
-        if (mDownloadFileOutputStream == null || mDownloadFile == null) {
-            Log.d(TAG, "mDownloadFileOutputStream or mDownloadFile is null")
-            return false
-        }
-        try {
-            mDownloadFileOutputStream!!.write(data)
-            if (isEof) {
-                mDownloadFileOutputStream!!.flush()
-                showNotification(mDownloadFile!!)
-            }
-        } catch (e: IOException) {
-            Log.d(TAG, "IOException", e)
-            return false
-        }
-        return true
+    override fun onTransferData(
+      fabricIndex: Int,
+      nodeId: Long,
+      data: ByteArray
+    ): Boolean {
+      Log.d(TAG, "onTransferData : ${data.size}")
+      if (mDownloadFileOutputStream == null) {
+        Log.d(TAG, "mDownloadFileOutputStream or mDownloadFile is null")
+        return false
+      }
+      try {
+        mDownloadFileOutputStream!!.write(data)
+      } catch (e: IOException) {
+        Log.d(TAG, "IOException", e)
+        return false
       }
+      mReceiveFileLen += data.size.toUInt()
+      showMessage("Receive Data Size : $mReceiveFileLen")
+      return true
+    }
   }
 
   private fun getDiagnosticLogClick() {
-    mDownloadFile = createLogFile(deviceController.fabricIndex.toUInt(), addressUpdateFragment.deviceId.toULong(), diagnosticLogType)
+    mDownloadFile =
+      createLogFile(
+        deviceController.fabricIndex.toUInt(),
+        addressUpdateFragment.deviceId.toULong(),
+        diagnosticLogType
+      )
     mDownloadFileOutputStream = FileOutputStream(mDownloadFile)
-    deviceController.downloadLogFromNode(addressUpdateFragment.deviceId, diagnosticLogType, timeout, ChipDownloadLogCallback())
+    deviceController.downloadLogFromNode(
+      addressUpdateFragment.deviceId,
+      diagnosticLogType,
+      timeout,
+      ChipDownloadLogCallback()
+    )
   }
 
   private fun isExternalStorageWritable(): Boolean {
     return Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED
   }
 
-  private fun createLogFile(fabricIndex: UInt, nodeId: ULong, type:DiagnosticLogType) : File? {
+  private fun createLogFile(fabricIndex: UInt, nodeId: ULong, type: DiagnosticLogType): File? {
     if (!isExternalStorageWritable()) {
       return null
     }
     val now = System.currentTimeMillis()
     val fileName = "${type}_${fabricIndex}_${nodeId}_$now.txt"
+    mReceiveFileLen = 0U
     return File(requireContext().getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS), fileName)
   }
 
   private fun showNotification(file: File) {
-        val intent = Intent(Intent.ACTION_VIEW).apply {
-            setDataAndType(getFileUri(file), "text/plain")
-            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-        }
+    val intent =
+      Intent(Intent.ACTION_VIEW).apply {
+        setDataAndType(getFileUri(file), "text/plain")
+        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+      }
 
-      requireActivity().startActivity(intent)
-    }
+    requireActivity().startActivity(intent)
+  }
 
-    private fun getFileUri(file: File): Uri {
-        return FileProvider.getUriForFile(requireContext(), "${requireContext().packageName}.provider", file)
-    }
+  private fun getFileUri(file: File): Uri {
+    return FileProvider.getUriForFile(
+      requireContext(),
+      "${requireContext().packageName}.provider",
+      file
+    )
+  }
+
+  private fun showMessage(msg: String) {
+    requireActivity().runOnUiThread { binding.diagnosticLogTv.text = msg }
+  }
 
   companion object {
     private const val TAG = "DiagnosticLogFragment"
diff --git a/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml b/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
index 6233bee067b992..56b770a645b442 100644
--- a/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
+++ b/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
@@ -72,4 +72,16 @@
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintTop_toBottomOf="@id/timeoutTv"/>
 
+    <TextView
+        android:id="@+id/diagnosticLogTv"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:minLines="4"
+        android:padding="16dp"
+        android:singleLine="false"
+        android:textSize="20sp"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/getDiagnosticLogBtn" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
index 89cecdce0678b4..d35ecff777409e 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -22,15 +22,12 @@ import chip.devicecontroller.DiagnosticLogType
 import chip.devicecontroller.DownloadLogCallback
 import com.matter.controller.commands.common.CredentialsIssuer
 import com.matter.controller.commands.common.MatterCommand
-import java.nio.ByteBuffer
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 
-class DownloadLogCommand(
-  controller: ChipDeviceController,
-  credsIssuer: CredentialsIssuer?
-) : MatterCommand(controller, credsIssuer, "downloadLog") {
+class DownloadLogCommand(controller: ChipDeviceController, credsIssuer: CredentialsIssuer?) :
+  MatterCommand(controller, credsIssuer, "downloadLog") {
   private val nodeId: AtomicLong = AtomicLong()
   private val logType: StringBuffer = StringBuffer()
   private val timeout: AtomicInteger = AtomicInteger()
@@ -41,24 +38,36 @@ class DownloadLogCommand(
     addArgument("logType", logType, null, false)
     addArgument("timeout", 0, Int.MAX_VALUE, timeout, null, false)
   }
+
   override fun runCommand() {
-    currentCommissioner().downloadLogFromNode(nodeId.toLong(), DiagnosticLogType.value(logType.toString()), timeout.toInt(), object: DownloadLogCallback {
-      override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
-        println("error :")
-        println("FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode")
-      }
+    currentCommissioner()
+      .downloadLogFromNode(
+        nodeId.toLong(),
+        DiagnosticLogType.value(logType.toString()),
+        timeout.toInt(),
+        object : DownloadLogCallback {
+          override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+            println("error :")
+            println("FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode")
+          }
 
-      override fun onTransferData(fabricIndex: Int, nodeId: Long, data: ByteArray, isEof: Boolean): Boolean {
-        buffer.append(String(data))
-        if (isEof) {
-          println()
-          println("FabricIndex : $fabricIndex, NodeID : $nodeId")
-          println(buffer.toString())
-          println("Log Download Finish!")
+          override fun onTransferData(
+            fabricIndex: Int,
+            nodeId: Long,
+            data: ByteArray,
+            isEof: Boolean
+          ): Boolean {
+            buffer.append(String(data))
+            if (isEof) {
+              println()
+              println("FabricIndex : $fabricIndex, NodeID : $nodeId")
+              println(buffer.toString())
+              println("Log Download Finish!")
+            }
+            return true
+          }
         }
-        return true
-      }
-    })
+      )
     try {
       TimeUnit.SECONDS.sleep(timeout.toLong())
     } catch (e: InterruptedException) {
diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
index b550ce5723ce87..2b766fa36c47f7 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.cpp
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -47,6 +47,7 @@ AndroidLogDownloadFromNode::AndroidLogDownloadFromNode(chip::Controller::DeviceC
  : mController(controller), mOnDeviceConnectedCallback(&OnDeviceConnectedFn, this),
     mOnDeviceConnectionFailureCallback(&OnDeviceConnectionFailureFn, this),
     mOnBdxTransferCallback(&OnBdxTransferCallback, this),
+    mOnBdxTransferSuccessCallback(&OnBdxTransferSuccessCallback, this),
     mOnBdxTransferFailureCallback(&OnBdxTransferFailureCallback, this)
 {
     mRemoteNodeId = remoteNodeId;
@@ -96,7 +97,7 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan
         FinishLogDownloadFromNode(err);
     }
 
-    mBdxReceiver = new BdxDiagnosticLogsReceiver(&mOnBdxTransferCallback, &mOnBdxTransferFailureCallback, mController->GetFabricIndex(), mRemoteNodeId, mFileDesignator);
+    mBdxReceiver = new BdxDiagnosticLogsReceiver(&mOnBdxTransferCallback, &mOnBdxTransferSuccessCallback, &mOnBdxTransferFailureCallback, mController->GetFabricIndex(), mRemoteNodeId, mFileDesignator);
     VerifyOrReturnValue(mBdxReceiver != nullptr, CHIP_ERROR_NO_MEMORY);
 
     auto systemState = DeviceControllerFactory::GetInstance().GetSystemState();
@@ -152,13 +153,13 @@ void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context, const Di
     else if (data.status == StatusEnum::kExhausted)
     {
         CHIP_ERROR err = CHIP_NO_ERROR;
-        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, data.logContent, true, &err);
+        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, data.logContent, &err);
         self->FinishLogDownloadFromNode(err);
     }
     else if (data.status == StatusEnum::kNoLogs)
     {
         CHIP_ERROR err = CHIP_NO_ERROR;
-        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), true, &err);
+        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), &err);
         self->FinishLogDownloadFromNode(err);
     }
     else if (data.status == StatusEnum::kBusy)
@@ -187,9 +188,20 @@ void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err
 
 void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
 {
+    CHIP_ERROR jniErr = CHIP_NO_ERROR;
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    JniLocalReferenceScope scope(env);
+
     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);
+
+        VerifyOrReturn(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;
     }
 
@@ -204,27 +216,24 @@ void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
     }
 
     ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
-    
-    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
-    JniLocalReferenceScope scope(env);
 
     jmethodID onErrorMethod;
-    // Java method signiture : void onError(int fabricIndex, long nodeId, long errorCode)
-    CHIP_ERROR jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &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(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()), static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
 }
 
-void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure)
+void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure)
 {
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
 
-    self->OnTransferCallback(fabricIndex, remoteNodeId, data, isEof, errInfoOnFailure);
+    self->OnTransferCallback(fabricIndex, remoteNodeId, data, errInfoOnFailure);
 }
 
-void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure)
+void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure)
 {
     VerifyOrReturn(mJavaCallback.HasValidObjectRef(), ChipLogError(Controller, "mJavaCallback is invalid"));
 
@@ -232,13 +241,13 @@ void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, Nod
     JniLocalReferenceScope scope(env);
 
     jmethodID onTransferDataMethod;
-    // Java method signiture : boolean onTransferData(int fabricIndex, long nodeId, byte[] data, boolean isEof)
+    // Java method signature : boolean onTransferData(int fabricIndex, long nodeId, byte[] data)
     *errInfoOnFailure = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onTransferData",
-                                                             "(IJ[BZ)Z", &onTransferDataMethod);
+                                                             "(IJ[B)Z", &onTransferDataMethod);
     VerifyOrReturn(*errInfoOnFailure == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onTransferData method"));
     chip::ByteArray dataByteArray(env, data);
 
-    jboolean ret = env->CallBooleanMethod(mJavaCallback.ObjectRef(), onTransferDataMethod, static_cast<jint>(fabricIndex), static_cast<jlong>(remoteNodeId), dataByteArray.jniValue(), isEof ? JNI_TRUE : JNI_FALSE);
+    jboolean ret = env->CallBooleanMethod(mJavaCallback.ObjectRef(), onTransferDataMethod, static_cast<jint>(fabricIndex), static_cast<jlong>(remoteNodeId), dataByteArray.jniValue());
 
     if (ret != JNI_TRUE)
     {
@@ -247,6 +256,16 @@ void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, Nod
     }
 }
 
+void AndroidLogDownloadFromNode::OnBdxTransferSuccessCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId)
+{
+    ChipLogProgress(Controller, "OnBdxTransferSuccessCallback");
+
+    auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
+    VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
+
+    self->FinishLogDownloadFromNode(CHIP_NO_ERROR);
+}
+
 void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status)
 {
     ChipLogProgress(Controller, "OnBdxTransferFailureCallback: %" CHIP_ERROR_FORMAT, status.Format());
diff --git a/src/controller/java/AndroidLogDownloadFromNode.h b/src/controller/java/AndroidLogDownloadFromNode.h
index bf64d46701121e..e10515823a5d00 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.h
+++ b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -56,6 +56,7 @@ class AndroidLogDownloadFromNode
     chip::Callback::Callback<OnDeviceConnected> mOnDeviceConnectedCallback;
     chip::Callback::Callback<OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
     chip::Callback::Callback<OnBdxTransfer> mOnBdxTransferCallback;
+    chip::Callback::Callback<OnBdxTransferSuccess> mOnBdxTransferSuccessCallback;
     chip::Callback::Callback<OnBdxTransferFailure> mOnBdxTransferFailureCallback;
 
     chip::JniGlobalReference mJavaCallback;
@@ -70,7 +71,7 @@ class AndroidLogDownloadFromNode
     
     CHIP_ERROR GetConnectedDevice();
     CHIP_ERROR SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
-    void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+    void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
     void FinishLogDownloadFromNode(CHIP_ERROR err);
 
     static void OnDeviceConnectedFn(void * context, Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
@@ -79,7 +80,8 @@ class AndroidLogDownloadFromNode
     static void OnResponseRetrieveLogs(void * context, const app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
     static void OnCommandFailure(void * context, CHIP_ERROR err);
 
-    static void OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+    static void OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
+    static void OnBdxTransferSuccessCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId);
     static void OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
 };
 
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.cpp b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
index 20de07ca5a4990..7b6b0b510972f0 100644
--- a/src/controller/java/BdxDiagnosticLogsReceiver.cpp
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
@@ -25,9 +25,10 @@ namespace Controller {
 
 using namespace ::chip::DeviceLayer;
 
-BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator)
+BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferSuccess> * onSuccess, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator)
 {
     mOnBdxTransferCallback = onTransfer;
+    mOnBdxTransferSuccessCallback = onSuccess;
     mOnBdxTransferFailureCallback = onFailure;
 
     mFabricIndex = fabricIndex;
@@ -56,18 +57,28 @@ CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferBegin(chip::bdx::BDXTransferProx
 CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferEnd(chip::bdx::BDXTransferProxy * transfer, CHIP_ERROR error)
 {
     ChipLogProgress(Controller, "OnTransferEnd: %" CHIP_ERROR_FORMAT, error.Format());
+    chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
+    chip::NodeId nodeId = transfer->GetPeerNodeId();
+    if (error == CHIP_NO_ERROR)
+    {
+        mOnBdxTransferSuccessCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId);
+    }
+    else
+    {
+        mOnBdxTransferFailureCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId, error);
+    }
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data, bool isEof)
+CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data)
 {
-    ChipLogProgress(Controller, "OnTransferData : %u", isEof);
+    ChipLogProgress(Controller, "OnTransferData");
     chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
     chip::NodeId nodeId = transfer->GetPeerNodeId();
 
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    mOnBdxTransferCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId, data, isEof, &err);
+    mOnBdxTransferCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId, data, &err);
 
     if (err == CHIP_NO_ERROR)
     {
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.h b/src/controller/java/BdxDiagnosticLogsReceiver.h
index a082d271dc02e1..35156d5306be47 100644
--- a/src/controller/java/BdxDiagnosticLogsReceiver.h
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.h
@@ -26,7 +26,8 @@
 namespace chip {
 namespace Controller {
 
-typedef void (*OnBdxTransfer)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, bool isEof, CHIP_ERROR *errInfoOnFailure);
+typedef void (*OnBdxTransfer)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
+typedef void (*OnBdxTransferSuccess)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId);
 typedef void (*OnBdxTransferFailure)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
 
 constexpr uint32_t kMaxBDXReceiverURILen = 256;
@@ -34,14 +35,14 @@ constexpr uint32_t kMaxBDXReceiverURILen = 256;
 class BdxDiagnosticLogsReceiver : public chip::bdx::BDXTransferServerDelegate
 {
 public:
-    BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator);
+    BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferSuccess> * onSuccess, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator);
 
     ~BdxDiagnosticLogsReceiver() {}
 
     /////////// BdxDiagnosticLogsReceiver Interface /////////
     CHIP_ERROR OnTransferBegin(chip::bdx::BDXTransferProxy * transfer) override;
     CHIP_ERROR OnTransferEnd(chip::bdx::BDXTransferProxy * transfer, CHIP_ERROR error) override;
-    CHIP_ERROR OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data, bool isEof) override;
+    CHIP_ERROR OnTransferData(chip::bdx::BDXTransferProxy * transfer, const chip::ByteSpan & data) override;
 
     CHIP_ERROR StartBDXTransferTimeout(uint16_t timeoutInSeconds);
     void CancelBDXTransferTimeout();
@@ -50,6 +51,7 @@ class BdxDiagnosticLogsReceiver : public chip::bdx::BDXTransferServerDelegate
     static void OnTransferTimeout(chip::System::Layer * layer, void * context);
     
     chip::Callback::Callback<OnBdxTransfer> * mOnBdxTransferCallback;
+    chip::Callback::Callback<OnBdxTransferSuccess> * mOnBdxTransferSuccessCallback;
     chip::Callback::Callback<OnBdxTransferFailure> * mOnBdxTransferFailureCallback;
 
     chip::FabricIndex mFabricIndex = kUndefinedFabricIndex;
diff --git a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
index 0c622156895327..3ceba50813599d 100644
--- a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
+++ b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
@@ -22,5 +22,7 @@
 public interface DownloadLogCallback {
   public void onError(int fabricIndex, long nodeId, long errorCode);
 
-  public boolean onTransferData(int fabricIndex, long nodeId, @Nonnull byte[] data, boolean isEof);
+  public void onSuccess(int fabricIndex, long nodeId);
+
+  public boolean onTransferData(int fabricIndex, long nodeId, @Nonnull byte[] data);
 }
diff --git a/src/protocols/bdx/BdxTransferDiagnosticLog.cpp b/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
index 9ab1054a3305d1..4804a01c578c26 100644
--- a/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
+++ b/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
@@ -156,7 +156,7 @@ CHIP_ERROR BdxTransferDiagnosticLog::OnBlockReceived(TransferSession::OutputEven
     VerifyOrReturnError(nullptr != mDelegate, CHIP_ERROR_INCORRECT_STATE);
 
     ByteSpan blockData(event.blockdata.Data, event.blockdata.Length);
-    return mDelegate->OnTransferData(&mTransferProxy, blockData, event.blockdata.IsEof);
+    return mDelegate->OnTransferData(&mTransferProxy, blockData);
 }
 
 void BdxTransferDiagnosticLog::AbortTransferOnFailure(CHIP_ERROR error)
diff --git a/src/protocols/bdx/BdxTransferServerDelegate.h b/src/protocols/bdx/BdxTransferServerDelegate.h
index 16d81209b4375b..e151ed8c5f09f9 100644
--- a/src/protocols/bdx/BdxTransferServerDelegate.h
+++ b/src/protocols/bdx/BdxTransferServerDelegate.h
@@ -46,17 +46,7 @@ class BDXTransferServerDelegate
      * @brief
      *  This method is invoked when a block is received.
      */
-    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data)
-    {
-        return CHIP_ERROR_NOT_IMPLEMENTED;
-    }
-
-    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data, bool isEof)
-    {
-        (void) isEof;
-
-        return OnTransferData(transfer, data);
-    }
+    virtual CHIP_ERROR OnTransferData(BDXTransferProxy * transfer, const ByteSpan & data) = 0;
 };
 
 } // namespace bdx

From d82e05e4708757516b2a3971590588fb1cff48e3 Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Fri, 29 Nov 2024 16:11:11 +0900
Subject: [PATCH 03/11] Restyled

---
 .../clusterclient/DiagnosticLogFragment.kt    | 15 ++--
 kotlin-detect-config.yaml                     |  1 +
 .../java/AndroidLogDownloadFromNode.cpp       | 73 +++++++++++--------
 .../java/AndroidLogDownloadFromNode.h         | 20 +++--
 src/controller/java/BUILD.gn                  |  2 +-
 .../java/BdxDiagnosticLogsReceiver.cpp        | 38 ++++++----
 .../java/BdxDiagnosticLogsReceiver.h          | 15 ++--
 .../java/CHIPDeviceController-JNI.cpp         |  9 ++-
 .../ChipDeviceController.java                 | 10 ++-
 9 files changed, 111 insertions(+), 72 deletions(-)

diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
index 26d09051814746..41da838f4ef103 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -21,7 +21,8 @@ import com.google.chip.chiptool.databinding.DiagnosticLogFragmentBinding
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 
 class DiagnosticLogFragment : Fragment() {
   private val deviceController: ChipDeviceController
@@ -87,18 +88,18 @@ class DiagnosticLogFragment : Fragment() {
       mDownloadFile?.let { showNotification(it) } ?: return
     }
 
-    override fun onTransferData(
-      fabricIndex: Int,
-      nodeId: Long,
-      data: ByteArray
-    ): Boolean {
+    override fun onTransferData(fabricIndex: Int, nodeId: Long, data: ByteArray): Boolean {
       Log.d(TAG, "onTransferData : ${data.size}")
       if (mDownloadFileOutputStream == null) {
         Log.d(TAG, "mDownloadFileOutputStream or mDownloadFile is null")
         return false
       }
+      return addData(mDownloadFileOutputStream!!, data)
+    }
+
+    private fun addData(outputStream: FileOutputStream, data: ByteArray): Boolean {
       try {
-        mDownloadFileOutputStream!!.write(data)
+        outputStream.write(data)
       } catch (e: IOException) {
         Log.d(TAG, "IOException", e)
         return false
diff --git a/kotlin-detect-config.yaml b/kotlin-detect-config.yaml
index 8470d1687dbe14..faa3a2a76604fd 100644
--- a/kotlin-detect-config.yaml
+++ b/kotlin-detect-config.yaml
@@ -231,6 +231,7 @@ exceptions:
             - "**/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Argument.kt"
     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/discover/DiscoverCommissionablesCommand.kt"
             - "**/src/controller/java/generated/java/**/*"
     ThrowingExceptionsWithoutMessageOrCause:
diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
index 2b766fa36c47f7..621ece6887fd57 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.cpp
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -18,10 +18,10 @@
 
 #include "AndroidLogDownloadFromNode.h"
 
-#include <controller/CHIPDeviceControllerFactory.h>
-#include <protocols/bdx/BdxUri.h>
 #include <app-common/zap-generated/cluster-enums.h>
 #include <app-common/zap-generated/cluster-objects.h>
+#include <controller/CHIPDeviceControllerFactory.h>
+#include <protocols/bdx/BdxUri.h>
 
 using namespace chip::app::Clusters;
 
@@ -30,8 +30,9 @@ namespace Controller {
 
 // Max Length is below 8
 CharSpan toIntentCharSpan(DiagnosticLogs::IntentEnum intent)
-{    
-    switch (intent) {
+{
+    switch (intent)
+    {
     case DiagnosticLogs::IntentEnum::kEndUserSupport:
         return CharSpan::fromCharString("EndUser");
     case DiagnosticLogs::IntentEnum::kNetworkDiag:
@@ -43,16 +44,17 @@ CharSpan toIntentCharSpan(DiagnosticLogs::IntentEnum intent)
     }
 }
 
-AndroidLogDownloadFromNode::AndroidLogDownloadFromNode(chip::Controller::DeviceController * controller, NodeId remoteNodeId, DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jCallbackObject)
- : mController(controller), mOnDeviceConnectedCallback(&OnDeviceConnectedFn, this),
-    mOnDeviceConnectionFailureCallback(&OnDeviceConnectionFailureFn, this),
-    mOnBdxTransferCallback(&OnBdxTransferCallback, this),
-    mOnBdxTransferSuccessCallback(&OnBdxTransferSuccessCallback, this),
+AndroidLogDownloadFromNode::AndroidLogDownloadFromNode(chip::Controller::DeviceController * controller, NodeId remoteNodeId,
+                                                       DiagnosticLogs::IntentEnum intent, uint16_t timeout,
+                                                       jobject jCallbackObject) :
+    mController(controller),
+    mOnDeviceConnectedCallback(&OnDeviceConnectedFn, this), mOnDeviceConnectionFailureCallback(&OnDeviceConnectionFailureFn, this),
+    mOnBdxTransferCallback(&OnBdxTransferCallback, this), mOnBdxTransferSuccessCallback(&OnBdxTransferSuccessCallback, this),
     mOnBdxTransferFailureCallback(&OnBdxTransferFailureCallback, this)
 {
     mRemoteNodeId = remoteNodeId;
-    mIntent = intent;
-    mTimeout = timeout;
+    mIntent       = intent;
+    mTimeout      = timeout;
 
     if (mJavaCallback.Init(jCallbackObject) != CHIP_NO_ERROR)
     {
@@ -61,9 +63,11 @@ AndroidLogDownloadFromNode::AndroidLogDownloadFromNode(chip::Controller::DeviceC
     }
 }
 
-CHIP_ERROR AndroidLogDownloadFromNode::LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jcallback)
+CHIP_ERROR AndroidLogDownloadFromNode::LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId,
+                                                           DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jcallback)
 {
-    VerifyOrReturnValue(controller != nullptr && jcallback != nullptr && remoteNodeId != kUndefinedNodeId, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnValue(controller != nullptr && jcallback != nullptr && remoteNodeId != kUndefinedNodeId,
+                        CHIP_ERROR_INVALID_ARGUMENT);
 
     auto * logDownload = new AndroidLogDownloadFromNode(controller, remoteNodeId, intent, timeout, jcallback);
     VerifyOrReturnValue(logDownload != nullptr, CHIP_ERROR_NO_MEMORY);
@@ -84,10 +88,11 @@ CHIP_ERROR AndroidLogDownloadFromNode::GetConnectedDevice()
     return mController->GetConnectedDevice(mRemoteNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
 }
 
-CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)
+CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr,
+                                                               const SessionHandle & sessionHandle)
 {
     DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
-    request.intent = mIntent;
+    request.intent            = mIntent;
     request.requestedProtocol = DiagnosticLogs::TransferProtocolEnum::kBdx;
 
     CHIP_ERROR err = chip::bdx::MakeURI(mRemoteNodeId, toIntentCharSpan(mIntent), mFileDesignator);
@@ -97,7 +102,9 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan
         FinishLogDownloadFromNode(err);
     }
 
-    mBdxReceiver = new BdxDiagnosticLogsReceiver(&mOnBdxTransferCallback, &mOnBdxTransferSuccessCallback, &mOnBdxTransferFailureCallback, mController->GetFabricIndex(), mRemoteNodeId, mFileDesignator);
+    mBdxReceiver =
+        new BdxDiagnosticLogsReceiver(&mOnBdxTransferCallback, &mOnBdxTransferSuccessCallback, &mOnBdxTransferFailureCallback,
+                                      mController->GetFabricIndex(), mRemoteNodeId, mFileDesignator);
     VerifyOrReturnValue(mBdxReceiver != nullptr, CHIP_ERROR_NO_MEMORY);
 
     auto systemState = DeviceControllerFactory::GetInstance().GetSystemState();
@@ -107,7 +114,7 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan
     {
         mBdxReceiver->StartBDXTransferTimeout(mTimeout);
     }
-    
+
     request.transferFileDesignator = MakeOptional(mFileDesignator);
     ClusterBase cluster(exchangeMgr, sessionHandle, 0);
 
@@ -115,7 +122,7 @@ CHIP_ERROR AndroidLogDownloadFromNode::SendRetrieveLogsRequest(Messaging::Exchan
 }
 
 void AndroidLogDownloadFromNode::OnDeviceConnectedFn(void * context, Messaging::ExchangeManager & exchangeMgr,
-                                               const SessionHandle & sessionHandle)
+                                                     const SessionHandle & sessionHandle)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     auto * self    = static_cast<AndroidLogDownloadFromNode *>(context);
@@ -139,7 +146,8 @@ void AndroidLogDownloadFromNode::OnDeviceConnectionFailureFn(void * context, con
     self->FinishLogDownloadFromNode(err);
 }
 
-void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context, const DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data)
+void AndroidLogDownloadFromNode::OnResponseRetrieveLogs(void * context,
+                                                        const DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data)
 {
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr,
@@ -189,7 +197,7 @@ void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err
 void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
 {
     CHIP_ERROR jniErr = CHIP_NO_ERROR;
-    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    JNIEnv * env      = JniReferences::GetInstance().GetEnvForCurrentThread();
     JniLocalReferenceScope scope(env);
 
     if (err == CHIP_NO_ERROR)
@@ -201,7 +209,8 @@ void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
 
         VerifyOrReturn(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(mJavaCallback.ObjectRef(), onSuccessMethod, static_cast<jint>(mController->GetFabricIndex()),
+                            static_cast<jlong>(mRemoteNodeId));
         return;
     }
 
@@ -222,10 +231,12 @@ void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
     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(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()), static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
+    env->CallVoidMethod(mJavaCallback.ObjectRef(), onErrorMethod, static_cast<jint>(mController->GetFabricIndex()),
+                        static_cast<jlong>(mRemoteNodeId), static_cast<jlong>(err.AsInteger()));
 }
 
-void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure)
+void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,
+                                                       const chip::ByteSpan & data, CHIP_ERROR * errInfoOnFailure)
 {
     auto * self = static_cast<AndroidLogDownloadFromNode *>(context);
     VerifyOrReturn(self != nullptr, ChipLogProgress(Controller, "Send command failure callback with null context. Ignoring"));
@@ -233,7 +244,8 @@ void AndroidLogDownloadFromNode::OnBdxTransferCallback(void * context, FabricInd
     self->OnTransferCallback(fabricIndex, remoteNodeId, data, errInfoOnFailure);
 }
 
-void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure)
+void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
+                                                    CHIP_ERROR * errInfoOnFailure)
 {
     VerifyOrReturn(mJavaCallback.HasValidObjectRef(), ChipLogError(Controller, "mJavaCallback is invalid"));
 
@@ -242,17 +254,17 @@ void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, Nod
 
     jmethodID onTransferDataMethod;
     // Java method signature : boolean onTransferData(int fabricIndex, long nodeId, byte[] data)
-    *errInfoOnFailure = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onTransferData",
-                                                             "(IJ[B)Z", &onTransferDataMethod);
+    *errInfoOnFailure =
+        JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onTransferData", "(IJ[B)Z", &onTransferDataMethod);
     VerifyOrReturn(*errInfoOnFailure == CHIP_NO_ERROR, ChipLogError(Controller, "Could not find onTransferData method"));
     chip::ByteArray dataByteArray(env, data);
 
-    jboolean ret = env->CallBooleanMethod(mJavaCallback.ObjectRef(), onTransferDataMethod, static_cast<jint>(fabricIndex), static_cast<jlong>(remoteNodeId), dataByteArray.jniValue());
+    jboolean ret = env->CallBooleanMethod(mJavaCallback.ObjectRef(), onTransferDataMethod, static_cast<jint>(fabricIndex),
+                                          static_cast<jlong>(remoteNodeId), dataByteArray.jniValue());
 
     if (ret != JNI_TRUE)
     {
-        ChipLogError(Controller, "Transfer will be rejected.")
-        *errInfoOnFailure = CHIP_ERROR_INTERNAL;
+        ChipLogError(Controller, "Transfer will be rejected.") * errInfoOnFailure = CHIP_ERROR_INTERNAL;
     }
 }
 
@@ -266,7 +278,8 @@ void AndroidLogDownloadFromNode::OnBdxTransferSuccessCallback(void * context, Fa
     self->FinishLogDownloadFromNode(CHIP_NO_ERROR);
 }
 
-void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status)
+void AndroidLogDownloadFromNode::OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId,
+                                                              CHIP_ERROR status)
 {
     ChipLogProgress(Controller, "OnBdxTransferFailureCallback: %" CHIP_ERROR_FORMAT, status.Format());
 
diff --git a/src/controller/java/AndroidLogDownloadFromNode.h b/src/controller/java/AndroidLogDownloadFromNode.h
index e10515823a5d00..9d5c3d098afde2 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.h
+++ b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -46,10 +46,13 @@ class AndroidLogDownloadFromNode
      * @param[in] timeout Download log timeout value. If this value is 0, controller does not handle timeouts.
      * @param[in] callback The callback to call when Log Download data is received and when an error occurs
      */
-    static CHIP_ERROR LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject jCallbackObject);
+    static CHIP_ERROR LogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId,
+                                          app::Clusters::DiagnosticLogs::IntentEnum intent, uint16_t timeout,
+                                          jobject jCallbackObject);
 
 private:
-    AndroidLogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent, uint16_t timeout, jobject javaCallback);
+    AndroidLogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent,
+                               uint16_t timeout, jobject javaCallback);
 
     DeviceController * mController;
 
@@ -67,20 +70,23 @@ class AndroidLogDownloadFromNode
     char mFileDesignatorBuffer[bdx::DiagnosticLogs::kMaxFileDesignatorLen];
     MutableCharSpan mFileDesignator = MutableCharSpan(mFileDesignatorBuffer, bdx::DiagnosticLogs::kMaxFileDesignatorLen);
 
-    BdxDiagnosticLogsReceiver *mBdxReceiver = nullptr;
-    
+    BdxDiagnosticLogsReceiver * mBdxReceiver = nullptr;
+
     CHIP_ERROR GetConnectedDevice();
     CHIP_ERROR SendRetrieveLogsRequest(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle);
-    void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
+    void OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
+                            CHIP_ERROR * errInfoOnFailure);
     void FinishLogDownloadFromNode(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);
 
-    static void OnResponseRetrieveLogs(void * context, const app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
+    static void OnResponseRetrieveLogs(void * context,
+                                       const app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
     static void OnCommandFailure(void * context, CHIP_ERROR err);
 
-    static void OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
+    static void OnBdxTransferCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
+                                      CHIP_ERROR * errInfoOnFailure);
     static void OnBdxTransferSuccessCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId);
     static void OnBdxTransferFailureCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
 };
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index c5a36dbaef978e..d969612f375de1 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -642,8 +642,8 @@ android_library("java") {
     "src/chip/devicecontroller/DeviceAttestation.java",
     "src/chip/devicecontroller/DeviceAttestationDelegate.java",
     "src/chip/devicecontroller/DiagnosticLogType.java",
-    "src/chip/devicecontroller/DownloadLogCallback.java",
     "src/chip/devicecontroller/DiscoveredDevice.java",
+    "src/chip/devicecontroller/DownloadLogCallback.java",
     "src/chip/devicecontroller/GroupKeySecurityPolicy.java",
     "src/chip/devicecontroller/ICDCheckInDelegate.java",
     "src/chip/devicecontroller/ICDCheckInDelegateWrapper.java",
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.cpp b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
index 7b6b0b510972f0..afb854024bd7ee 100644
--- a/src/controller/java/BdxDiagnosticLogsReceiver.cpp
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
@@ -25,14 +25,18 @@ namespace Controller {
 
 using namespace ::chip::DeviceLayer;
 
-BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferSuccess> * onSuccess, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator)
+BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer,
+                                                     Callback::Callback<OnBdxTransferSuccess> * onSuccess,
+                                                     Callback::Callback<OnBdxTransferFailure> * onFailure,
+                                                     chip::FabricIndex fabricIndex, chip::NodeId nodeId,
+                                                     chip::CharSpan fileDesignator)
 {
-    mOnBdxTransferCallback = onTransfer;
+    mOnBdxTransferCallback        = onTransfer;
     mOnBdxTransferSuccessCallback = onSuccess;
     mOnBdxTransferFailureCallback = onFailure;
 
-    mFabricIndex = fabricIndex;
-    mNodeId = nodeId;
+    mFabricIndex    = fabricIndex;
+    mNodeId         = nodeId;
     mFileDesignator = fileDesignator;
 }
 
@@ -40,7 +44,7 @@ CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferBegin(chip::bdx::BDXTransferProx
 {
     chip::CharSpan fileDesignator = transfer->GetFileDesignator();
     chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
-    chip::NodeId nodeId = transfer->GetPeerNodeId();
+    chip::NodeId nodeId           = transfer->GetPeerNodeId();
 
     if (mFileDesignator.data_equal(fileDesignator) && mFabricIndex == fabricIndex && mNodeId == nodeId)
     {
@@ -58,7 +62,7 @@ CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferEnd(chip::bdx::BDXTransferProxy
 {
     ChipLogProgress(Controller, "OnTransferEnd: %" CHIP_ERROR_FORMAT, error.Format());
     chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
-    chip::NodeId nodeId = transfer->GetPeerNodeId();
+    chip::NodeId nodeId           = transfer->GetPeerNodeId();
     if (error == CHIP_NO_ERROR)
     {
         mOnBdxTransferSuccessCallback->mCall(mOnBdxTransferCallback->mContext, fabricIndex, nodeId);
@@ -74,7 +78,7 @@ CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferData(chip::bdx::BDXTransferProxy
 {
     ChipLogProgress(Controller, "OnTransferData");
     chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
-    chip::NodeId nodeId = transfer->GetPeerNodeId();
+    chip::NodeId nodeId           = transfer->GetPeerNodeId();
 
     CHIP_ERROR err = CHIP_NO_ERROR;
 
@@ -93,21 +97,23 @@ CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferData(chip::bdx::BDXTransferProxy
 
 CHIP_ERROR BdxDiagnosticLogsReceiver::StartBDXTransferTimeout(uint16_t timeoutInSeconds)
 {
-  ChipLogProgress(Controller, "StartBDXTransferTimeout %u", timeoutInSeconds);
-  return chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds16(timeoutInSeconds), OnTransferTimeout, static_cast<void *>(this));
+    ChipLogProgress(Controller, "StartBDXTransferTimeout %u", timeoutInSeconds);
+    return chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds16(timeoutInSeconds), OnTransferTimeout,
+                                                       static_cast<void *>(this));
 }
 
 void BdxDiagnosticLogsReceiver::CancelBDXTransferTimeout()
 {
-  ChipLogProgress(Controller, "CancelBDXTransferTimeout");
-  chip::DeviceLayer::SystemLayer().CancelTimer(OnTransferTimeout, static_cast<void *>(this));
+    ChipLogProgress(Controller, "CancelBDXTransferTimeout");
+    chip::DeviceLayer::SystemLayer().CancelTimer(OnTransferTimeout, static_cast<void *>(this));
 }
 
 void BdxDiagnosticLogsReceiver::OnTransferTimeout(chip::System::Layer * layer, void * context)
 {
-  ChipLogProgress(Controller, "OnTransferTimeout");
-  auto * self    = static_cast<BdxDiagnosticLogsReceiver *>(context);
-  self->mOnBdxTransferFailureCallback->mCall(self->mOnBdxTransferFailureCallback->mContext, self->mFabricIndex, self->mNodeId, CHIP_ERROR_TIMEOUT);
+    ChipLogProgress(Controller, "OnTransferTimeout");
+    auto * self = static_cast<BdxDiagnosticLogsReceiver *>(context);
+    self->mOnBdxTransferFailureCallback->mCall(self->mOnBdxTransferFailureCallback->mContext, self->mFabricIndex, self->mNodeId,
+                                               CHIP_ERROR_TIMEOUT);
 }
-}
-}
\ No newline at end of file
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.h b/src/controller/java/BdxDiagnosticLogsReceiver.h
index 35156d5306be47..46cdbfab8e50a9 100644
--- a/src/controller/java/BdxDiagnosticLogsReceiver.h
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.h
@@ -26,7 +26,8 @@
 namespace chip {
 namespace Controller {
 
-typedef void (*OnBdxTransfer)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data, CHIP_ERROR *errInfoOnFailure);
+typedef void (*OnBdxTransfer)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
+                              CHIP_ERROR * errInfoOnFailure);
 typedef void (*OnBdxTransferSuccess)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId);
 typedef void (*OnBdxTransferFailure)(void * context, FabricIndex fabricIndex, NodeId remoteNodeId, CHIP_ERROR status);
 
@@ -35,7 +36,9 @@ constexpr uint32_t kMaxBDXReceiverURILen = 256;
 class BdxDiagnosticLogsReceiver : public chip::bdx::BDXTransferServerDelegate
 {
 public:
-    BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferSuccess> * onSuccess, Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex, chip::NodeId nodeId, chip::CharSpan fileDesignator);
+    BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTransfer> * onTransfer, Callback::Callback<OnBdxTransferSuccess> * onSuccess,
+                              Callback::Callback<OnBdxTransferFailure> * onFailure, chip::FabricIndex fabricIndex,
+                              chip::NodeId nodeId, chip::CharSpan fileDesignator);
 
     ~BdxDiagnosticLogsReceiver() {}
 
@@ -49,14 +52,14 @@ class BdxDiagnosticLogsReceiver : public chip::bdx::BDXTransferServerDelegate
 
 private:
     static void OnTransferTimeout(chip::System::Layer * layer, void * context);
-    
+
     chip::Callback::Callback<OnBdxTransfer> * mOnBdxTransferCallback;
     chip::Callback::Callback<OnBdxTransferSuccess> * mOnBdxTransferSuccessCallback;
     chip::Callback::Callback<OnBdxTransferFailure> * mOnBdxTransferFailureCallback;
 
     chip::FabricIndex mFabricIndex = kUndefinedFabricIndex;
-    chip::NodeId mNodeId = kUndefinedNodeId;
+    chip::NodeId mNodeId           = kUndefinedNodeId;
     chip::CharSpan mFileDesignator;
 };
-}
-}
\ No newline at end of file
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index 9f07ed43d95d19..e283b9739c6ba6 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -25,8 +25,8 @@
 #include "AndroidCommissioningWindowOpener.h"
 #include "AndroidCurrentFabricRemover.h"
 #include "AndroidDeviceControllerWrapper.h"
-#include "AndroidLogDownloadFromNode.h"
 #include "AndroidInteractionClient.h"
+#include "AndroidLogDownloadFromNode.h"
 #include <controller/java/ControllerConfig.h>
 #include <lib/support/CHIPJNIError.h>
 #include <lib/support/JniReferences.h>
@@ -2060,7 +2060,8 @@ JNI_METHOD(jboolean, openPairingWindowWithPINCallback)
     return true;
 }
 
-JNI_METHOD(void, downloadLogFromNode)(JNIEnv * env, jobject self, jlong handle, jlong deviceId, jint typeEnum, jint timeout, jobject downloadLogCallback)
+JNI_METHOD(void, downloadLogFromNode)
+(JNIEnv * env, jobject self, jlong handle, jlong deviceId, jint typeEnum, jint timeout, jobject downloadLogCallback)
 {
     chip::DeviceLayer::StackLock lock;
     CHIP_ERROR err                           = CHIP_NO_ERROR;
@@ -2068,7 +2069,9 @@ JNI_METHOD(void, downloadLogFromNode)(JNIEnv * env, jobject self, jlong handle,
 
     ChipLogProgress(Controller, "downloadLogFromNode() called with device ID and callback object");
 
-    err = AndroidLogDownloadFromNode::LogDownloadFromNode(wrapper->Controller(), static_cast<NodeId>(deviceId), static_cast<chip::app::Clusters::DiagnosticLogs::IntentEnum>(typeEnum), static_cast<uint16_t>(timeout), downloadLogCallback);
+    err = AndroidLogDownloadFromNode::LogDownloadFromNode(wrapper->Controller(), static_cast<NodeId>(deviceId),
+                                                          static_cast<chip::app::Clusters::DiagnosticLogs::IntentEnum>(typeEnum),
+                                                          static_cast<uint16_t>(timeout), downloadLogCallback);
 
     if (err != CHIP_NO_ERROR)
     {
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index 5f55b3f47fbbf4..11f0310448a417 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -883,7 +883,8 @@ public boolean openPairingWindowWithPINCallback(
         deviceControllerPtr, devicePtr, duration, iteration, discriminator, setupPinCode, callback);
   }
 
-  public boolean downloadLogFromNode(long deviceId, DiagnosticLogType type, int timeout, DownloadLogCallback callback) {
+  public boolean downloadLogFromNode(
+      long deviceId, DiagnosticLogType type, int timeout, DownloadLogCallback callback) {
     return downloadLogFromNode(deviceControllerPtr, deviceId, type.getValue(), timeout, callback);
   }
 
@@ -1731,7 +1732,12 @@ private native boolean openPairingWindowWithPINCallback(
       @Nullable Long setupPinCode,
       OpenCommissioningCallback callback);
 
-  private native boolean downloadLogFromNode(long deviceControllerPtr, long deviceId, int typeEnum, long timeout, DownloadLogCallback callback);
+  private native boolean downloadLogFromNode(
+      long deviceControllerPtr,
+      long deviceId,
+      int typeEnum,
+      long timeout,
+      DownloadLogCallback callback);
 
   private native byte[] getAttestationChallenge(long deviceControllerPtr, long devicePtr);
 

From 8a4894e688572eb5293a83fa4e754487ae8a6a0c Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Fri, 29 Nov 2024 16:31:02 +0900
Subject: [PATCH 04/11] Update DiagnosticLog UX (Download complete / failed)

---
 .../google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
index 41da838f4ef103..9332554911060e 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -79,12 +79,14 @@ class DiagnosticLogFragment : Fragment() {
   inner class ChipDownloadLogCallback : DownloadLogCallback {
     override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
       Log.d(TAG, "onError: $fabricIndex, ${nodeId.toULong()}, $errorCode")
+      showMessage("Downloading Failed")
       mDownloadFileOutputStream?.flush() ?: return
     }
 
     override fun onSuccess(fabricIndex: Int, nodeId: Long) {
       Log.d(TAG, "onSuccess: $fabricIndex, ${nodeId.toULong()}")
       mDownloadFileOutputStream?.flush() ?: return
+      showMessage("Downloading Completed")
       mDownloadFile?.let { showNotification(it) } ?: return
     }
 

From 8d219dfa29c6a2db506738837ef7c518c2d1d482 Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Fri, 29 Nov 2024 16:50:28 +0900
Subject: [PATCH 05/11] Fix timeout issue

---
 .../java/AndroidLogDownloadFromNode.cpp       | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
index 621ece6887fd57..77c0ae17181b3b 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.cpp
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -197,7 +197,17 @@ void AndroidLogDownloadFromNode::OnCommandFailure(void * context, CHIP_ERROR err
 void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
 {
     CHIP_ERROR jniErr = CHIP_NO_ERROR;
-    JNIEnv * env      = JniReferences::GetInstance().GetEnvForCurrentThread();
+    if (mBdxReceiver != nullptr)
+    {
+        if (mTimeout > 0)
+        {
+            mBdxReceiver->CancelBDXTransferTimeout();
+        }
+        delete mBdxReceiver;
+        mBdxReceiver = nullptr;
+    }
+
+    JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     JniLocalReferenceScope scope(env);
 
     if (err == CHIP_NO_ERROR)
@@ -214,16 +224,6 @@ void AndroidLogDownloadFromNode::FinishLogDownloadFromNode(CHIP_ERROR err)
         return;
     }
 
-    if (mBdxReceiver != nullptr)
-    {
-        if (mTimeout > 0)
-        {
-            mBdxReceiver->CancelBDXTransferTimeout();
-        }
-        delete mBdxReceiver;
-        mBdxReceiver = nullptr;
-    }
-
     ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
 
     jmethodID onErrorMethod;

From 8653d5656150dae72d2623986907e7c9652da81d Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Mon, 2 Dec 2024 06:57:51 +0900
Subject: [PATCH 06/11] Fix java-controller build error

---
 .../commands/bdx/DownloadLogCommand.kt        | 20 ++++++++-----------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
index d35ecff777409e..714837dc26c01f 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -51,19 +51,15 @@ class DownloadLogCommand(controller: ChipDeviceController, credsIssuer: Credenti
             println("FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode")
           }
 
-          override fun onTransferData(
-            fabricIndex: Int,
-            nodeId: Long,
-            data: ByteArray,
-            isEof: Boolean
-          ): Boolean {
+          override fun onSuccess(fabricIndex: Int, nodeId: Long) {
+            println()
+            println("FabricIndex : $fabricIndex, NodeID : $nodeId")
+            println(buffer.toString())
+            println("Log Download Finish!")
+          }
+
+          override fun onTransferData(fabricIndex: Int, nodeId: Long, data: ByteArray): Boolean {
             buffer.append(String(data))
-            if (isEof) {
-              println()
-              println("FabricIndex : $fabricIndex, NodeID : $nodeId")
-              println(buffer.toString())
-              println("Log Download Finish!")
-            }
             return true
           }
         }

From 6bfcb10b6329cc479b4b7a8657c04ec965a4df3f Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Tue, 3 Dec 2024 08:19:28 +0900
Subject: [PATCH 07/11] modify from comment

---
 .../matter/controller/commands/bdx/DownloadLogCommand.kt  | 2 +-
 src/controller/java/AndroidLogDownloadFromNode.cpp        | 2 ++
 src/controller/java/AndroidLogDownloadFromNode.h          | 8 ++++----
 src/controller/java/BdxDiagnosticLogsReceiver.cpp         | 2 ++
 .../src/chip/devicecontroller/DownloadLogCallback.java    | 2 +-
 5 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
index 714837dc26c01f..a406b7d9c5df42 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -1,5 +1,5 @@
 /*
- *   Copyright (c) 2023 Project CHIP Authors
+ *   Copyright (c) 2024 Project CHIP Authors
  *   All rights reserved.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/src/controller/java/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
index 77c0ae17181b3b..d37f1b727e7ed3 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.cpp
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -250,6 +250,8 @@ void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, Nod
     VerifyOrReturn(mJavaCallback.HasValidObjectRef(), ChipLogError(Controller, "mJavaCallback is invalid"));
 
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+    VerifyOrReturn(env != nullptr, ChipLogError(Controller, "Could not get JNIEnv for current thread"));
+
     JniLocalReferenceScope scope(env);
 
     jmethodID onTransferDataMethod;
diff --git a/src/controller/java/AndroidLogDownloadFromNode.h b/src/controller/java/AndroidLogDownloadFromNode.h
index 9d5c3d098afde2..1001a2d7a224b1 100644
--- a/src/controller/java/AndroidLogDownloadFromNode.h
+++ b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -54,7 +54,7 @@ class AndroidLogDownloadFromNode
     AndroidLogDownloadFromNode(DeviceController * controller, NodeId remoteNodeId, app::Clusters::DiagnosticLogs::IntentEnum intent,
                                uint16_t timeout, jobject javaCallback);
 
-    DeviceController * mController;
+    DeviceController * mController = nullptr;
 
     chip::Callback::Callback<OnDeviceConnected> mOnDeviceConnectedCallback;
     chip::Callback::Callback<OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
@@ -63,9 +63,9 @@ class AndroidLogDownloadFromNode
     chip::Callback::Callback<OnBdxTransferFailure> mOnBdxTransferFailureCallback;
 
     chip::JniGlobalReference mJavaCallback;
-    NodeId mRemoteNodeId;
-    app::Clusters::DiagnosticLogs::IntentEnum mIntent;
-    uint16_t mTimeout;
+    NodeId mRemoteNodeId                              = chip::kUndefinedNodeId;
+    app::Clusters::DiagnosticLogs::IntentEnum mIntent = app::Clusters::DiagnosticLogs::IntentEnum::kUnknownEnumValue;
+    uint16_t mTimeout                                 = 0;
 
     char mFileDesignatorBuffer[bdx::DiagnosticLogs::kMaxFileDesignatorLen];
     MutableCharSpan mFileDesignator = MutableCharSpan(mFileDesignatorBuffer, bdx::DiagnosticLogs::kMaxFileDesignatorLen);
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.cpp b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
index afb854024bd7ee..7e3c01bbaadc84 100644
--- a/src/controller/java/BdxDiagnosticLogsReceiver.cpp
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
@@ -42,6 +42,8 @@ BdxDiagnosticLogsReceiver::BdxDiagnosticLogsReceiver(Callback::Callback<OnBdxTra
 
 CHIP_ERROR BdxDiagnosticLogsReceiver::OnTransferBegin(chip::bdx::BDXTransferProxy * transfer)
 {
+    VerifyOrReturnError(transfer != nullptr, CHIP_ERROR_INVALID_ARGUMENT, ChipLogError(Controller, "transfer is nullptr."));
+
     chip::CharSpan fileDesignator = transfer->GetFileDesignator();
     chip::FabricIndex fabricIndex = transfer->GetFabricIndex();
     chip::NodeId nodeId           = transfer->GetPeerNodeId();
diff --git a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
index 3ceba50813599d..6ac2204fcf81ef 100644
--- a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
+++ b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
@@ -1,5 +1,5 @@
 /*
- *   Copyright (c) 2022 Project CHIP Authors
+ *   Copyright (c) 2024 Project CHIP Authors
  *   All rights reserved.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");

From 099a417aab44093a8617cd39c768d38d2130c453 Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Tue, 3 Dec 2024 15:35:08 +0900
Subject: [PATCH 08/11] Add javadoc, test cases

---
 .github/workflows/java-tests.yaml             | 11 +++
 examples/java-matter-controller/BUILD.gn      |  1 +
 .../java/src/com/matter/controller/Main.kt    |  1 +
 .../PairOnNetworkLongDownloadLogCommand.kt    | 95 +++++++++++++++++++
 scripts/tests/java/bdx_test.py                | 87 +++++++++++++++++
 scripts/tests/run_java_test.py                | 42 ++++++++
 .../ChipDeviceController.java                 |  9 ++
 .../devicecontroller/DownloadLogCallback.java | 21 ++++
 8 files changed, 267 insertions(+)
 create mode 100644 examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt
 create mode 100755 scripts/tests/java/bdx_test.py

diff --git a/.github/workflows/java-tests.yaml b/.github/workflows/java-tests.yaml
index 504cb865a9cc0b..473cd482357a75 100644
--- a/.github/workflows/java-tests.yaml
+++ b/.github/workflows/java-tests.yaml
@@ -236,6 +236,17 @@ jobs:
                      --tool-args "onnetwork-long --nodeid 1 --setup-pin-code 20202021 --discriminator 3840 -t 1000" \
                      --factoryreset \
                   '
+            - name: Run Pairing Onnetwork and get diagnostic log Test
+              run: |
+                  scripts/run_in_python_env.sh out/venv \
+                  './scripts/tests/run_java_test.py \
+                     --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app \
+                     --app-args "--discriminator 3840 --interface-id -1 --crash_log ./crashLog.log --end_user_support_log ./enduser.log --network_diagnostics_log ./network.log" \
+                     --tool-path out/linux-x64-java-matter-controller \
+                     --tool-cluster "bdx" \
+                     --tool-args "onnetwork-long-downloadLog --nodeid 1 --setup-pin-code 20202021 --discriminator 3840 -t 3000 --logType CrashLogs --fileName ./crashLog.log" \
+                     --factoryreset \
+                  '
             - name: Run Pairing Onnetwork Test
               run: |
                   scripts/run_in_python_env.sh out/venv \
diff --git a/examples/java-matter-controller/BUILD.gn b/examples/java-matter-controller/BUILD.gn
index 9cc452e75afeaf..287272d219f6cd 100644
--- a/examples/java-matter-controller/BUILD.gn
+++ b/examples/java-matter-controller/BUILD.gn
@@ -30,6 +30,7 @@ kotlin_binary("java-matter-controller") {
   sources = [
     "java/src/com/matter/controller/Main.kt",
     "java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt",
+    "java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt",
     "java/src/com/matter/controller/commands/common/Argument.kt",
     "java/src/com/matter/controller/commands/common/ArgumentType.kt",
     "java/src/com/matter/controller/commands/common/Command.kt",
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/Main.kt b/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
index 1ed725ba08d5df..e4807d604d53a9 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/Main.kt
@@ -87,6 +87,7 @@ private fun getBdxCommands(
 ): List<Command> {
   return listOf(
     DownloadLogCommand(controller, credentialsIssuer),
+    PairOnNetworkLongDownloadLogCommand(controller, credentialsIssuer),
   )
 }
 
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
new file mode 100644
index 00000000000000..e9c4f1ac024551
--- /dev/null
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt
@@ -0,0 +1,95 @@
+package com.matter.controller.commands.bdx
+
+import chip.devicecontroller.ChipDeviceController
+import chip.devicecontroller.DiagnosticLogType
+import chip.devicecontroller.DownloadLogCallback
+import com.matter.controller.commands.common.CredentialsIssuer
+import com.matter.controller.commands.pairing.DiscoveryFilterType
+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.logging.Level
+import java.util.logging.Logger
+
+class PairOnNetworkLongDownloadLogCommand(
+  controller: ChipDeviceController,
+  credsIssue: CredentialsIssuer?
+) :
+  PairingCommand(
+    controller,
+    "onnetwork-long-downloadLog",
+    credsIssue,
+    PairingModeType.ON_NETWORK,
+    PairingNetworkType.NONE,
+    DiscoveryFilterType.LONG_DISCRIMINATOR
+  ) {
+  private val buffer: StringBuffer = StringBuffer()
+  private val logType: StringBuffer = StringBuffer()
+  private val fileName: StringBuffer = StringBuffer()
+
+  init {
+    addArgument("logType", logType, null, false)
+    addArgument("fileName", fileName, null, false)
+  }
+
+  private inner class InternalDownloadLogCallback : DownloadLogCallback {
+    override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+      logger.log(
+        Level.WARNING,
+        "Error - FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode"
+      )
+      setFailure("onError : $errorCode")
+    }
+
+    override fun onSuccess(fabricIndex: Int, nodeId: Long) {
+      logger.log(Level.INFO, "FabricIndex : $fabricIndex, NodeID : $nodeId")
+      logger.log(Level.INFO, "FileName : $fileName")
+
+      val fileContent = File(fileName.toString()).readText()
+      if (fileContent.compareTo(buffer.toString()) != 0) {
+        setFailure("Invalid File Content")
+        return
+      }
+
+      setSuccess()
+    }
+
+    override fun onTransferData(fabricIndex: Int, nodeId: Long, data: ByteArray): Boolean {
+      buffer.append(String(data))
+      return true
+    }
+  }
+
+  override fun runCommand() {
+    currentCommissioner()
+      .pairDeviceWithAddress(
+        getNodeId(),
+        getRemoteAddr().address.hostAddress,
+        MATTER_PORT,
+        getDiscriminator(),
+        getSetupPINCode(),
+        null
+      )
+    currentCommissioner().setCompletionListener(this)
+    waitCompleteMs(getTimeoutMillis())
+    clear()
+    logger.log(Level.INFO, "Type : $logType")
+    logger.log(Level.INFO, "FileName : $fileName")
+    currentCommissioner()
+      .downloadLogFromNode(
+        getNodeId(),
+        DiagnosticLogType.value(logType.toString()),
+        (getTimeoutMillis() / 1000).toInt(),
+        InternalDownloadLogCallback()
+      )
+    logger.log(Level.INFO, "Waiting response : ${getTimeoutMillis()}")
+    waitCompleteMs(getTimeoutMillis())
+  }
+
+  companion object {
+    private val logger = Logger.getLogger(PairOnNetworkLongDownloadLogCommand::class.java.name)
+
+    private const val MATTER_PORT = 5540
+  }
+}
diff --git a/scripts/tests/java/bdx_test.py b/scripts/tests/java/bdx_test.py
new file mode 100755
index 00000000000000..60fe158b97f67e
--- /dev/null
+++ b/scripts/tests/java/bdx_test.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+#
+#    Copyright (c) 2024 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+import argparse
+import logging
+import queue
+import subprocess
+import threading
+import typing
+
+from colorama import Fore, Style
+from java.base import DumpProgramOutputToQueue
+
+
+class BDXTest:
+    def __init__(self, thread_list: typing.List[threading.Thread], queue: queue.Queue, cmd: [], args: str):
+        self.thread_list = thread_list
+        self.queue = queue
+        self.command = cmd
+
+        parser = argparse.ArgumentParser(description='Process pairing arguments.')
+
+        parser.add_argument('command', help="Command name")
+        parser.add_argument('-t', '--timeout', help="The program will return with timeout after specified seconds", default='200')
+        parser.add_argument('-a', '--address', help="Address of the device")
+        parser.add_argument('-p', '--port', help="Port of the remote device", default='5540')
+        parser.add_argument('-s', '--setup-payload', dest='setup_payload',
+                            help="Setup Payload (manual pairing code or QR code content)")
+        parser.add_argument('-c', '--setup-pin-code', dest='setup_pin_code',
+                            help=("Setup PIN code which can be used for password-authenticated "
+                                  "session establishment (PASE) with the Commissionee"))
+        parser.add_argument('-n', '--nodeid', help="The Node ID issued to the device", default='1')
+        parser.add_argument('-d', '--discriminator', help="Discriminator of the device", default='3840')
+        parser.add_argument('-u', '--paa-trust-store-path', dest='paa_trust_store_path',
+                            help="Path that contains valid and trusted PAA Root Certificates")
+        parser.add_argument('-g', '--logType', help="Diagnostic Log Type", default='EndUserSupport')
+        parser.add_argument('-f', '--fileName', help="Diagnostic Log File Name")
+
+        args = parser.parse_args(args.split())
+
+        self.command_name = args.command
+        self.nodeid = args.nodeid
+        self.address = args.address
+        self.port = args.port
+        self.setup_payload = args.setup_payload
+        self.setup_pin_code = args.setup_pin_code
+        self.discriminator = args.discriminator
+        self.timeout = args.timeout
+        self.logType = args.logType
+        self.fileName = args.fileName
+
+        logging.basicConfig(level=logging.INFO)
+
+    def TestCmdOnnetworkLongBDXDownloadLog(self, nodeid, setuppin, discriminator, timeout, logType, fileName):
+        java_command = self.command + ['bdx', 'onnetwork-long-downloadLog',
+                                       nodeid, setuppin, discriminator, timeout, logType, fileName]
+        logging.info(f"Execute: {java_command}")
+        java_process = subprocess.Popen(
+            java_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        DumpProgramOutputToQueue(self.thread_list, Fore.GREEN + "JAVA " + Style.RESET_ALL, java_process, self.queue)
+        return java_process.wait()
+
+    def RunTest(self):
+        if self.command_name == 'onnetwork-long-downloadLog':
+            logging.info("Testing pairing onnetwork-long-downloadLog")
+            code = self.TestCmdOnnetworkLongBDXDownloadLog(
+                self.nodeid, self.setup_pin_code, self.discriminator, self.timeout, self.logType, self.fileName)
+            if code != 0:
+                raise Exception(f"Testing pairing onnetwork-long-downloadLog failed with error {code}")
+        else:
+            raise Exception(f"Unsupported command {self.command_name}")
diff --git a/scripts/tests/run_java_test.py b/scripts/tests/run_java_test.py
index 2288dd71998fc7..de356d62b85582 100755
--- a/scripts/tests/run_java_test.py
+++ b/scripts/tests/run_java_test.py
@@ -27,6 +27,7 @@
 import coloredlogs
 from colorama import Fore, Style
 from java.base import DumpProgramOutputToQueue
+from java.bdx_test import BDXTest
 from java.commissioning_test import CommissioningTest
 from java.discover_test import DiscoverTest
 from java.im_test import IMTest
@@ -80,6 +81,37 @@ def main(app: str, app_args: str, tool_path: str, tool_cluster: str, tool_args:
                 raise FileNotFoundError(f"{app} not found")
         app_args = [app] + shlex.split(app_args)
         logging.info(f"Execute: {app_args}")
+
+        if '--crash_log' in app_args:
+            index = app_args.index('--crash_log')
+            fileName = app_args[index + 1]
+            logging.info(f"Crash Log FileName: {fileName}")
+            f = open(fileName, 'w')
+            for i in range(1, 1000):
+                data = "%d\n" % i
+                f.write(data)
+            f.close()
+
+        if '--network_diagnostics_log' in app_args:
+            index = app_args.index('--network_diagnostics_log')
+            fileName = app_args[index + 1]
+            logging.info(f"Network Diag Log FileName: {fileName}")
+            f = open(fileName, 'w')
+            for i in range(1, 500):
+                data = "%d\n" % i
+                f.write(data)
+            f.close()
+
+        if '--end_user_support_log' in app_args:
+            index = app_args.index('--end_user_support_log')
+            fileName = app_args[index + 1]
+            logging.info(f"EndUser Support Log FileName: {fileName}")
+            f = open(fileName, 'w')
+            for i in range(1, 10):
+                data = "%d\n" % i
+                f.write(data)
+            f.close()
+
         app_process = subprocess.Popen(
             app_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0)
         DumpProgramOutputToQueue(
@@ -123,6 +155,16 @@ def main(app: str, app_args: str, tool_path: str, tool_cluster: str, tool_args:
             logging.error(e)
             sys.exit(1)
 
+    elif tool_cluster == 'bdx':
+        logging.info("Testing BDX")
+
+        test = BDXTest(log_cooking_threads, log_queue, command, tool_args)
+        try:
+            test.RunTest()
+        except Exception as e:
+            logging.error(e)
+            sys.exit(1)
+
     app_exit_code = 0
     if app_process:
         logging.warning("Stopping app with SIGINT")
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index 11f0310448a417..bace224ac31e44 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -883,6 +883,15 @@ public boolean openPairingWindowWithPINCallback(
         deviceControllerPtr, devicePtr, duration, iteration, discriminator, setupPinCode, callback);
   }
 
+  /**
+   * This function is used for downloading logs from the device.
+   *
+   * @param deviceId The 64-bit node ID of the device.
+   * @param type The log type being downloaded. See detailed in {@link DiagnosticLogType}.
+   * @param timeout This function sets the timeout. If set to 0, there will be no timeout.
+   * @param callback The callback is registered to convey the status during log downloads. See
+   *     detailed in {@link DownloadLogCallback}.
+   */
   public boolean downloadLogFromNode(
       long deviceId, DiagnosticLogType type, int timeout, DownloadLogCallback callback) {
     return downloadLogFromNode(deviceControllerPtr, deviceId, type.getValue(), timeout, callback);
diff --git a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
index 6ac2204fcf81ef..e6245a180e8a66 100644
--- a/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
+++ b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
@@ -19,10 +19,31 @@
 
 import javax.annotation.Nonnull;
 
+/** An interface for receiving download log response. */
 public interface DownloadLogCallback {
+  /**
+   * OnError will be called when the log download fails.
+   *
+   * @param fabricIndex The fabric index of to which the node belongs
+   * @param nodeId The Node ID of the target device.
+   * @param errorCode Error code on attestation failure.
+   */
   public void onError(int fabricIndex, long nodeId, long errorCode);
 
+  /**
+   * onSuccess will be called when the log download is complete.
+   *
+   * @param fabricIndex The fabric index of to which the node belongs
+   * @param nodeId The Node ID of the target device.
+   */
   public void onSuccess(int fabricIndex, long nodeId);
 
+  /**
+   * onTransferData will be called when data is being received.
+   *
+   * @param fabricIndex The fabric index of to which the node belongs
+   * @param nodeId The Node ID of the target device.
+   * @param data Received log data.
+   */
   public boolean onTransferData(int fabricIndex, long nodeId, @Nonnull byte[] data);
 }

From 0b7a81452e350217660b2d8ab3d9ca55cabdea8d Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Tue, 3 Dec 2024 15:37:56 +0900
Subject: [PATCH 09/11] kotlin code style

---
 .../commands/bdx/PairOnNetworkLongDownloadLogCommand.kt        | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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
index e9c4f1ac024551..a9460b698abdfd 100644
--- 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
@@ -80,7 +80,7 @@ class PairOnNetworkLongDownloadLogCommand(
       .downloadLogFromNode(
         getNodeId(),
         DiagnosticLogType.value(logType.toString()),
-        (getTimeoutMillis() / 1000).toInt(),
+        (getTimeoutMillis() / MS_TO_SEC).toInt(),
         InternalDownloadLogCallback()
       )
     logger.log(Level.INFO, "Waiting response : ${getTimeoutMillis()}")
@@ -91,5 +91,6 @@ class PairOnNetworkLongDownloadLogCommand(
     private val logger = Logger.getLogger(PairOnNetworkLongDownloadLogCommand::class.java.name)
 
     private const val MATTER_PORT = 5540
+    private const val MS_TO_SEC = 1000
   }
 }

From a0feff9ab2dc595616d7ba79fd8be7c8a0a8627b Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Wed, 4 Dec 2024 09:20:14 +0900
Subject: [PATCH 10/11] Fix from comment

---
 .../chip/chiptool/clusterclient/DiagnosticLogFragment.kt      | 4 ++--
 src/controller/java/CHIPDeviceController-JNI.cpp              | 4 +++-
 .../java/src/chip/devicecontroller/ChipDeviceController.java  | 2 +-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
index 9332554911060e..ea7d5438d247c3 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -36,8 +36,8 @@ class DiagnosticLogFragment : Fragment() {
   private val binding
     get() = _binding!!
 
-  private val timeout: Int
-    get() = binding.timeoutEd.text.toString().toUIntOrNull()?.toInt() ?: 0
+  private val timeout: Long
+    get() = binding.timeoutEd.text.toString().toULongOrNull()?.toLong() ?: 0L
 
   private val diagnosticLogTypeList = DiagnosticLogType.values()
   private val diagnosticLogType: DiagnosticLogType
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index e283b9739c6ba6..1590bc14d9489d 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -2061,11 +2061,13 @@ JNI_METHOD(jboolean, openPairingWindowWithPINCallback)
 }
 
 JNI_METHOD(void, downloadLogFromNode)
-(JNIEnv * env, jobject self, jlong handle, jlong deviceId, jint typeEnum, jint timeout, jobject downloadLogCallback)
+(JNIEnv * env, jobject self, jlong handle, jlong deviceId, jint typeEnum, jlong timeout, jobject downloadLogCallback)
 {
     chip::DeviceLayer::StackLock lock;
     CHIP_ERROR err                           = CHIP_NO_ERROR;
     AndroidDeviceControllerWrapper * wrapper = AndroidDeviceControllerWrapper::FromJNIHandle(handle);
+    VerifyOrReturn(wrapper != nullptr,
+                   ChipLogError(Controller, "AndroidDeviceControllerWrapper::FromJNIHandle in downloadLogFromNode fails!"));
 
     ChipLogProgress(Controller, "downloadLogFromNode() called with device ID and callback object");
 
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index bace224ac31e44..c3249489749110 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -893,7 +893,7 @@ public boolean openPairingWindowWithPINCallback(
    *     detailed in {@link DownloadLogCallback}.
    */
   public boolean downloadLogFromNode(
-      long deviceId, DiagnosticLogType type, int timeout, DownloadLogCallback callback) {
+      long deviceId, DiagnosticLogType type, long timeout, DownloadLogCallback callback) {
     return downloadLogFromNode(deviceControllerPtr, deviceId, type.getValue(), timeout, callback);
   }
 

From 9a0100377825d60c25950597654ced2f6a4d263e Mon Sep 17 00:00:00 2001
From: Joonhaeng Heo <jh.heo@lge.com>
Date: Wed, 4 Dec 2024 10:09:16 +0900
Subject: [PATCH 11/11] Fix build error

---
 .../com/matter/controller/commands/bdx/DownloadLogCommand.kt    | 2 +-
 .../commands/bdx/PairOnNetworkLongDownloadLogCommand.kt         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
index a406b7d9c5df42..f2bb6b3ae904ad 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -44,7 +44,7 @@ class DownloadLogCommand(controller: ChipDeviceController, credsIssuer: Credenti
       .downloadLogFromNode(
         nodeId.toLong(),
         DiagnosticLogType.value(logType.toString()),
-        timeout.toInt(),
+        timeout.toLong(),
         object : DownloadLogCallback {
           override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
             println("error :")
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
index a9460b698abdfd..e58eda873e9823 100644
--- 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
@@ -80,7 +80,7 @@ class PairOnNetworkLongDownloadLogCommand(
       .downloadLogFromNode(
         getNodeId(),
         DiagnosticLogType.value(logType.toString()),
-        (getTimeoutMillis() / MS_TO_SEC).toInt(),
+        (getTimeoutMillis() / MS_TO_SEC).toLong(),
         InternalDownloadLogCallback()
       )
     logger.log(Level.INFO, "Waiting response : ${getTimeoutMillis()}")