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/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..ea7d5438d247c3
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/DiagnosticLogFragment.kt
@@ -0,0 +1,172 @@
+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 java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+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: Long
+    get() = binding.timeoutEd.text.toString().toULongOrNull()?.toLong() ?: 0L
+
+  private val diagnosticLogTypeList = DiagnosticLogType.values()
+  private val diagnosticLogType: DiagnosticLogType
+    get() = diagnosticLogTypeList[binding.diagnosticTypeSp.selectedItemPosition]
+
+  private var mDownloadFile: File? = null
+  private var mDownloadFileOutputStream: FileOutputStream? = null
+
+  private var mReceiveFileLen = 0U
+
+  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")
+      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
+    }
+
+    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 {
+        outputStream.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
+      )
+    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"
+    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)
+      }
+
+    requireActivity().startActivity(intent)
+  }
+
+  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"
+
+    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..56b770a645b442
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/res/layout/diagnostic_log_fragment.xml
@@ -0,0 +1,87 @@
+<?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"/>
+
+    <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/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 be620f83715a38..5c9e3d0e425f1d 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..287272d219f6cd 100644
--- a/examples/java-matter-controller/BUILD.gn
+++ b/examples/java-matter-controller/BUILD.gn
@@ -29,6 +29,8 @@ 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 a1a66a8420b196..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
@@ -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,16 @@ private fun getICDCommands(
   )
 }
 
+private fun getBdxCommands(
+  controller: ChipDeviceController,
+  credentialsIssuer: CredentialsIssuer
+): List<Command> {
+  return listOf(
+    DownloadLogCommand(controller, credentialsIssuer),
+    PairOnNetworkLongDownloadLogCommand(controller, credentialsIssuer),
+  )
+}
+
 fun main(args: Array<String>) {
   val controller =
     ChipDeviceController(
@@ -96,6 +107,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..f2bb6b3ae904ad
--- /dev/null
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/DownloadLogCommand.kt
@@ -0,0 +1,73 @@
+/*
+ *   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 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.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.toLong(),
+        object : DownloadLogCallback {
+          override fun onError(fabricIndex: Int, nodeId: Long, errorCode: Long) {
+            println("error :")
+            println("FabricIndex : $fabricIndex, NodeID : $nodeId, errorCode : $errorCode")
+          }
+
+          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))
+            return true
+          }
+        }
+      )
+    try {
+      TimeUnit.SECONDS.sleep(timeout.toLong())
+    } catch (e: InterruptedException) {
+      throw RuntimeException(e)
+    }
+  }
+}
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..e58eda873e9823
--- /dev/null
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/bdx/PairOnNetworkLongDownloadLogCommand.kt
@@ -0,0 +1,96 @@
+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() / MS_TO_SEC).toLong(),
+        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
+    private const val MS_TO_SEC = 1000
+  }
+}
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/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/AndroidLogDownloadFromNode.cpp b/src/controller/java/AndroidLogDownloadFromNode.cpp
new file mode 100644
index 00000000000000..d37f1b727e7ed3
--- /dev/null
+++ b/src/controller/java/AndroidLogDownloadFromNode.cpp
@@ -0,0 +1,294 @@
+/*
+ *
+ *    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 <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;
+
+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), mOnBdxTransferSuccessCallback(&OnBdxTransferSuccessCallback, 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, &mOnBdxTransferSuccessCallback, &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, &err);
+        self->FinishLogDownloadFromNode(err);
+    }
+    else if (data.status == StatusEnum::kNoLogs)
+    {
+        CHIP_ERROR err = CHIP_NO_ERROR;
+        self->OnTransferCallback(self->mController->GetFabricIndex(), self->mRemoteNodeId, ByteSpan(), &err);
+        self->FinishLogDownloadFromNode(err);
+    }
+    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)
+{
+    CHIP_ERROR jniErr = CHIP_NO_ERROR;
+    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)
+    {
+        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;
+    }
+
+    ChipLogError(Controller, "Log Download Failed : %" CHIP_ERROR_FORMAT, err.Format());
+
+    jmethodID onErrorMethod;
+    // Java method signature : void onError(int fabricIndex, long nodeId, long errorCode)
+    jniErr = JniReferences::GetInstance().FindMethod(env, mJavaCallback.ObjectRef(), "onError", "(IJJ)V", &onErrorMethod);
+    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, 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, errInfoOnFailure);
+}
+
+void AndroidLogDownloadFromNode::OnTransferCallback(FabricIndex fabricIndex, NodeId remoteNodeId, const chip::ByteSpan & data,
+                                                    CHIP_ERROR * errInfoOnFailure)
+{
+    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;
+    // Java method signature : boolean onTransferData(int fabricIndex, long nodeId, byte[] data)
+    *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());
+
+    if (ret != JNI_TRUE)
+    {
+        ChipLogError(Controller, "Transfer will be rejected.") * errInfoOnFailure = CHIP_ERROR_INTERNAL;
+    }
+}
+
+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());
+
+    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..1001a2d7a224b1
--- /dev/null
+++ b/src/controller/java/AndroidLogDownloadFromNode.h
@@ -0,0 +1,95 @@
+/*
+ *
+ *    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 = nullptr;
+
+    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;
+    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);
+
+    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 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,
+                                      CHIP_ERROR * errInfoOnFailure);
+    static void OnBdxTransferSuccessCallback(void * context, FabricIndex fabricIndex, NodeId remoteNodeId);
+    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..d969612f375de1 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,7 +641,9 @@ 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/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
new file mode 100644
index 00000000000000..7e3c01bbaadc84
--- /dev/null
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.cpp
@@ -0,0 +1,121 @@
+/*
+ *
+ *    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<OnBdxTransferSuccess> * onSuccess,
+                                                     Callback::Callback<OnBdxTransferFailure> * onFailure,
+                                                     chip::FabricIndex fabricIndex, chip::NodeId nodeId,
+                                                     chip::CharSpan fileDesignator)
+{
+    mOnBdxTransferCallback        = onTransfer;
+    mOnBdxTransferSuccessCallback = onSuccess;
+    mOnBdxTransferFailureCallback = onFailure;
+
+    mFabricIndex    = fabricIndex;
+    mNodeId         = nodeId;
+    mFileDesignator = fileDesignator;
+}
+
+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();
+
+    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());
+    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)
+{
+    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, &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);
+}
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/BdxDiagnosticLogsReceiver.h b/src/controller/java/BdxDiagnosticLogsReceiver.h
new file mode 100644
index 00000000000000..46cdbfab8e50a9
--- /dev/null
+++ b/src/controller/java/BdxDiagnosticLogsReceiver.h
@@ -0,0 +1,65 @@
+/*
+ *   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,
+                              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;
+
+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() {}
+
+    /////////// 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) 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<OnBdxTransferSuccess> * mOnBdxTransferSuccessCallback;
+    chip::Callback::Callback<OnBdxTransferFailure> * mOnBdxTransferFailureCallback;
+
+    chip::FabricIndex mFabricIndex = kUndefinedFabricIndex;
+    chip::NodeId mNodeId           = kUndefinedNodeId;
+    chip::CharSpan mFileDesignator;
+};
+} // namespace Controller
+} // namespace chip
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index 65f0d13f01d06e..1590bc14d9489d 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -26,6 +26,7 @@
 #include "AndroidCurrentFabricRemover.h"
 #include "AndroidDeviceControllerWrapper.h"
 #include "AndroidInteractionClient.h"
+#include "AndroidLogDownloadFromNode.h"
 #include <controller/java/ControllerConfig.h>
 #include <lib/support/CHIPJNIError.h>
 #include <lib/support/JniReferences.h>
@@ -2059,6 +2060,28 @@ JNI_METHOD(jboolean, openPairingWindowWithPINCallback)
     return true;
 }
 
+JNI_METHOD(void, downloadLogFromNode)
+(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");
+
+    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..c3249489749110 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -883,6 +883,20 @@ 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, long timeout, DownloadLogCallback callback) {
+    return downloadLogFromNode(deviceControllerPtr, deviceId, type.getValue(), timeout, callback);
+  }
+
   public int getFabricIndex() {
     return getFabricIndex(deviceControllerPtr);
   }
@@ -1727,6 +1741,13 @@ 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..e6245a180e8a66
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/DownloadLogCallback.java
@@ -0,0 +1,49 @@
+/*
+ *   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;
+
+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);
+}
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>