Implement BDXDownloader for new OTA Requestor API

examples/ota-requestor-app/linux/LinuxOTAImageProcessor.cpp

@@ -22,12 +22,6 @@
 
 namespace chip {
 
-// TODO: Dummy function to be removed once BDX downloader is implemented and can return a real instance
-OTADownloader * GetDownloaderInstance()
-{
-    return nullptr;
-}
-
 CHIP_ERROR LinuxOTAImageProcessor::PrepareDownload()
 {
     if (mParams.imageFile.empty())
@@ -83,29 +77,29 @@ CHIP_ERROR LinuxOTAImageProcessor::ProcessBlock(ByteSpan & block)
 
 void LinuxOTAImageProcessor::HandlePrepareDownload(intptr_t context)
 {
-    OTADownloader * downloader = GetDownloaderInstance();
-    if (downloader == nullptr)
+    auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+    if (imageProcessor == nullptr)
     {
-        ChipLogError(SoftwareUpdate, "No known OTA downloader");
+        ChipLogError(SoftwareUpdate, "ImageProcessor context is null");
         return;
     }
-
-    auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
-    if (imageProcessor == nullptr)
+    else if (imageProcessor->mDownloader == nullptr)
     {
-        downloader->OnPreparedForDownload(CHIP_ERROR_INVALID_ARGUMENT);
+        ChipLogError(SoftwareUpdate, "mDownloader is null");
         return;
     }
 
     imageProcessor->mOfs.open(imageProcessor->mParams.imageFile.data(),
                               std::ofstream::out | std::ofstream::ate | std::ofstream::app);
     if (!imageProcessor->mOfs.good())
     {
-        downloader->OnPreparedForDownload(CHIP_ERROR_OPEN_FAILED);
+        imageProcessor->mDownloader->OnPreparedForDownload(CHIP_ERROR_OPEN_FAILED);
         return;
     }
 
-    downloader->OnPreparedForDownload(CHIP_NO_ERROR);
+    // TODO: if file already exists and is not empty, erase previous contents
+
+    imageProcessor->mDownloader->OnPreparedForDownload(CHIP_NO_ERROR);
 }
 
 void LinuxOTAImageProcessor::HandleFinalize(intptr_t context)
@@ -118,6 +112,8 @@ void LinuxOTAImageProcessor::HandleFinalize(intptr_t context)
 
     imageProcessor->mOfs.close();
     imageProcessor->ReleaseBlock();
+
+    ChipLogProgress(SoftwareUpdate, "OTA image downloaded to %s", imageProcessor->mParams.imageFile.data());
 }
 
 void LinuxOTAImageProcessor::HandleAbort(intptr_t context)
@@ -135,17 +131,15 @@ void LinuxOTAImageProcessor::HandleAbort(intptr_t context)
 
 void LinuxOTAImageProcessor::HandleProcessBlock(intptr_t context)
 {
-    OTADownloader * downloader = GetDownloaderInstance();
-    if (downloader == nullptr)
+    auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+    if (imageProcessor == nullptr)
     {
-        ChipLogError(SoftwareUpdate, "No known OTA downloader");
+        ChipLogError(SoftwareUpdate, "ImageProcessor context is null");
         return;
     }
-
-    auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
-    if (imageProcessor == nullptr)
+    else if (imageProcessor->mDownloader == nullptr)
     {
-        downloader->OnBlockProcessed(CHIP_ERROR_INVALID_ARGUMENT, OTADownloader::kEnd);
+        ChipLogError(SoftwareUpdate, "mDownloader is null");
         return;
     }
 
@@ -154,12 +148,12 @@ void LinuxOTAImageProcessor::HandleProcessBlock(intptr_t context)
     if (!imageProcessor->mOfs.write(reinterpret_cast<const char *>(imageProcessor->mBlock.data()),
                                     static_cast<std::streamsize>(imageProcessor->mBlock.size())))
     {
-        downloader->OnBlockProcessed(CHIP_ERROR_WRITE_FAILED, OTADownloader::kEnd);
+        imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED);
         return;
     }
 
     imageProcessor->mParams.downloadedBytes += imageProcessor->mBlock.size();
-    downloader->OnBlockProcessed(CHIP_NO_ERROR, OTADownloader::kGetNext);
+    imageProcessor->mDownloader->FetchNextData();
 }
 
 CHIP_ERROR LinuxOTAImageProcessor::SetBlock(ByteSpan & block)

examples/ota-requestor-app/linux/LinuxOTAImageProcessor.h

@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <app/clusters/ota-requestor/OTADownloader.h>
 #include <app/clusters/ota-requestor/OTAImageProcessor.h>
 #include <platform/CHIPDeviceLayer.h>
 
@@ -34,6 +35,8 @@ class LinuxOTAImageProcessor : public OTAImageProcessorInterface
     CHIP_ERROR Abort() override;
     CHIP_ERROR ProcessBlock(ByteSpan & block) override;
 
+    void SetOTADownloader(chip::OTADownloader * downloader) { mDownloader = downloader; }
+
 private:
     //////////// Actual handlers for the OTAImageProcessorInterface ///////////////
     static void HandlePrepareDownload(intptr_t context);
@@ -53,6 +56,7 @@ class LinuxOTAImageProcessor : public OTAImageProcessorInterface
 
     std::ofstream mOfs;
     MutableByteSpan mBlock;
+    OTADownloader * mDownloader;
 };
 
 } // namespace chip

examples/ota-requestor-app/linux/main.cpp

@@ -25,9 +25,11 @@
 
 #include "LinuxOTAImageProcessor.h"
 #include "LinuxOTARequestorDriver.h"
+#include "app/clusters/ota-requestor/BDXDownloader.h"
 #include "app/clusters/ota-requestor/OTADownloader.h"
 #include "app/clusters/ota-requestor/OTARequestor.h"
 
+using chip::BDXDownloader;
 using chip::ByteSpan;
 using chip::CharSpan;
 using chip::DeviceProxy;
@@ -38,6 +40,7 @@ using chip::NodeId;
 using chip::OnDeviceConnected;
 using chip::OnDeviceConnectionFailure;
 using chip::OTADownloader;
+using chip::OTAImageProcessorParams;
 using chip::PeerId;
 using chip::Server;
 using chip::VendorId;
@@ -49,6 +52,11 @@ using namespace chip::ArgParser;
 using namespace chip::Messaging;
 using namespace chip::app::Clusters::OtaSoftwareUpdateProvider::Commands;
 
+OTARequestor requestorCore;
+LinuxOTARequestorDriver requestorUser;
+BDXDownloader downloader;
+LinuxOTAImageProcessor imageProcessor;
+
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue);
 void OnStartDelayTimerHandler(Layer * systemLayer, void * appState);
 
@@ -195,40 +203,39 @@ int main(int argc, char * argv[])
     SetDeviceAttestationCredentialsProvider(chip::Credentials::Examples::GetExampleDACProvider());
 
     // Initialize and interconnect the Requestor and Image Processor objects -- START
-    // Initialize the instance of the main Requestor Class
-    OTARequestor * requestorCore = new OTARequestor;
-    SetRequestorInstance(requestorCore);
-
-    // Initialize an instance of the Requestor Driver
-    LinuxOTARequestorDriver * requestorUser = new LinuxOTARequestorDriver;
+    SetRequestorInstance(&requestorCore);
 
     // Connect the Requestor and Requestor Driver objects
-    requestorCore->SetOtaRequestorDriver(requestorUser);
+    requestorCore.SetOtaRequestorDriver(&requestorUser);
 
-    // Initialize  the Downloader object
-    OTADownloader * downloaderCore = new OTADownloader;
-    // TODO: enable    SetDownloaderInstance(downloaderCore);
-
-    // Initialize the Image Processor object
-    LinuxOTAImageProcessor * downloaderUser = new LinuxOTAImageProcessor;
+    // WARNING: this is probably not realistic to know such details of the image or to even have an OTADownloader instantiated at
+    // the beginning of program execution. We're using hardcoded values here for now since this is a reference application.
+    // TODO: instatiate and initialize these values when QueryImageResponse tells us an image is available
+    // TODO: add API for OTARequestor to pass QueryImageResponse info to the application to use for OTADownloader init
+    OTAImageProcessorParams ipParams;
+    ipParams.imageFile = CharSpan("test.txt");
+    imageProcessor.SetOTAImageProcessorParams(ipParams);
+    imageProcessor.SetOTADownloader(&downloader);
 
     // Connect the Downloader and Image Processor objects
-    downloaderCore->SetImageProcessorDelegate(downloaderUser);
+    downloader.SetImageProcessorDelegate(&imageProcessor);
+
+    requestorCore.SetBDXDownloader(&downloader);
     // Initialize and interconnect the Requestor and Image Processor objects -- END
 
     // Pass the IP Address to the OTARequestor object: Use of explicit IP address is temporary
     // until the Exchange Layer implements address resolution
     {
         IPAddress ipAddr;
         IPAddress::FromString(ipAddress, ipAddr);
-        requestorCore->SetIpAddress(ipAddr);
+        requestorCore.SetIpAddress(ipAddr);
     }
 
     // Test Mode operation: If a delay is provided, QueryImage after the timer expires
     if (delayQueryTimeInSec > 0)
     {
         // In this mode Provider node ID and fabric idx must be supplied explicitly from program args
-        requestorCore->TestModeSetProviderParameters(providerNodeId, providerFabricIndex);
+        requestorCore.TestModeSetProviderParameters(providerNodeId, providerFabricIndex);
 
         chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(delayQueryTimeInSec * 1000),
                                                     OnStartDelayTimerHandler, nullptr);