ept_client.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_EPT_CLIENT_H_
#define RDMNET_CPP_EPT_CLIENT_H_
 
#include "etcpal/common.h"
#include "etcpal/cpp/opaque_id.h"
#include "rdmnet/cpp/client.h"
#include "rdmnet/cpp/common.h"
#include "rdmnet/cpp/message.h"
#include "rdmnet/ept_client.h"
 
namespace rdmnet
{
 
namespace detail
{
class EptClientHandleType
{
};
};  // namespace detail
 
class EptClient
{
public:
  using Handle = etcpal::OpaqueId<detail::EptClientHandleType, rdmnet_ept_client_t, RDMNET_EPT_CLIENT_INVALID>;
 
  class NotifyHandler
  {
  public:
    virtual ~NotifyHandler() = default;
 
    virtual void HandleConnectedToBroker(Handle                     client_handle,
                                         ScopeHandle                scope_handle,
                                         const ClientConnectedInfo& info) = 0;
 
    virtual void HandleBrokerConnectFailed(Handle                         client_handle,
                                           ScopeHandle                    scope_handle,
                                           const ClientConnectFailedInfo& info) = 0;
 
    virtual void HandleDisconnectedFromBroker(Handle                        client_handle,
                                              ScopeHandle                   scope_handle,
                                              const ClientDisconnectedInfo& info) = 0;
 
    virtual void HandleClientListUpdate(Handle               client_handle,
                                        ScopeHandle          scope_handle,
                                        client_list_action_t list_action,
                                        const EptClientList& list) = 0;
 
    virtual EptResponseAction HandleEptData(Handle client_handle, ScopeHandle scope_handle, const EptData& data) = 0;
 
    virtual void HandleEptStatus(Handle client_handle, ScopeHandle scope_handle, const EptStatus& status) = 0;
  };
 
  struct Settings
  {
    etcpal::Uuid                cid;            
    std::vector<EptSubProtocol> protocols;      
    std::string                 search_domain;  
    const uint8_t* response_buf{nullptr};
 
    Settings() = default;
    Settings(const etcpal::Uuid& new_cid, const std::vector<EptSubProtocol>& new_protocols);
 
    bool IsValid() const;
  };
 
  EptClient() = default;
  EptClient(const EptClient& other) = delete;
  EptClient& operator=(const EptClient& other) = delete;
  EptClient(EptClient&& other) = default;             
  EptClient& operator=(EptClient&& other) = default;  
 
  etcpal::Error Startup(NotifyHandler& notify_handler, const Settings& settings);
  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 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 RequestClientList(ScopeHandle scope_handle);
 
  etcpal::Error SendData(ScopeHandle         scope_handle,
                         const etcpal::Uuid& dest_cid,
                         uint16_t            manufacturer_id,
                         uint16_t            protocol_id,
                         const uint8_t*      data,
                         size_t              data_len);
  etcpal::Error SendStatus(ScopeHandle         scope_handle,
                           const etcpal::Uuid& dest_cid,
                           ept_status_code_t   status_code,
                           const char*         status_string = nullptr);
 
  Handle                  handle() const;
  NotifyHandler*          notify_handler() const;
  etcpal::Expected<Scope> scope(ScopeHandle scope_handle) const;
 
private:
  Handle         handle_;
  NotifyHandler* notify_{nullptr};
};
 
inline EptClient::Settings::Settings(const etcpal::Uuid& new_cid, const std::vector<EptSubProtocol>& new_protocols)
    : cid(new_cid), protocols(new_protocols)
{
}
 
inline bool EptClient::Settings::IsValid() const
{
  return (!cid.IsNull() && !protocols.empty());
}
 
inline etcpal::Error EptClient::Startup(NotifyHandler& notify_handler, const Settings& settings)
{
  ETCPAL_UNUSED_ARG(notify_handler);
  ETCPAL_UNUSED_ARG(settings);
  return kEtcPalErrNotImpl;
}
 
inline void EptClient::Shutdown(rdmnet_disconnect_reason_t disconnect_reason)
{
  ETCPAL_UNUSED_ARG(disconnect_reason);
}
 
inline etcpal::Expected<ScopeHandle> EptClient::AddScope(const char* id, const etcpal::SockAddr& static_broker_addr)
{
  ETCPAL_UNUSED_ARG(id);
  ETCPAL_UNUSED_ARG(static_broker_addr);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Expected<ScopeHandle> EptClient::AddScope(const Scope& scope_config)
{
  ETCPAL_UNUSED_ARG(scope_config);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Expected<ScopeHandle> EptClient::AddDefaultScope(const etcpal::SockAddr& static_broker_addr)
{
  ETCPAL_UNUSED_ARG(static_broker_addr);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Error EptClient::RemoveScope(ScopeHandle scope_handle, rdmnet_disconnect_reason_t disconnect_reason)
{
  ETCPAL_UNUSED_ARG(scope_handle);
  ETCPAL_UNUSED_ARG(disconnect_reason);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Error EptClient::RequestClientList(ScopeHandle scope_handle)
{
  ETCPAL_UNUSED_ARG(scope_handle);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Error EptClient::SendData(ScopeHandle         scope_handle,
                                         const etcpal::Uuid& dest_cid,
                                         uint16_t            manufacturer_id,
                                         uint16_t            protocol_id,
                                         const uint8_t*      data,
                                         size_t              data_len)
{
  ETCPAL_UNUSED_ARG(scope_handle);
  ETCPAL_UNUSED_ARG(dest_cid);
  ETCPAL_UNUSED_ARG(manufacturer_id);
  ETCPAL_UNUSED_ARG(protocol_id);
  ETCPAL_UNUSED_ARG(data);
  ETCPAL_UNUSED_ARG(data_len);
  return kEtcPalErrNotImpl;
}
 
inline etcpal::Error EptClient::SendStatus(ScopeHandle         scope_handle,
                                           const etcpal::Uuid& dest_cid,
                                           ept_status_code_t   status_code,
                                           const char*         status_string)
{
  ETCPAL_UNUSED_ARG(scope_handle);
  ETCPAL_UNUSED_ARG(dest_cid);
  ETCPAL_UNUSED_ARG(status_code);
  ETCPAL_UNUSED_ARG(status_string);
  return kEtcPalErrNotImpl;
}
 
inline EptClient::Handle EptClient::handle() const
{
  return EptClient::Handle();
}
 
inline EptClient::NotifyHandler* EptClient::notify_handler() const
{
  return nullptr;
}
 
inline etcpal::Expected<Scope> EptClient::scope(ScopeHandle scope_handle) const
{
  ETCPAL_UNUSED_ARG(scope_handle);
  return kEtcPalErrNotImpl;
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_EPT_CLIENT_H_