unify_node_state_monitor.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2022 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 UNIFY_NODE_STATE_MONITOR_H
#define UNIFY_NODE_STATE_MONITOR_H
#include "sys/clock.h"
#include "ctimer.h"
 
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <nlohmann/json.hpp>
namespace unify::node_state_monitor
{
using endpoint_id_t = uint16_t;
 
static constexpr clock_time_t DEFAULT_NODE_STATE_FUNCTIONAL_THRESHOLD
  = 1 * CLOCK_SECOND;
static constexpr clock_time_t DEFAULT_NODE_STATE_FUNCTIONAL_TIMEOUT
  = 1 * CLOCK_SECOND;
 
class cluster
{
  public:
  std::string cluster_name;
  std::unordered_set<std::string> attributes;
  std::unordered_set<std::string> supported_commands;
  std::unordered_set<std::string> generated_commands;
  explicit cluster(const std::string &name) :
    cluster_name(name) {};
 
  std::string to_string() const;
};
 
class endpoint
{
  public:
  endpoint_id_t endpoint_id;
  std::unordered_map<std::string, cluster> clusters;
  explicit endpoint(endpoint_id_t id) : endpoint_id(id) {};
  cluster &emplace_cluster(const std::string &cluster_name);
 
  std::string to_string() const;
};
 
class node
{
  public:
  std::string unid;
  uint32_t state = 4;
  uint32_t security_info;
  std::unordered_map<endpoint_id_t, endpoint> endpoints;
  clock_time_t last_update;
  explicit node(const std::string &_unid) : unid(_unid)
  {
    last_update = clock_time();
  };
 
  endpoint &emplace_endpoint(endpoint_id_t endpoint_id);
 
  std::string to_string() const;
};
 
class node_state_monitor_interface
{
  public:
  virtual void on_unify_node_added(const node &node) = 0;
 
  virtual void on_unify_node_removed(const std::string &unid) = 0;
 
  virtual void on_unify_node_state_changed(const node &node) = 0;
 
  virtual ~node_state_monitor_interface() = default;
};
 
class node_state_monitor
{
  public:
  static node_state_monitor &get_instance()
  {
    // Singleton instance
    static node_state_monitor instance;
    return instance;
  };
 
  const std::unordered_map<std::string, node> &get_nodes() const
  {
    return nodes;
  };
 
  void set_node_state_functional_threshold(clock_time_t t);
 
  void set_node_state_functional_timeout_time(clock_time_t t);
 
  void set_interface(node_state_monitor_interface *_interface)
  {
    interface = _interface;
  }
 
  private:
  // Map of all nodes <UNID, node>
  std::unordered_map<std::string, node> nodes;
  // Set of nodes pending a on_unify_node_added callback.
  std::unordered_set<std::string> nodes_pending_node_added;
  // Timer used for delaying on_unify_node_added callback.
  struct ctimer node_state_functional_timer;
  // Threshold for delaying on_unify_node_added, the time a node shall have been
  // unchanged before a on_unify_node_added callback is issued.
  clock_time_t node_state_functional_threshold
    = DEFAULT_NODE_STATE_FUNCTIONAL_THRESHOLD;
  // Timeout for the timer that monitors node change thresholds.
  clock_time_t node_state_functional_timeout_time
    = DEFAULT_NODE_STATE_FUNCTIONAL_TIMEOUT;
 
  node_state_monitor_interface *interface;
  static void on_mqtt_node_state_message(const char *topic,
                                         const char *message,
                                         const size_t message_length);
 
  static void on_mqtt_cluster_supported_commands_message(
    const char *topic, const char *message, const size_t message_length);
 
  static void on_mqtt_cluster_supported_generated_commands_message(
    const char *topic, const char *message, const size_t message_length);
 
  static void on_mqtt_cluster_attributes(const char *topic,
                                         const char *message,
                                         const size_t message_length);
 
  node &emplace_node(const std::string &unid);
 
  void on_node_state_changed(const std::string &unid,
                             const nlohmann::json &jsn);
  void on_node_removed(const std::string &unid);
 
  void on_cluster_attribute_added(const std::string &unid,
                                  endpoint_id_t endpoint_id,
                                  const std::string &cluster_name,
                                  const std::string &attribute);
 
  void on_cluster_attribute_removed(const std::string &unid,
                                    endpoint_id_t endpoint_id,
                                    const std::string &cluster_name,
                                    const std::string &attribute);
 
  void on_cluster_supported_commands_added(const std::string &unid,
                                           endpoint_id_t endpoint_id,
                                           const std::string &cluster_name,
                                           const nlohmann::json &jsn);
 
  void on_cluster_supported_commands_removed(const std::string &unid,
                                             endpoint_id_t endpoint_id,
                                             const std::string &cluster_name);
 
  void on_cluster_generated_commands_added(const std::string &unid,
                                           endpoint_id_t endpoint_id,
                                           const std::string &cluster_name,
                                           const nlohmann::json &jsn);
 
  void on_cluster_generated_commands_removed(const std::string &unid,
                                             endpoint_id_t endpoint_id,
                                             const std::string &cluster_name);
 
  static void on_node_state_functional_timeout(void *context);
 
  // Delete copy constructor
  node_state_monitor(const node_state_monitor &) = delete;
  node_state_monitor const &operator=(const node_state_monitor &) = delete;
  node_state_monitor();
  ~node_state_monitor();
};
 
}  // namespace unify::node_state_monitor
 
#endif  //UNIFY_NODE_STATE_MONITOR_H