peak_firmware_updater.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak/backend/peak_backend.h>
#include <peak/device/peak_device_descriptor.hpp>
#include <peak/device/peak_firmware_update_information.hpp>
#include <peak/device/peak_firmware_update_progress_observer.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
 
namespace peak
{
namespace core
{
using namespace std::chrono_literals;
 
class FirmwareUpdater final
{
public:
    FirmwareUpdater();
    ~FirmwareUpdater();
    FirmwareUpdater(const FirmwareUpdater& other) = delete;
    FirmwareUpdater& operator=(const FirmwareUpdater& other) = delete;
    FirmwareUpdater(FirmwareUpdater&& other) = delete;
    FirmwareUpdater& operator=(FirmwareUpdater&& other) = delete;
 
    std::vector<std::shared_ptr<FirmwareUpdateInformation>> CollectFirmwareUpdateInformation(
        const std::string& gufPath) const;
 
    std::vector<std::shared_ptr<FirmwareUpdateInformation>> CollectFirmwareUpdateInformation(
        const std::string& gufPath, const std::shared_ptr<DeviceDescriptor>& device) const;
 
    void UpdateDevice(const std::shared_ptr<DeviceDescriptor>& device,
        const std::shared_ptr<FirmwareUpdateInformation>& updateInformation,
        const FirmwareUpdateProgressObserver* progressObserver = nullptr,
        Timeout deviceResetDiscoveryTimeout = Timeout(60000ms));
 
private:
    PEAK_FIRMWARE_UPDATER_HANDLE m_backendHandle;
};
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline FirmwareUpdater::FirmwareUpdater()
    : m_backendHandle(QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATER_HANDLE>(
        [](PEAK_FIRMWARE_UPDATER_HANDLE* firmwareUpdaterHandle) {
            return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_Construct(firmwareUpdaterHandle);
        }))
{}
 
inline FirmwareUpdater::~FirmwareUpdater()
{
    (void)PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_Destruct(m_backendHandle);
}
 
inline std::vector<std::shared_ptr<FirmwareUpdateInformation>> FirmwareUpdater::CollectFirmwareUpdateInformation(
    const std::string& gufPath) const
{
    CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(
            m_backendHandle, gufPath.c_str(), gufPath.size() + 1);
    });
 
    auto numFirmwareUpdateInformation = QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* _numFirmwareUpdateInformation) {
            return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(
                m_backendHandle, _numFirmwareUpdateInformation);
        });
 
    std::vector<std::shared_ptr<FirmwareUpdateInformation>> firmwareUpdateInformation;
    for (size_t x = 0; x < numFirmwareUpdateInformation; ++x)
    {
        auto firmwareUpdateInformationHandle =
            QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE>(
                [&](PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE* _firmwareUpdateInformationHandle) {
                    return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(
                        m_backendHandle, x, _firmwareUpdateInformationHandle);
                });
 
        firmwareUpdateInformation.emplace_back(
            std::make_shared<ClassCreator<FirmwareUpdateInformation>>(firmwareUpdateInformationHandle));
    }
 
    return firmwareUpdateInformation;
}
 
inline std::vector<std::shared_ptr<FirmwareUpdateInformation>> FirmwareUpdater::CollectFirmwareUpdateInformation(
    const std::string& gufPath, const std::shared_ptr<DeviceDescriptor>& device) const
{
    if (device == nullptr)
    {
        throw InvalidArgumentException("The given device is a nullptr!");
    }
 
    CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(
            m_backendHandle, gufPath.c_str(), gufPath.size() + 1, device->m_backendHandle);
    });
 
    auto numFirmwareUpdateInformation = QueryNumericFromCInterfaceFunction<size_t>(
        [&](size_t* _numFirmwareUpdateInformation) {
            return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(
                m_backendHandle, _numFirmwareUpdateInformation);
        });
 
    std::vector<std::shared_ptr<FirmwareUpdateInformation>> firmwareUpdateInformation;
    for (size_t x = 0; x < numFirmwareUpdateInformation; ++x)
    {
        auto firmwareUpdateInformationHandle =
            QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE>(
                [&](PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE* _firmwareUpdateInformationHandle) {
                    return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(
                        m_backendHandle, x, _firmwareUpdateInformationHandle);
                });
 
        firmwareUpdateInformation.emplace_back(
            std::make_shared<ClassCreator<FirmwareUpdateInformation>>(firmwareUpdateInformationHandle));
    }
 
    return firmwareUpdateInformation;
}
 
inline void FirmwareUpdater::UpdateDevice(const std::shared_ptr<DeviceDescriptor>& device,
    const std::shared_ptr<FirmwareUpdateInformation>& updateInformation,
    const FirmwareUpdateProgressObserver* progressObserver /* = nullptr */,
    Timeout deviceResetDiscoveryTimeout /* = Timeout{ 60000ms }*/)
{
    if (device == nullptr)
    {
        throw InvalidArgumentException("The given device is a nullptr!");
    }
    if (updateInformation == nullptr)
    {
        throw InvalidArgumentException("The given updateInformation is a nullptr!");
    }
 
    CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(m_backendHandle,
            device->m_backendHandle, updateInformation->m_backendHandle,
            progressObserver ? progressObserver->m_backendHandle : nullptr, deviceResetDiscoveryTimeout);
    });
}
 
} /* namespace core */
} /* namespace peak */