suota.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================

#ifndef HF_CORE_SUOTA_H
#define HF_CORE_SUOTA_H

#include "hanfun/common.h"

#include "hanfun/protocol.h"
#include "hanfun/core.h"

namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace SUOTA
      {
         class Server;
      }

      HF::Attributes::IAttribute *create_attribute(SUOTA::Server *server, uint8_t uid);

      namespace SUOTA
      {
         typedef enum _CMD
         {
            NEW_VERSION_AVAILABLE_CMD = 1, 
            CHECK_VERSION_CMD         = 1, 
            UPGRADE_COMPLETE_CMD      = 2, 
            __LAST_CMD__              = UPGRADE_COMPLETE_CMD
         } CMD;

         // =============================================================================
         // Helper Classes
         // =============================================================================

         typedef enum _NewVersionResponse
         {
            UPGRADE_INITIATED    = 0x00,                 
            INVALID_SOFTWARE     = 0x11,                 
            UNSUPPORTED_HARDWARE = 0x12,                 
            BATTERY_TOO_LOW      = 0x13,                 
            FAIL_UNKNOWN         = Common::FAIL_UNKNOWN, 
         } NewVersionResponse;

         struct Version
         {
            std::string sw_version;    
            std::string hw_version;    
            std::string url;           

            Version(const std::string _sw_version = "",
                    const std::string _hw_version = "",
                    const std::string _url = ""):
               sw_version(_sw_version), hw_version(_hw_version), url(_url)
            {}

            static constexpr uint16_t min_size = 2 * sizeof(uint8_t);

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct CheckVersionResponse: public Protocol::Response, Version
         {
            typedef enum _Status
            {
               VERSION_AVAILABLE    = 0x00,                 
               NO_VERSION_AVAILABLE = 0x11,                 
               FAIL_INFRASTUCTURE   = 0x12,                 
               FAIL_UNKNOWN         = Common::FAIL_UNKNOWN, 
            } Status;

            CheckVersionResponse(Status _status = FAIL_UNKNOWN, const std::string _sw_version = "",
                                 const std::string _hw_version = "", const std::string _url = ""):
               Protocol::Response(_status),
               Version(_sw_version, _hw_version, _url) {}

            CheckVersionResponse(Common::Result _status):
               Protocol::Response(_status), Version() {}

            static constexpr uint16_t min_size = Protocol::Response::min_size + Version::min_size;

            uint16_t size() const
            {
               return Protocol::Response::size() + Version::size();
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, size());

               uint16_t start = offset;

               offset += Protocol::Response::pack(array, offset);
               offset += Version::pack(array, offset);

               return offset - start;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               uint16_t start = offset;

               uint16_t size  = Protocol::Response::unpack(array, offset);
               HF_ASSERT(size != 0, {return 0;});
               offset += size;
               size    = Version::unpack(array, offset);
               HF_ASSERT(size != 0, {return 0;});
               offset += size;

               return offset - start;
            }
         };

         struct UpgradeStatus
         {
            typedef enum _Status
            {
               UPGRADE_SUCCESSFUL  = 0x00,                 
               UPGRADE_ABORTED     = 0x11,                 
               GMEP_SESSION_ERROR  = 0x12,                 
               INVALID_IMAGE       = 0x13,                 
               MEMORY_ACCESS_ERROR = 0x14,                 
               BATTERY_TOO_LOW     = 0x15,                 
               FAIL_UNKNOWN        = Common::FAIL_UNKNOWN, 
            } Code;

            Code        code;       
            std::string sw_version; 

            UpgradeStatus(Code _code = FAIL_UNKNOWN, std::string _sw_version = ""):
               code(_code), sw_version(_sw_version) {}

            static constexpr uint16_t min_size = sizeof(uint8_t);

            uint16_t size() const
            {
               return sizeof(uint8_t) +
                      (sw_version.empty() ? 0 :
                       Common::SerializableHelper<std::string>::size(sw_version));
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, size());

               uint16_t start = offset;

               offset += array.write(offset, static_cast<uint8_t>(code));

               if (!sw_version.empty())
               {
                  offset +=
                     Common::SerializableHelper<std::string>::pack(sw_version, array, offset);
               }

               return offset - start;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               uint16_t start = offset;

               uint8_t temp;
               offset += array.read(offset, temp);
               code    = static_cast<Code>(temp);

               offset += Common::SerializableHelper<std::string>::unpack(sw_version, array, offset);

               return offset - start;
            }
         };

         // =============================================================================
         // Attributes API
         // =============================================================================

         HF::Attributes::IAttribute *create_attribute(uint8_t uid);

         struct Base: public Service<HF::Interface::SUOTA>
         {
            protected:

            Base(HF::Core::Unit0 &unit0): Service<HF::Interface::SUOTA>(unit0) {}
         };

         class Server: public ServiceRole<SUOTA::Base, HF::Interface::SERVER_ROLE>
         {
            public:

            Server(HF::Core::Unit0 &unit0):
               ServiceRole<SUOTA::Base, HF::Interface::SERVER_ROLE>(unit0) {}

            virtual ~Server() {}

            // ======================================================================
            // Commands
            // ======================================================================

            void new_version_available(const Protocol::Address &addr, const Version &version);

            void new_version_available(const Version &version)
            {
               Protocol::Address addr;
               new_version_available(addr, version);
            }

            // ======================================================================

            // ======================================================================
            // Events
            // ======================================================================

            virtual void new_version_available(const Protocol::Address &addr,
                                               NewVersionResponse result);

            virtual CheckVersionResponse check_version(const Protocol::Address &addr,
                                                       const Version &version);

            virtual void upgrade_complete(const Protocol::Address &addr,
                                          const UpgradeStatus &status);

            // ======================================================================
            protected:

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset);
         };

         struct Client: public ServiceRole<SUOTA::Base, HF::Interface::CLIENT_ROLE>
         {
            Client(HF::Core::Unit0 &unit0):
               ServiceRole<SUOTA::Base, HF::Interface::CLIENT_ROLE>(unit0) {}

            virtual ~Client() {}

            // ======================================================================
            // Commands
            // ======================================================================

#ifdef HF_CORE_SUOTA_CHECK_VERSION_CMD

            void check_version(const Protocol::Address &addr, const Version &version);

            void check_version(const Version &version)
            {
               Protocol::Address addr;
               check_version(addr, version);
            }
#endif

            void upgrade_complete(const Protocol::Address &addr, UpgradeStatus::Code status,
                                  std::string version = "");

            void upgrade_complete(UpgradeStatus::Code status, std::string version = "")
            {
               Protocol::Address addr;
               upgrade_complete(addr, status, version);
            }

            // ======================================================================

            // ======================================================================
            // Events
            // ======================================================================

            virtual NewVersionResponse new_version_available(const Protocol::Address &addr,
                                                             const Version &version);

            virtual void check_version(const Protocol::Address &addr,
                                       const CheckVersionResponse &response);

            // =============================================================================

            protected:

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset);
         };

      }  // namespace SUOTA

   }  // namespace Core

}   // namespace HF

// =============================================================================
// Stream Helpers
// =============================================================================

std::ostream &operator<<(std::ostream &stream, const HF::Core::SUOTA::CMD command);

#endif /* HF_CORE_SUOTA_H */