detail_fw_updater.hpp

#pragma once
 
#include <memory>
#include <stdexcept>
#include <vector>
#include <thread>
#include <chrono>
 
#include "../../_cexports/c_gen_api.h"
 
#include "../../global.hpp"
 
#include "../_decl/decl_node.hpp"
#include "../_decl/decl_node_map.hpp"
#include "../_decl/decl_fw_updater.hpp"
#include "../../device.hpp"
#include "../../device_factory.hpp"
#include "../node.hpp"
#include "../string_node.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace GenApi
  {
    inline std::unique_ptr<FWUpdater> FWUpdater::Create(const String &filename, bool verify)
    {
      std::string cname(Internal::CastToAscii(filename));
      auto firmwareUpdater = Internal::DoResCallObjectOut<FWUpdater>(
          [&](void *&handle) { return CVB_CALL_CAPI(CreateFirmwareUpdater(cname.c_str(), verify, handle)); }, filename);
      return firmwareUpdater;
    }
 
    inline FWUpdater::FWUpdater(const String &filename, bool verify)
        : FWUpdater(std::move(*Create(filename, verify)))
    {
    }
 
    inline FWUpdater::FWUpdater(HandleGuard<FWUpdater> &&guard, const String &filename, PrivateTag)
        : handle_(std::move(guard))
        , filename_(filename)
    {
    }
 
    inline std::unique_ptr<FWUpdater> FWUpdater::FromHandle(HandleGuard<FWUpdater> &&guard, const String &filename)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::make_unique<FWUpdater>(std::move(guard), filename, PrivateTag{});
    }
 
    inline size_t FWUpdater::UpdateFileCount()
    {
      return NativeCall<size_t>([&](size_t &count) { return CVB_CALL_CAPI(FWUpdateFileCount(Handle(), count)); });
    }
 
    inline size_t FWUpdater::UpdateFileInfoCount(const size_t &fileIndex)
    {
      return NativeCall<size_t>(
          [&](size_t &count) { return CVB_CALL_CAPI(FWUpdateFileInfoCount(Handle(), fileIndex, count)); });
    }
 
    inline String FWUpdater::UpdateFileInfo(size_t fileIndex, size_t infoIndex, FirmwareUpdateInfo cmd)
    {
      return NativeCall<String>([&](String &value) {
        std::size_t bufferSize = 0;
        auto bufferSizeResult  = CExports::FWUpdateFileInfoTyped(Handle(), fileIndex, infoIndex,
                                                                 static_cast<CExports::TFirmwareUpdateInfo>(cmd),
                                                                 reinterpret_cast<Char *>(0), bufferSize);
        if (bufferSizeResult < 0)
          return bufferSizeResult;
 
        std::vector<Char> buffer(bufferSize);
        auto bufferResult = CExports::FWUpdateFileInfoTyped(
            Handle(), fileIndex, infoIndex, static_cast<CExports::TFirmwareUpdateInfo>(cmd), buffer.data(), bufferSize);
        if (bufferResult < 0)
          return bufferResult;
 
        value = String(buffer.data());
        return bufferResult;
      });
    }
 
    inline std::vector<std::pair<String, String>> FWUpdater::AvailableGufInfo()
    {
      std::vector<std::pair<String, String>> availableGufInformation;
      auto updateFileCount = UpdateFileCount();
      // Check all available update files within guf file
      for (size_t updateFile = 0; updateFile < updateFileCount; updateFile++)
      {
        auto updateFileInfoCount = UpdateFileInfoCount(updateFile);
        // Check all available file infos for name
        for (size_t fileInfo = 0; fileInfo < updateFileInfoCount; fileInfo++)
        {
          auto key   = UpdateFileInfo(updateFile, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Key);
          auto value = UpdateFileInfo(updateFile, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Value);
          availableGufInformation.push_back(std::make_pair(key, value));
        }
      }
      return availableGufInformation;
    }
 
    inline std::vector<String> FWUpdater::AvailableUpdateFiles()
    {
      std::vector<String> availableFileDescriptions;
      auto updateFileCount = UpdateFileCount();
      // Check all available update files within guf file
      for (size_t updateFile = 0; updateFile < updateFileCount; updateFile++)
      {
        auto updateFileInfoCount = UpdateFileInfoCount(updateFile);
        // Check all available file infos for name
        String fileDescription;
        String fileFirmwareVersion;
        for (size_t fileInfo = 0; fileInfo < updateFileInfoCount; fileInfo++)
        {
          auto key   = UpdateFileInfo(updateFile, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Key);
          auto value = UpdateFileInfo(updateFile, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Value);
          if (key == CVB_LIT("Description"))
            fileDescription = value;
          if (key == CVB_LIT("Version"))
            fileFirmwareVersion = value;
        }
        availableFileDescriptions.push_back(fileDescription + CVB_LIT(" version ") + fileFirmwareVersion);
      }
      return availableFileDescriptions;
    }
 
    inline std::vector<String> FWUpdater::UpdateFileInfos(const size_t &updateFileIndex)
    {
      std::vector<String> availableFileInfos;
      auto updateFileInfoCount = UpdateFileInfoCount(updateFileIndex);
      for (size_t fileInfo = 0; fileInfo < updateFileInfoCount; fileInfo++)
      {
        auto key   = UpdateFileInfo(updateFileIndex, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Key);
        auto value = UpdateFileInfo(updateFileIndex, fileInfo, Cvb::GenApi::FirmwareUpdateInfo::Value);
        availableFileInfos.push_back(key + CVB_LIT(": ") + value);
      }
      return availableFileInfos;
    }
 
    inline void FWUpdater::Update(DevicePtr &&device, const size_t updateFileSelection)
    {
      SetDevice(std::move(device));
 
      NativeCall([&]() {
        return CVB_CALL_CAPI(
            FWUpdate(Handle(), deviceNM_->Handle(), updateFileSelection, &FWUpdater::EventOnDeviceReset, this));
      });
      device = std::move(device_);
    }
 
    inline CExports::cvbbool_t __stdcall FWUpdater::EventOnDeviceReset(unsigned int deviceDiscoveryTimeoutMs,
                                                                       unsigned int deviceDiscoveryDelayMs,
                                                                       CExports::NODEMAP &nodeMap, void *pPrivate)
    {
      try
      {
        auto fwu = reinterpret_cast<FWUpdater *>(pPrivate);
 
        // Let device and nodemap go
        fwu->ResetDevice();
 
        // Wait for device to reset
        std::this_thread::sleep_for(std::chrono::milliseconds(deviceDiscoveryDelayMs));
 
        // Discover device after reset
        auto startTime                           = std::chrono::high_resolution_clock::now();
        std::chrono::system_clock::rep runTimeMs = {0};
        do // NOLINT(cppcoreguidelines-avoid-do-while)
        {
          try
          {
            auto discover = Cvb::DeviceFactory::Discover(Cvb::Driver::DiscoverFlags::FindAll);
            for (const auto &device : discover)
            {
              // Open same device again an re-set new nodemap
              Cvb::String discoverSn{CVB_LIT("")};
              if (device.TryGetProperty(Cvb::Driver::DiscoveryProperties::DeviceSerialNumber, discoverSn))
              {
                if (fwu->DeviceSerialNumber() == discoverSn)
                {
                  // Poll device since its availability depends on the environment (like DHCP server etc.)
                  do // NOLINT(cppcoreguidelines-avoid-do-while)
                  {
                    try
                    {
                      DevicePtr dev = {Cvb::DeviceFactory::Open(device.AccessToken(), AcquisitionStack::PreferGenTL)};
                      fwu->SetDevice(std::move(dev));
                      nodeMap = fwu->deviceNM_->Handle();
                      return true;
                    }
                    catch (...) // NOLINT(bugprone-empty-catch)
                    {                      
                    }
                    auto endTime = std::chrono::high_resolution_clock::now();
                    runTimeMs    = (endTime - startTime) / std::chrono::milliseconds(1);
                  } while (runTimeMs < deviceDiscoveryTimeoutMs);
                }
              }
            }
          }
          catch (...) // NOLINT(bugprone-empty-catch)
          {
          }
          auto endTime = std::chrono::high_resolution_clock::now();
          runTimeMs    = (endTime - startTime) / std::chrono::milliseconds(1);
 
        } while (runTimeMs < deviceDiscoveryTimeoutMs);
        return false;  // Timeout
      }
      catch (...)
      {
        return false;
      }
    }
 
    inline String FWUpdater::DeviceSerialNumber() const
    {
      return deviceSn_;
    }
 
    inline void FWUpdater::SetDevice(DevicePtr &&device)
    {
      device_   = std::move(device);
      deviceNM_ = device_->NodeMap(CVB_LIT("Device"));
      deviceSn_ = deviceNM_->Node<StringNode>(CVB_LIT("DeviceSerialNumber"))->Value();
    }
 
    inline void FWUpdater::ResetDevice()
    {
      deviceNM_->Node<CommandNode>(CVB_LIT("DeviceReset"))->Execute();
      deviceNM_.reset();
      device_.reset();
    }
 
  }  // namespace GenApi
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb