ota.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2021 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
#ifndef OTA_H
#define OTA_H
 
// Unify Components
#include "uic_typedefs.h"
#include "sl_status.h"
 
// Standard library imports
#include <functional>
#include <string>
#include <ctime>
 
constexpr uint16_t DEFAULT_CLUSTER_REVISION = 1;
 
namespace uic_ota
{
enum class status_t {
  IDLE,                                  /*< Means the device is not currently
        * participating in any part of an OTA process. */
  DOWNLOAD_IN_PROGRESS,                  /*< One ore more firmware fragments
        * has been sent but the transfer is not complete. */
  WAITING_TO_UPGRADE,                    /*< Indicates that device has
        * transferred the image but has not yet updated. Possibly
        * because of the ApplyAfter timestamp has not yet passed.*/
  WAITING_TO_UPGRADE_VIA_EXTERNAL_EVENT, /*< Device need
        * external/manual activation to complete the update.*/
  WAIT_FOR_MORE,                         /*< Indicates that the client is still
        * waiting to receive more OTA upgrade image files from
        * the server. This is true for a client device that is
        * composed of multiple processors and each processor
        * requires different image or a system which requires
        * multiple images. The client SHALL be in this
        * state until it has received all necessary OTA
        * upgrade images, then it SHALL transition to Download
        * complete state.*/
};
 
enum class last_error_t {
  SUCCESS            = 0,  /* The operation was successful. */
  ABORT              = 1,  /*< Failed case when a client or a server decides
        * to abort the upgrade process.*/
  NOT_AUTHORIZED     = 2,  
  INVALID_IMAGE      = 3,  /*< Invalid OTA upgrade image (ex. failed
        * signature validation or signer information check or CRC
        * check) */
  REQUIRE_MORE_IMAGE = 4,  /*< The client still requires more OTA
        * upgrade image files in order to successfully upgrade */
  NOT_SUPPORTED      = 5,
};
 
enum class image_ready_result_t {
  OK,        
  TIMED_OUT, /*< image provider can be reached. however it took too long to
        receive and return the response. Request it dropped */
  ERROR,     
};
 
struct meta_t {
  std::string uiid;
  std::string unid;
  time_t apply_after;
  std::string version;
  std::string filename;
};
 
using image_available_func_t = std::function<void(const meta_t &)>;
 
using image_ready_funct_t
  = std::function<void(const image_ready_result_t, const std::string &)>;
 
sl_status_t init(const image_available_func_t &image_available_cb,
                 const std::string &image_base_path,
                 unsigned long int cache_size,
                 uint32_t timeout_s,
                 uint16_t cluster_revision = DEFAULT_CLUSTER_REVISION);
 
void subscribe_unid(const std::string &unid, const std::string &uiid);
 
void unsubscribe_unid(const std::string &unid, const std::string &uiid);
 
void unsubscribe_all_unids_uiid(const std::string &unid);
 
void get_by_unid(const std::string &unid,
                 const std::string &uiid,
                 const image_ready_funct_t &get_ready_cb);
 
void update_status(const dotdot_unid_t &unid,
                   const dotdot_endpoint_id_t &endpoint,
                   const ota_uiid_t &uiid,
                   const status_t status);
 
void update_size(const dotdot_unid_t &unid,
                 const dotdot_endpoint_id_t &endpoint,
                 const ota_uiid_t &uiid,
                 const size_t size_file);
 
void update_offset(const dotdot_unid_t &unid,
                   const dotdot_endpoint_id_t &endpoint,
                   const ota_uiid_t &uiid,
                   const size_t offset);
 
void update_last_error(const dotdot_unid_t &unid,
                       const dotdot_endpoint_id_t &endpoint,
                       const ota_uiid_t &uiid,
                       const last_error_t last_error);
 
void update_apply_after(const dotdot_unid_t &unid,
                        const dotdot_endpoint_id_t &endpoint,
                        const ota_uiid_t &uiid,
                        const time_t apply_after);
 
void update_current_version(const dotdot_unid_t &unid,
                            const dotdot_endpoint_id_t &endpoint,
                            const ota_uiid_t &uiid,
                            const std::string &current_version);
 
void update_target_version(const dotdot_unid_t &unid,
                           const dotdot_endpoint_id_t &endpoint,
                           const ota_uiid_t &uiid,
                           const std::string &target_version);
 
void clear_cache();
 
void unretain_ota_status();
 
void unretain_ota_status_by_unid(const dotdot_unid_t &unid);
 
};  // namespace uic_ota
#endif