zigpc_gateway_request_queue.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 ZIGPC_GATEWAY_CALL_HPP
#define ZIGPC_GATEWAY_CALL_HPP
 
#include <memory>
#include <queue>
#include <string>
 
// ZigPC includes
#include <zigpc_common_zigbee.h>
 
/* ZigbeeHost includes */
#include <zigbee_host.h>
 
namespace zigpc::gateway
{
class RequestQueue
{
  public:
  static const size_t DEFER_CYCLES_DEFAULT = 1U;
 
  static const size_t DEFER_CYCLES_START_BACKOFF = 20U;
 
  static const size_t DEFER_CYCLES_LOST_CONNECTION = 50U;
 
  static const size_t DEFER_CYCLES_MESSAGE_LIMIT_REACHED = 10U;
 
  class Entry
  {
    const char *label;         
    size_t send_attempts = 0U; 
    public:
    explicit Entry(const char *label);
    virtual ~Entry() = default;
 
    const char *getLabel(void) const;
 
    size_t getSendAttempts(void) const;
 
    void incrementSendAttempt(void);
 
    virtual sl_status_t invoke(void) = 0;
  };
 
  RequestQueue();
  RequestQueue(RequestQueue &other) = delete;
  void operator=(const RequestQueue &) = delete;
 
  static RequestQueue &getInstance();
 
  void stopDispatching();
 
  void startDispatching(void);
 
  void enqueue(std::shared_ptr<Entry> call);
 
  sl_status_t dispatch(void);
 
  private:
  std::queue<std::shared_ptr<Entry>> queue; 
  size_t defer_cycles = 0U; 
  bool dispatching_allowed = false; 
};
 
class NetworkInitRequest : public RequestQueue::Entry
{
  public:
  explicit NetworkInitRequest(void);
  ~NetworkInitRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class DiscoverDeviceRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t eui64; 
  public:
  explicit DiscoverDeviceRequest(const zigbee_eui64_t eui64);
  ~DiscoverDeviceRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class DiscoverEndpointRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t eui64;             
  zigbee_endpoint_id_t endpoint_id; 
  public:
  explicit DiscoverEndpointRequest(const zigbee_eui64_t eui64,
                                   zigbee_endpoint_id_t endpoint_id);
  ~DiscoverEndpointRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class DeviceRemoveRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t eui64; 
  public:
  explicit DeviceRemoveRequest(const zigbee_eui64_t eui64);
  ~DeviceRemoveRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class BindingRequestRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t source_eui64;             
  zigbee_endpoint_id_t source_endpoint_id; 
  zcl_cluster_id_t cluster_id;      
  zigbee_eui64_t dest_eui64;             
  zigbee_endpoint_id_t dest_endpoint_id; 
  bool is_binding_req;                  
  public:
  explicit BindingRequestRequest(const zigbee_eui64_t source_eui64,
                                 zigbee_endpoint_id_t source_endpoint_id,
                                 zcl_cluster_id_t cluster_id,
                                 const zigbee_eui64_t dest_eui64,
                                 zigbee_endpoint_id_t dest_endpoint_id,
                                 bool is_binding_req);
  ~BindingRequestRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class ZCLConfigureReportingRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t eui64;             
  zigbee_endpoint_id_t endpoint_id; 
  zcl_cluster_id_t cluster_id;      
  zcl_frame_t frame;                
  public:
  explicit ZCLConfigureReportingRequest(const zigbee_eui64_t eui64,
                                        zigbee_endpoint_id_t endpoint_id,
                                        zcl_cluster_id_t cluster_id,
                                        const uint8_t *report_record,
                                        unsigned int record_size);
  ~ZCLConfigureReportingRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class ZCLFrameUnicastRequest : public RequestQueue::Entry
{
  private:
  zigbee_eui64_t eui64;             
  zigbee_endpoint_id_t endpoint_id; 
  zcl_cluster_id_t cluster_id;      
  const zcl_frame_t frame;          
  public:
  explicit ZCLFrameUnicastRequest(const zigbee_eui64_t eui64,
                                  zigbee_endpoint_id_t endpoint_id,
                                  zcl_cluster_id_t cluster_id,
                                  const zcl_frame_t &frame);
  ~ZCLFrameUnicastRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class ZCLFrameMulticastRequest : public RequestQueue::Entry
{
  private:
  zigbee_group_id_t group_id;  
  zcl_cluster_id_t cluster_id; 
  const zcl_frame_t frame;     
  public:
  explicit ZCLFrameMulticastRequest(zigbee_group_id_t group_id,
                                    zcl_cluster_id_t cluster_id,
                                    const zcl_frame_t &frame);
  ~ZCLFrameMulticastRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
class AddOTAImageRequest : public RequestQueue::Entry
{
  private:
  std::string filename; 
  public:
  explicit AddOTAImageRequest(std::string &filename);
  ~AddOTAImageRequest() override = default;
 
  sl_status_t invoke(void) override;
};
 
}  // namespace zigpc::gateway
 
#endif  // ZIGPC_GATEWAY_CALL_HPP