llrp_manager.h

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of RDMnet. For more information, go to:
 * https://github.com/ETCLabs/RDMnet
 *****************************************************************************/
 
#ifndef RDMNET_CPP_LLRP_MANAGER_H_
#define RDMNET_CPP_LLRP_MANAGER_H_
 
#include <cstdint>
#include "etcpal/common.h"
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/opaque_id.h"
#include "etcpal/cpp/uuid.h"
#include "rdmnet/llrp_manager.h"
#include "rdmnet/cpp/common.h"
#include "rdmnet/cpp/message.h"
 
namespace rdmnet
{
 
namespace detail
{
class LlrpManagerHandleType
{
};
};  // namespace detail
 
namespace llrp
{
 
class DestinationAddr
{
public:
  constexpr DestinationAddr(const etcpal::Uuid& cid, const rdm::Uid& uid, uint16_t subdevice = 0);
 
  constexpr const LlrpDestinationAddr& get() const noexcept;
 
private:
  LlrpDestinationAddr addr_;
};
 
constexpr DestinationAddr::DestinationAddr(const etcpal::Uuid& cid, const rdm::Uid& uid, uint16_t subdevice)
    : addr_{cid.get(), uid.get(), subdevice}
{
}
 
constexpr const LlrpDestinationAddr& DestinationAddr::get() const noexcept
{
  return addr_;
}
 
struct DiscoveredTarget
{
  DiscoveredTarget() = default;
  constexpr DiscoveredTarget(const LlrpDiscoveredTarget& c_target) noexcept;
  DiscoveredTarget& operator=(const LlrpDiscoveredTarget& c_target) noexcept;
 
  constexpr DestinationAddr address(uint16_t subdevice = 0) const noexcept;
 
  const char* ComponentTypeToCString() const noexcept;
  std::string ComponentTypeToString() const;
 
  etcpal::Uuid     cid;               
  rdm::Uid         uid;               
  etcpal::MacAddr  hardware_address;  
  llrp_component_t component_type;    
};
 
constexpr DiscoveredTarget::DiscoveredTarget(const LlrpDiscoveredTarget& c_target) noexcept
    : cid(c_target.cid)
    , uid(c_target.uid)
    , hardware_address(c_target.hardware_address)
    , component_type(c_target.component_type)
{
}
 
inline DiscoveredTarget& DiscoveredTarget::operator=(const LlrpDiscoveredTarget& c_target) noexcept
{
  cid = c_target.cid;
  uid = c_target.uid;
  hardware_address = c_target.hardware_address;
  component_type = c_target.component_type;
  return *this;
}
 
constexpr DestinationAddr DiscoveredTarget::address(uint16_t subdevice) const noexcept
{
  return DestinationAddr(cid, uid, subdevice);
}
 
inline const char* DiscoveredTarget::ComponentTypeToCString() const noexcept
{
  return llrp_component_type_to_string(component_type);
}
 
inline std::string DiscoveredTarget::ComponentTypeToString() const
{
  return llrp_component_type_to_string(component_type);
}
 
class Manager
{
public:
  using Handle = etcpal::OpaqueId<detail::LlrpManagerHandleType, llrp_manager_t, LLRP_MANAGER_INVALID>;
 
  class NotifyHandler
  {
  public:
    virtual ~NotifyHandler() = default;
 
    virtual void HandleLlrpTargetDiscovered(Handle handle, const DiscoveredTarget& target) = 0;
 
    virtual void HandleLlrpRdmResponse(Handle handle, const RdmResponse& resp) = 0;
 
    virtual void HandleLlrpDiscoveryFinished(Handle handle) { ETCPAL_UNUSED_ARG(handle); }
  };
 
  Manager() = default;
  Manager(const Manager& other) = delete;
  Manager& operator=(const Manager& other) = delete;
  Manager(Manager&& other) = default;             
  Manager& operator=(Manager&& other) = default;  
 
  etcpal::Error Startup(NotifyHandler&      notify_handler,
                        uint16_t            manufacturer_id,
                        unsigned int        netint_index,
                        etcpal_iptype_t     ip_type = kEtcPalIpTypeV4,
                        const etcpal::Uuid& cid = etcpal::Uuid::OsPreferred());
  void          Shutdown();
 
  etcpal::Error              StartDiscovery(uint16_t filter = 0);
  etcpal::Error              StopDiscovery();
  etcpal::Expected<uint32_t> SendRdmCommand(const DestinationAddr& destination,
                                            rdmnet_command_class_t command_class,
                                            uint16_t               param_id,
                                            const uint8_t*         data = nullptr,
                                            uint8_t                data_len = 0);
  etcpal::Expected<uint32_t> SendGetCommand(const DestinationAddr& destination,
                                            uint16_t               param_id,
                                            const uint8_t*         data = nullptr,
                                            uint8_t                data_len = 0);
  etcpal::Expected<uint32_t> SendSetCommand(const DestinationAddr& destination,
                                            uint16_t               param_id,
                                            const uint8_t*         data = nullptr,
                                            uint8_t                data_len = 0);
 
  constexpr Handle         handle() const;
  constexpr NotifyHandler* notify_handler() const;
 
private:
  Handle         handle_;
  NotifyHandler* notify_{nullptr};
};
 
 
namespace internal
{
extern "C" inline void LlrpManagerLibCbTargetDiscovered(llrp_manager_t              handle,
                                                        const LlrpDiscoveredTarget* target,
                                                        void*                       context)
{
  if (target && context)
  {
    static_cast<Manager::NotifyHandler*>(context)->HandleLlrpTargetDiscovered(Manager::Handle(handle), *target);
  }
}
 
extern "C" inline void LlrpManagerLibCbRdmResponseReceived(llrp_manager_t         handle,
                                                           const LlrpRdmResponse* resp,
                                                           void*                  context)
{
  if (resp && context)
  {
    static_cast<Manager::NotifyHandler*>(context)->HandleLlrpRdmResponse(Manager::Handle(handle), *resp);
  }
}
 
extern "C" inline void LlrpManagerLibCbDiscoveryFinished(llrp_manager_t handle, void* context)
{
  if (context)
  {
    static_cast<Manager::NotifyHandler*>(context)->HandleLlrpDiscoveryFinished(Manager::Handle(handle));
  }
}
};  // namespace internal
 
 
inline etcpal::Error Manager::Startup(NotifyHandler&      notify_handler,
                                      uint16_t            manufacturer_id,
                                      unsigned int        netint_index,
                                      etcpal_iptype_t     ip_type,
                                      const etcpal::Uuid& cid)
{
  notify_ = &notify_handler;
 
  // clang-format off
  LlrpManagerConfig config = {
    cid.get(),
    {
      ip_type,
      netint_index
    },
    manufacturer_id,
    {
      internal::LlrpManagerLibCbTargetDiscovered,
      internal::LlrpManagerLibCbRdmResponseReceived,
      internal::LlrpManagerLibCbDiscoveryFinished,
      &notify_handler
    }
  };
  // clang-format on
 
  llrp_manager_t c_handle = LLRP_MANAGER_INVALID;
  etcpal::Error  result = llrp_manager_create(&config, &c_handle);
 
  handle_.SetValue(c_handle);
 
  return result;
}
 
inline void Manager::Shutdown()
{
  llrp_manager_destroy(handle_.value());
  handle_.Clear();
}
 
inline etcpal::Error Manager::StartDiscovery(uint16_t filter)
{
  return llrp_manager_start_discovery(handle_.value(), filter);
}
 
inline etcpal::Error Manager::StopDiscovery()
{
  return llrp_manager_stop_discovery(handle_.value());
}
 
inline etcpal::Expected<uint32_t> Manager::SendRdmCommand(const DestinationAddr& destination,
                                                          rdmnet_command_class_t command_class,
                                                          uint16_t               param_id,
                                                          const uint8_t*         data,
                                                          uint8_t                data_len)
{
  uint32_t       seq_num;
  etcpal_error_t res = llrp_manager_send_rdm_command(handle_.value(), &destination.get(), command_class, param_id, data,
                                                     data_len, &seq_num);
  return (res == kEtcPalErrOk ? seq_num : res);
}
 
inline etcpal::Expected<uint32_t> Manager::SendGetCommand(const DestinationAddr& destination,
                                                          uint16_t               param_id,
                                                          const uint8_t*         data,
                                                          uint8_t                data_len)
{
  uint32_t       seq_num;
  etcpal_error_t res =
      llrp_manager_send_get_command(handle_.value(), &destination.get(), param_id, data, data_len, &seq_num);
  return (res == kEtcPalErrOk ? seq_num : res);
}
 
inline etcpal::Expected<uint32_t> Manager::SendSetCommand(const DestinationAddr& destination,
                                                          uint16_t               param_id,
                                                          const uint8_t*         data,
                                                          uint8_t                data_len)
{
  uint32_t       seq_num;
  etcpal_error_t res =
      llrp_manager_send_set_command(handle_.value(), &destination.get(), param_id, data, data_len, &seq_num);
  return (res == kEtcPalErrOk ? seq_num : res);
}
 
constexpr Manager::Handle Manager::handle() const
{
  return handle_;
}
 
constexpr Manager::NotifyHandler* Manager::notify_handler() const
{
  return notify_;
}
 
};  // namespace llrp
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_LLRP_MANAGER_H_