device_information.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_DEVICE_INFORMATION_H
#define HF_DEVICE_INFORMATION_H

#include "hanfun/common.h"

#include "hanfun/interface.h"

#include "hanfun/core.h"

// =============================================================================
// Defines
// =============================================================================

#ifndef HF_DEVICE_MANUFACTURER_CODE
   #warning "HF_DEVICE_MANUFACTURER_CODE not defined ! Using default value '0x0000'"
   #define HF_DEVICE_MANUFACTURER_CODE   0x0000
#endif

#ifndef HF_APPLICATION_VERSION
   #warning "HF_APPLICATION_VERSION not defined ! Using default empty value !"
   #define HF_APPLICATION_VERSION        ""
#endif

#ifndef HF_HARDWARE_VERSION
   #warning "HF_HARDWARE_VERSION not defined ! Using default empty value !"
   #define HF_HARDWARE_VERSION           ""
#endif

#ifndef HF_MANUFACTURER_NAME
   #warning "HF_MANUFACTURER_NAME not defined ! Using default empty value !"
   #define HF_MANUFACTURER_NAME          ""
#endif

// =============================================================================
// API
// =============================================================================
namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace DeviceInformation
      {
         struct Server;
      }  // namespace DeviceInformation

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

      namespace DeviceInformation
      {
         constexpr static uint8_t CORE_VERSION      = HF::CORE_VERSION;             
         constexpr static uint8_t PROFILE_VERSION   = HF::PROFILES_VERSION;         
         constexpr static uint8_t INTERFACE_VERSION = HF::INTERFACES_VERSION;       

         constexpr static uint16_t EMC              = HF_DEVICE_MANUFACTURER_CODE;  

#if HF_CORE_DEV_INFO_APP_VERSION_ATTR
         constexpr static _const char *APPLICATION_VERSION = HF_APPLICATION_VERSION; 
#endif
#if HF_CORE_DEV_INFO_HW_VERSION_ATTR
         constexpr static _const char *HARDWARE_VERSION = HF_HARDWARE_VERSION;       
#endif
#if HF_CORE_DEV_INFO_MANUFACTURER_NAME_ATTR
         constexpr static _const char *MANUFACTURER_NAME = HF_MANUFACTURER_NAME;     
#endif

         typedef enum _Attributes
         {
            CORE_VERSION_ATTR      = 0x01,   
            PROFILE_VERSION_ATTR   = 0x02,   
            INTERFACE_VERSION_ATTR = 0x03,   
            EXTRA_CAP_ATTR         = 0x04,   
            MIN_SLEEP_TIME_ATTR    = 0x05,   
            ACTUAL_RESP_TIME_ATTR  = 0x06,   
            APP_VERSION_ATTR       = 0x07,   
            HW_VERSION_ATTR        = 0x08,   
            EMC_ATTR               = 0x09,   
            DECT_ID_ATTR           = 0x0A,   
            MANUFACTURER_NAME_ATTR = 0x0B,   
            LOCATION_ATTR          = 0x0C,   
            ENABLED_ATTR           = 0x0D,   
            FRIENDLY_NAME_ATTR     = 0x0E,   
            UID_ATTR               = 0x0F,   
            SERIAL_NUMBER_ATTR     = 0x10,   
            __LAST_ATTR__          = SERIAL_NUMBER_ATTR,
         } Attributes;

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

         struct FriendlyName
         {
            struct Unit
            {
               uint8_t     id;
               std::string name;

               typedef HF::Common::SerializableHelper<std::string> string_helper;

               static constexpr uint16_t min_size = sizeof(uint8_t) + string_helper::min_size;

               uint16_t size() const;

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

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

            std::vector<Unit> units;

            static constexpr uint16_t min_size = sizeof(uint8_t);

            uint16_t size() const;

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

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

            float changed(const FriendlyName &other) const
            {
               UNUSED(other);
               return 0.0;
            }

            int compare(const FriendlyName &other) const;
         };

         class Base: public Service<HF::Interface::DEVICE_INFORMATION>
         {
            protected:

            Base(Unit0 &unit): Service<HF::Interface::DEVICE_INFORMATION>(unit) {}
         };

         struct Server: public ServiceRole<Base, HF::Interface::SERVER_ROLE>
         {
            HF::UID::UID device_uid;   

            Server(HF::Core::Unit0 &unit):
               ServiceRole<Base, HF::Interface::SERVER_ROLE>(unit), _capabilities(0)
            {}

            virtual ~Server() {}

            // =============================================================================
            // Interface Attribute API.
            // =============================================================================

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

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const;

            void paging(bool value);

            bool has_paging()  const;

            void broadcast(bool value);

            bool has_broadcast() const;

            void capabilities(uint8_t value);

            uint8_t capabilities();

#if HF_CORE_DEV_INFO_APP_VERSION_ATTR

            const std::string application_version() const
            {
               return std::string(APPLICATION_VERSION);
            }
#endif
#if HF_CORE_DEV_INFO_HW_VERSION_ATTR

            virtual const std::string hardware_version() const
            {
               return std::string(HARDWARE_VERSION);
            }
#endif
#if HF_CORE_DEV_INFO_MANUFACTURER_NAME_ATTR

            const std::string manufacturer_name() const
            {
               return std::string(MANUFACTURER_NAME);
            }
#endif
            protected:

            uint8_t _capabilities;
         };

         Protocol::Message *mandatory();

         Protocol::Message *all();

         Protocol::Message *get(HF::Attributes::UIDS &uids);

         Protocol::Message *get(uint8_t uid);

      }  // namespace DeviceInformation

   }  // namespace Core

}  // namespace HF

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

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::DeviceInformation::Attributes attribute);

#endif /* HF_DEVICE_INFORMATION_H */