controller.h

Go to the documentation of this file.

/******************************************************************************
 * 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_CONTROLLER_H_
#define RDMNET_CPP_CONTROLLER_H_
 
#include <algorithm>
#include <string>
#include <vector>
#include "etcpal/common.h"
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/uuid.h"
#include "etcpal/cpp/log.h"
#include "etcpal/cpp/opaque_id.h"
#include "rdm/cpp/uid.h"
#include "rdm/cpp/message.h"
#include "rdmnet/cpp/client.h"
#include "rdmnet/cpp/common.h"
#include "rdmnet/cpp/message.h"
#include "rdmnet/controller.h"
 
namespace rdmnet
{
 
namespace detail
{
class ControllerHandleType
{
};
};  // namespace detail
 
class Controller
{
public:
  using Handle = etcpal::OpaqueId<detail::ControllerHandleType, rdmnet_controller_t, RDMNET_CONTROLLER_INVALID>;
 
  class NotifyHandler
  {
  public:
    virtual ~NotifyHandler() = default;
 
    virtual void HandleConnectedToBroker(Handle                     controller_handle,
                                         ScopeHandle                scope_handle,
                                         const ClientConnectedInfo& info) = 0;
 
    virtual void HandleBrokerConnectFailed(Handle                         controller_handle,
                                           ScopeHandle                    scope_handle,
                                           const ClientConnectFailedInfo& info) = 0;
 
    virtual void HandleDisconnectedFromBroker(Handle                        controller_handle,
                                              ScopeHandle                   scope_handle,
                                              const ClientDisconnectedInfo& info) = 0;
 
    virtual void HandleClientListUpdate(Handle               controller_handle,
                                        ScopeHandle          scope_handle,
                                        client_list_action_t list_action,
                                        const RptClientList& list) = 0;
 
    virtual bool HandleRdmResponse(Handle controller_handle, ScopeHandle scope_handle, const RdmResponse& resp) = 0;
 
    virtual void HandleRptStatus(Handle controller_handle, ScopeHandle scope_handle, const RptStatus& status) = 0;
 
    virtual void HandleResponderIdsReceived(Handle                          controller_handle,
                                            ScopeHandle                     scope_handle,
                                            const DynamicUidAssignmentList& list)
    {
      ETCPAL_UNUSED_ARG(controller_handle);
      ETCPAL_UNUSED_ARG(scope_handle);
      ETCPAL_UNUSED_ARG(list);
    }
  };
 
  class RdmCommandHandler
  {
  public:
    virtual RdmResponseAction HandleRdmCommand(Handle            controller_handle,
                                               ScopeHandle       scope_handle,
                                               const RdmCommand& cmd) = 0;
 
    virtual RdmResponseAction HandleLlrpRdmCommand(Handle controller_handle, const llrp::RdmCommand& cmd)
    {
      ETCPAL_UNUSED_ARG(controller_handle);
      ETCPAL_UNUSED_ARG(cmd);
      return rdmnet::RdmResponseAction::SendNack(kRdmNRActionNotSupported);
    }
  };
 
  struct Settings
  {
    etcpal::Uuid cid;            
    rdm::Uid     uid;            
    std::string  search_domain;  
 
    bool create_llrp_target{false};
 
    Settings() = default;
    Settings(const etcpal::Uuid& new_cid, const rdm::Uid& new_uid);
    Settings(const etcpal::Uuid& new_cid, uint16_t manufacturer_id);
 
    bool IsValid() const;
  };
 
  struct RdmData
  {
    uint16_t model_id{0};
    uint32_t software_version_id{0};
    uint16_t product_category{E120_PRODUCT_CATEGORY_CONTROL_CONTROLLER};
 
    std::string manufacturer_label;        
    std::string device_model_description;  
    std::string software_version_label;    
    std::string device_label;              
    bool device_label_settable{false};     
 
    RdmData() = default;
    RdmData(uint16_t    new_model_id,
            uint32_t    new_software_version_id,
            const char* new_manufacturer_label,
            const char* new_device_model_description,
            const char* new_software_version_label,
            const char* new_device_label);
    RdmData(uint16_t           new_model_id,
            uint32_t           new_software_version_id,
            const std::string& new_manufacturer_label,
            const std::string& new_device_model_description,
            const std::string& new_software_version_label,
            const std::string& new_device_label);
 
    bool IsValid() const;
  };
 
  Controller() = default;
  Controller(const Controller& other) = delete;
  Controller& operator=(const Controller& other) = delete;
  Controller(Controller&& other) = default;             
  Controller& operator=(Controller&& other) = default;  
 
  etcpal::Error Startup(NotifyHandler& notify_handler, const Settings& settings, const RdmData& rdm_data);
  etcpal::Error Startup(NotifyHandler&     notify_handler,
                        const Settings&    settings,
                        RdmCommandHandler& rdm_handler,
                        uint8_t*           rdm_response_buf = nullptr);
  void          Shutdown(rdmnet_disconnect_reason_t disconnect_reason = kRdmnetDisconnectShutdown);
 
  etcpal::Expected<ScopeHandle> AddScope(const char*             id,
                                         const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  etcpal::Expected<ScopeHandle> AddScope(const std::string&      id,
                                         const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  etcpal::Expected<ScopeHandle> AddScope(const Scope& scope_config);
  etcpal::Expected<ScopeHandle> AddDefaultScope(const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  etcpal::Error                 RemoveScope(ScopeHandle scope_handle, rdmnet_disconnect_reason_t disconnect_reason);
  etcpal::Error                 ChangeScope(ScopeHandle                scope_handle,
                                            const char*                new_scope_id_str,
                                            rdmnet_disconnect_reason_t disconnect_reason,
                                            const etcpal::SockAddr&    new_static_broker_addr = etcpal::SockAddr{});
  etcpal::Error                 ChangeScope(ScopeHandle                scope_handle,
                                            const Scope&               new_scope_config,
                                            rdmnet_disconnect_reason_t disconnect_reason);
  etcpal::Error ChangeSearchDomain(const char* new_search_domain, rdmnet_disconnect_reason_t disconnect_reason);
 
  etcpal::Expected<uint32_t> SendRdmCommand(ScopeHandle            scope_handle,
                                            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(ScopeHandle            scope_handle,
                                            const DestinationAddr& destination,
                                            uint16_t               param_id,
                                            const uint8_t*         data = nullptr,
                                            uint8_t                data_len = 0);
  etcpal::Expected<uint32_t> SendSetCommand(ScopeHandle            scope_handle,
                                            const DestinationAddr& destination,
                                            uint16_t               param_id,
                                            const uint8_t*         data = nullptr,
                                            uint8_t                data_len = 0);
 
  etcpal::Error RequestClientList(ScopeHandle scope_handle);
  etcpal::Error RequestResponderIds(ScopeHandle scope_handle, const rdm::Uid* uids, size_t num_uids);
  etcpal::Error RequestResponderIds(ScopeHandle scope_handle, const std::vector<rdm::Uid>& uids);
 
  etcpal::Error SendRdmAck(ScopeHandle            scope_handle,
                           const SavedRdmCommand& received_cmd,
                           const uint8_t*         response_data = nullptr,
                           size_t                 response_data_len = 0);
  etcpal::Error SendRdmNack(ScopeHandle            scope_handle,
                            const SavedRdmCommand& received_cmd,
                            rdm_nack_reason_t      nack_reason);
  etcpal::Error SendRdmNack(ScopeHandle scope_handle, const SavedRdmCommand& received_cmd, uint16_t raw_nack_reason);
  etcpal::Error SendRdmUpdate(ScopeHandle    scope_handle,
                              uint16_t       param_id,
                              const uint8_t* data = nullptr,
                              size_t         data_len = 0);
 
  etcpal::Error SendLlrpAck(const llrp::SavedRdmCommand& received_cmd,
                            const uint8_t*               response_data = nullptr,
                            uint8_t                      response_data_len = 0);
  etcpal::Error SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason);
  etcpal::Error SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, uint16_t raw_nack_reason);
 
  Handle                         handle() const;
  const RdmData&                 rdm_data() const;
  Controller::NotifyHandler*     notify_handler() const;
  Controller::RdmCommandHandler* rdm_command_handler() const;
  etcpal::Expected<Scope>        scope(ScopeHandle scope_handle) const;
 
  void UpdateRdmData(const RdmData& new_data);
 
private:
  Handle  handle_;
  RdmData my_rdm_data_;
 
  RdmCommandHandler* rdm_cmd_handler_{nullptr};
  NotifyHandler*     notify_{nullptr};
};
 
 
namespace internal
{
extern "C" inline void ControllerLibCbConnected(rdmnet_controller_t              controller_handle,
                                                rdmnet_client_scope_t            scope_handle,
                                                const RdmnetClientConnectedInfo* info,
                                                void*                            context)
{
  if (info && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleConnectedToBroker(Controller::Handle(controller_handle),
                                                                              ScopeHandle(scope_handle), *info);
  }
}
 
extern "C" inline void ControllerLibCbConnectFailed(rdmnet_controller_t                  controller_handle,
                                                    rdmnet_client_scope_t                scope_handle,
                                                    const RdmnetClientConnectFailedInfo* info,
                                                    void*                                context)
{
  if (info && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleBrokerConnectFailed(Controller::Handle(controller_handle),
                                                                                ScopeHandle(scope_handle), *info);
  }
}
 
extern "C" inline void ControllerLibCbDisconnected(rdmnet_controller_t                 controller_handle,
                                                   rdmnet_client_scope_t               scope_handle,
                                                   const RdmnetClientDisconnectedInfo* info,
                                                   void*                               context)
{
  if (info && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleDisconnectedFromBroker(
        Controller::Handle(controller_handle), ScopeHandle(scope_handle), *info);
  }
}
 
extern "C" inline void ControllerLibCbClientListUpdate(rdmnet_controller_t        controller_handle,
                                                       rdmnet_client_scope_t      scope_handle,
                                                       client_list_action_t       list_action,
                                                       const RdmnetRptClientList* list,
                                                       void*                      context)
{
  if (list && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleClientListUpdate(
        Controller::Handle(controller_handle), ScopeHandle(scope_handle), list_action, *list);
  }
}
 
extern "C" inline bool ControllerLibCbRdmResponseReceived(rdmnet_controller_t      controller_handle,
                                                          rdmnet_client_scope_t    scope_handle,
                                                          const RdmnetRdmResponse* resp,
                                                          void*                    context)
{
  if (resp && context)
  {
    return static_cast<Controller::NotifyHandler*>(context)->HandleRdmResponse(Controller::Handle(controller_handle),
                                                                               ScopeHandle(scope_handle), *resp);
  }
 
  return true;  // Error condition, drop response.
}
 
extern "C" inline void ControllerLibCbStatusReceived(rdmnet_controller_t    controller_handle,
                                                     rdmnet_client_scope_t  scope_handle,
                                                     const RdmnetRptStatus* status,
                                                     void*                  context)
{
  if (status && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleRptStatus(Controller::Handle(controller_handle),
                                                                      ScopeHandle(scope_handle), *status);
  }
}
 
extern "C" inline void ControllerLibCbResponderIdsReceived(rdmnet_controller_t                   controller_handle,
                                                           rdmnet_client_scope_t                 scope_handle,
                                                           const RdmnetDynamicUidAssignmentList* list,
                                                           void*                                 context)
{
  if (list && context)
  {
    static_cast<Controller::NotifyHandler*>(context)->HandleResponderIdsReceived(Controller::Handle(controller_handle),
                                                                                 ScopeHandle(scope_handle), *list);
  }
}
 
extern "C" inline void ControllerLibCbRdmCommandReceived(rdmnet_controller_t     controller_handle,
                                                         rdmnet_client_scope_t   scope_handle,
                                                         const RdmnetRdmCommand* cmd,
                                                         RdmnetSyncRdmResponse*  response,
                                                         void*                   context)
{
  if (cmd && response && context)
  {
    *response = static_cast<Controller::RdmCommandHandler*>(context)
                    ->HandleRdmCommand(Controller::Handle(controller_handle), ScopeHandle(scope_handle), *cmd)
                    .get();
  }
}
 
extern "C" inline void ControllerLibCbLlrpRdmCommandReceived(rdmnet_controller_t    controller_handle,
                                                             const LlrpRdmCommand*  cmd,
                                                             RdmnetSyncRdmResponse* response,
                                                             void*                  context)
{
  if (cmd && response && context)
  {
    *response = static_cast<Controller::RdmCommandHandler*>(context)
                    ->HandleLlrpRdmCommand(Controller::Handle(controller_handle), *cmd)
                    .get();
  }
}
 
};  // namespace internal
 
 
inline Controller::Settings::Settings(const etcpal::Uuid& new_cid, const rdm::Uid& new_uid) : cid(new_cid), uid(new_uid)
{
}
 
inline Controller::Settings::Settings(const etcpal::Uuid& new_cid, uint16_t manufacturer_id)
    : cid(new_cid), uid(rdm::Uid::DynamicUidRequest(manufacturer_id))
{
}
 
inline bool Controller::Settings::IsValid() const
{
  return (!cid.IsNull() && (uid.IsStatic() || uid.IsDynamicUidRequest()));
}
 
inline Controller::RdmData::RdmData(uint16_t    new_model_id,
                                    uint32_t    new_software_version_id,
                                    const char* new_manufacturer_label,
                                    const char* new_device_model_description,
                                    const char* new_software_version_label,
                                    const char* new_device_label)
    : model_id(new_model_id), software_version_id(new_software_version_id)
{
  if (new_manufacturer_label)
    manufacturer_label = std::string(new_manufacturer_label);
 
  if (new_device_model_description)
    device_model_description = std::string(new_device_model_description);
 
  if (new_software_version_label)
    software_version_label = std::string(new_software_version_label);
 
  if (new_device_label)
    device_label = std::string(new_device_label);
}
 
inline Controller::RdmData::RdmData(uint16_t           new_model_id,
                                    uint32_t           new_software_version_id,
                                    const std::string& new_manufacturer_label,
                                    const std::string& new_device_model_description,
                                    const std::string& new_software_version_label,
                                    const std::string& new_device_label)
    : model_id(new_model_id)
    , software_version_id(new_software_version_id)
    , manufacturer_label(new_manufacturer_label)
    , device_model_description(new_device_model_description)
    , software_version_label(new_software_version_label)
    , device_label(new_device_label)
{
}
 
inline bool Controller::RdmData::IsValid() const
{
  return ((!manufacturer_label.empty()) && (!device_model_description.empty()) && (!software_version_label.empty()) &&
          (!device_label.empty()));
}
 
inline etcpal::Error Controller::Startup(NotifyHandler&  notify_handler,
                                         const Settings& settings,
                                         const RdmData&  rdm_data)
{
  if (!settings.IsValid() || !rdm_data.IsValid())
    return kEtcPalErrInvalid;
 
  notify_ = &notify_handler;
  my_rdm_data_ = rdm_data;
 
  // clang-format off
  RdmnetControllerConfig config = {
    settings.cid.get(),             // CID
    {                               // Callback shims
      internal::ControllerLibCbConnected,
      internal::ControllerLibCbConnectFailed,
      internal::ControllerLibCbDisconnected,
      internal::ControllerLibCbClientListUpdate,
      internal::ControllerLibCbRdmResponseReceived,
      internal::ControllerLibCbStatusReceived,
      internal::ControllerLibCbResponderIdsReceived,
      &notify_handler               // Context
    },
    {                               // RDM command callback shims
      nullptr, nullptr, nullptr, nullptr
    },
    {                               // RDM data
      rdm_data.model_id,
      rdm_data.software_version_id,
      rdm_data.manufacturer_label.c_str(),
      rdm_data.device_model_description.c_str(),
      rdm_data.software_version_label.c_str(),
      rdm_data.device_label.c_str(),
      rdm_data.product_category,
      rdm_data.device_label_settable
    },
    settings.uid.get(),             // UID
    settings.search_domain.c_str(), // Search domain
    settings.create_llrp_target,    // Create LLRP target
  };
  // clang-format on
 
  rdmnet_controller_t c_handle = RDMNET_CONTROLLER_INVALID;
  etcpal::Error       result = rdmnet_controller_create(&config, &c_handle);
 
  handle_.SetValue(c_handle);
 
  return result;
}
 
inline etcpal::Error Controller::Startup(NotifyHandler&     notify_handler,
                                         const Settings&    settings,
                                         RdmCommandHandler& rdm_handler,
                                         uint8_t*           rdm_response_buf)
{
  if (!settings.IsValid())
    return kEtcPalErrInvalid;
 
  notify_ = &notify_handler;
  rdm_cmd_handler_ = &rdm_handler;
 
  // clang-format off
  RdmnetControllerConfig config = {
    settings.cid.get(),             // CID
    {                               // Callback shims
      internal::ControllerLibCbConnected,
      internal::ControllerLibCbConnectFailed,
      internal::ControllerLibCbDisconnected,
      internal::ControllerLibCbClientListUpdate,
      internal::ControllerLibCbRdmResponseReceived,
      internal::ControllerLibCbStatusReceived,
      internal::ControllerLibCbResponderIdsReceived,
      &notify_handler               // Context
    },
    {                               // RDM command callback shims
      internal::ControllerLibCbRdmCommandReceived,
      internal::ControllerLibCbLlrpRdmCommandReceived,
      rdm_response_buf,
      &rdm_handler                  // Context
    },
    RDMNET_CONTROLLER_RDM_DATA_DEFAULT_INIT, // RDM data
    settings.uid.get(),             // UID
    settings.search_domain.c_str(), // Search domain
    settings.create_llrp_target,    // Create LLRP target
  };
  // clang-format on
 
  rdmnet_controller_t c_handle = RDMNET_CONTROLLER_INVALID;
  etcpal::Error       result = rdmnet_controller_create(&config, &c_handle);
 
  handle_.SetValue(c_handle);
 
  return result;
}
 
inline void Controller::Shutdown(rdmnet_disconnect_reason_t disconnect_reason)
{
  rdmnet_controller_destroy(handle_.value(), disconnect_reason);
  handle_.Clear();
}
 
inline etcpal::Expected<ScopeHandle> Controller::AddScope(const char* id, const etcpal::SockAddr& static_broker_addr)
{
  if (!id)
    return kEtcPalErrInvalid;
 
  RdmnetScopeConfig     scope_config = {id, static_broker_addr.get()};
  rdmnet_client_scope_t scope_handle;
  auto                  result = rdmnet_controller_add_scope(handle_.value(), &scope_config, &scope_handle);
  if (result == kEtcPalErrOk)
    return ScopeHandle(scope_handle);
  else
    return result;
}
 
inline etcpal::Expected<ScopeHandle> Controller::AddScope(const std::string&      id,
                                                          const etcpal::SockAddr& static_broker_addr)
{
  return AddScope(id.c_str(), static_broker_addr);
}
 
inline etcpal::Expected<ScopeHandle> Controller::AddScope(const Scope& scope_config)
{
  return AddScope(scope_config.id_string().c_str(), scope_config.static_broker_addr());
}
 
inline etcpal::Expected<ScopeHandle> Controller::AddDefaultScope(const etcpal::SockAddr& static_broker_addr)
{
  return AddScope(E133_DEFAULT_SCOPE, static_broker_addr);
}
 
inline etcpal::Error Controller::RemoveScope(ScopeHandle scope_handle, rdmnet_disconnect_reason_t disconnect_reason)
{
  return rdmnet_controller_remove_scope(handle_.value(), scope_handle.value(), disconnect_reason);
}
 
inline etcpal::Error Controller::ChangeScope(ScopeHandle                scope_handle,
                                             const char*                new_scope_id_str,
                                             rdmnet_disconnect_reason_t disconnect_reason,
                                             const etcpal::SockAddr&    new_static_broker_addr)
{
  if (!new_scope_id_str)
    return kEtcPalErrInvalid;
 
  RdmnetScopeConfig new_scope_config = {new_scope_id_str, new_static_broker_addr.get()};
  return rdmnet_controller_change_scope(handle_.value(), scope_handle.value(), &new_scope_config, disconnect_reason);
}
 
inline etcpal::Error Controller::ChangeScope(ScopeHandle                scope_handle,
                                             const Scope&               new_scope_config,
                                             rdmnet_disconnect_reason_t disconnect_reason)
{
  return ChangeScope(scope_handle, new_scope_config.id_string().c_str(), disconnect_reason,
                     new_scope_config.static_broker_addr());
}
 
inline etcpal::Error Controller::ChangeSearchDomain(const char*                new_search_domain,
                                                    rdmnet_disconnect_reason_t disconnect_reason)
{
  if (!new_search_domain)
    return kEtcPalErrInvalid;
 
  return rdmnet_controller_change_search_domain(handle_.value(), new_search_domain, disconnect_reason);
}
 
inline etcpal::Expected<uint32_t> Controller::SendRdmCommand(ScopeHandle            scope_handle,
                                                             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 = rdmnet_controller_send_rdm_command(handle_.value(), scope_handle.value(), &destination.get(),
                                                          command_class, param_id, data, data_len, &seq_num);
  if (res == kEtcPalErrOk)
    return seq_num;
  else
    return res;
}
 
inline etcpal::Expected<uint32_t> Controller::SendGetCommand(ScopeHandle            scope_handle,
                                                             const DestinationAddr& destination,
                                                             uint16_t               param_id,
                                                             const uint8_t*         data,
                                                             uint8_t                data_len)
{
  uint32_t       seq_num;
  etcpal_error_t res = rdmnet_controller_send_get_command(handle_.value(), scope_handle.value(), &destination.get(),
                                                          param_id, data, data_len, &seq_num);
  if (res == kEtcPalErrOk)
    return seq_num;
  else
    return res;
}
 
inline etcpal::Expected<uint32_t> Controller::SendSetCommand(ScopeHandle            scope_handle,
                                                             const DestinationAddr& destination,
                                                             uint16_t               param_id,
                                                             const uint8_t*         data,
                                                             uint8_t                data_len)
{
  uint32_t       seq_num;
  etcpal_error_t res = rdmnet_controller_send_set_command(handle_.value(), scope_handle.value(), &destination.get(),
                                                          param_id, data, data_len, &seq_num);
  if (res == kEtcPalErrOk)
    return seq_num;
  else
    return res;
}
 
inline etcpal::Error Controller::RequestClientList(ScopeHandle scope_handle)
{
  return rdmnet_controller_request_client_list(handle_.value(), scope_handle.value());
}
 
inline etcpal::Error Controller::RequestResponderIds(ScopeHandle scope_handle, const rdm::Uid* uids, size_t num_uids)
{
  if (!uids || (num_uids == 0))
    return kEtcPalErrInvalid;
 
  std::vector<RdmUid> c_uids;
  c_uids.reserve(num_uids);
  std::transform(uids, uids + num_uids, std::back_inserter(c_uids), [](const rdm::Uid& uid) { return uid.get(); });
  return rdmnet_controller_request_responder_ids(handle_.value(), scope_handle.value(), c_uids.data(), c_uids.size());
}
 
inline etcpal::Error Controller::RequestResponderIds(ScopeHandle scope_handle, const std::vector<rdm::Uid>& uids)
{
  return RequestResponderIds(scope_handle, uids.data(), uids.size());
}
 
inline etcpal::Error Controller::SendRdmAck(ScopeHandle            scope_handle,
                                            const SavedRdmCommand& received_cmd,
                                            const uint8_t*         response_data,
                                            size_t                 response_data_len)
{
  return rdmnet_controller_send_rdm_ack(handle_.value(), scope_handle.value(), &received_cmd.get(), response_data,
                                        response_data_len);
}
 
inline etcpal::Error Controller::SendRdmNack(ScopeHandle            scope_handle,
                                             const SavedRdmCommand& received_cmd,
                                             rdm_nack_reason_t      nack_reason)
{
  return rdmnet_controller_send_rdm_nack(handle_.value(), scope_handle.value(), &received_cmd.get(), nack_reason);
}
 
inline etcpal::Error Controller::SendRdmNack(ScopeHandle            scope_handle,
                                             const SavedRdmCommand& received_cmd,
                                             uint16_t               raw_nack_reason)
{
  return rdmnet_controller_send_rdm_nack(handle_.value(), scope_handle.value(), &received_cmd.get(),
                                         static_cast<rdm_nack_reason_t>(raw_nack_reason));
}
 
inline etcpal::Error Controller::SendRdmUpdate(ScopeHandle    scope_handle,
                                               uint16_t       param_id,
                                               const uint8_t* data,
                                               size_t         data_len)
{
  return rdmnet_controller_send_rdm_update(handle_.value(), scope_handle.value(), 0, param_id, data, data_len);
}
 
inline etcpal::Error Controller::SendLlrpAck(const llrp::SavedRdmCommand& received_cmd,
                                             const uint8_t*               response_data,
                                             uint8_t                      response_data_len)
{
  return rdmnet_controller_send_llrp_ack(handle_.value(), &received_cmd.get(), response_data, response_data_len);
}
 
inline etcpal::Error Controller::SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason)
{
  return rdmnet_controller_send_llrp_nack(handle_.value(), &received_cmd.get(), nack_reason);
}
 
inline etcpal::Error Controller::SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, uint16_t raw_nack_reason)
{
  return rdmnet_controller_send_llrp_nack(handle_.value(), &received_cmd.get(),
                                          static_cast<rdm_nack_reason_t>(raw_nack_reason));
}
 
inline Controller::Handle Controller::handle() const
{
  return handle_;
}
 
inline const Controller::RdmData& Controller::rdm_data() const
{
  return my_rdm_data_;
}
 
inline Controller::NotifyHandler* Controller::notify_handler() const
{
  return notify_;
}
 
inline Controller::RdmCommandHandler* Controller::rdm_command_handler() const
{
  return rdm_cmd_handler_;
}
 
inline etcpal::Expected<Scope> Controller::scope(ScopeHandle scope_handle) const
{
  std::string    scope_id(E133_SCOPE_STRING_PADDED_LENGTH, 0);
  EtcPalSockAddr static_broker_addr;
  etcpal_error_t res =
      rdmnet_controller_get_scope(handle_.value(), scope_handle.value(), &scope_id[0], &static_broker_addr);
 
  if (res == kEtcPalErrOk)
    return Scope(scope_id, static_broker_addr);
  else
    return res;
}
 
inline void Controller::UpdateRdmData(const RdmData& new_data)
{
  // TODO implement
  ETCPAL_UNUSED_ARG(new_data);
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_CONTROLLER_H_