source_detector.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2024 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 sACN. For more information, go to:
 * https://github.com/ETCLabs/sACN
 *****************************************************************************/
 
#ifndef SACN_CPP_SOURCE_DETECTOR_H_
#define SACN_CPP_SOURCE_DETECTOR_H_
 
#include "sacn/cpp/common.h"
 
#include <vector>
 
#include "sacn/source_detector.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/uuid.h"
 
namespace sacn
{
class SourceDetector
{
public:
  class NotifyHandler
  {
  public:
    NotifyHandler()          = default;
    virtual ~NotifyHandler() = default;
 
    NotifyHandler(const NotifyHandler& other) = default;
 
    NotifyHandler& operator=(const NotifyHandler& other) = default;
 
    NotifyHandler(NotifyHandler&& other) = default;
 
    NotifyHandler& operator=(NotifyHandler&& other) = default;
 
    virtual void HandleSourceUpdated(RemoteSourceHandle           handle,
                                     const etcpal::Uuid&          cid,
                                     const std::string&           name,
                                     const std::vector<uint16_t>& sourced_universes) = 0;
 
    virtual void HandleSourceExpired(RemoteSourceHandle handle, const etcpal::Uuid& cid, const std::string& name) = 0;
 
    virtual void HandleMemoryLimitExceeded() {}
  };
 
  struct Settings
  {
    /********* Required values **********/
 
    /********* Optional values **********/
 
    int source_count_max{kSacnSourceDetectorInfinite};
 
    int universes_per_source_max{kSacnSourceDetectorInfinite};
 
    sacn_ip_support_t ip_supported{kSacnIpV4AndIpV6};
 
    Settings() = default;
  };
 
  SourceDetector() = delete;
 
  static etcpal::Error Startup(NotifyHandler& notify_handler, McastMode mcast_mode);
  static etcpal::Error Startup(NotifyHandler& notify_handler, std::vector<SacnMcastInterface>& netints);
  static etcpal::Error Startup(const Settings& settings, NotifyHandler& notify_handler, McastMode mcast_mode);
  static etcpal::Error Startup(const Settings&                  settings,
                               NotifyHandler&                   notify_handler,
                               std::vector<SacnMcastInterface>& netints);
  static void          Shutdown();
  static etcpal::Error ResetNetworking(McastMode mcast_mode);
  static etcpal::Error ResetNetworking(std::vector<SacnMcastInterface>& netints);
  static std::vector<EtcPalMcastNetintId> GetNetworkInterfaces();
 
private:
  static SacnSourceDetectorConfig TranslateConfig(const Settings& settings, NotifyHandler& notify_handler);
};
 
namespace internal
{
extern "C" inline void SourceDetectorCbSourceUpdated(sacn_remote_source_t handle,
                                                     const EtcPalUuid*    cid,
                                                     const char*          name,
                                                     const uint16_t*      sourced_universes,
                                                     size_t               num_sourced_universes,
                                                     void*                context)
{
  if (context && cid && name)
  {
    std::vector<uint16_t> sourced_vec;
    if (sourced_universes && (num_sourced_universes > 0))
      sourced_vec.assign(sourced_universes, sourced_universes + num_sourced_universes);
    static_cast<SourceDetector::NotifyHandler*>(context)->HandleSourceUpdated(handle, *cid, name, sourced_vec);
  }
}
 
extern "C" inline void SourceDetectorCbSourceExpired(sacn_remote_source_t handle,
                                                     const EtcPalUuid*    cid,
                                                     const char*          name,
                                                     void*                context)
{
  if (context && cid && name)
  {
    static_cast<SourceDetector::NotifyHandler*>(context)->HandleSourceExpired(handle, *cid, name);
  }
}
 
extern "C" inline void SourceDetectorCbMemoryLimitExceeded(void* context)
{
  if (context)
  {
    static_cast<SourceDetector::NotifyHandler*>(context)->HandleMemoryLimitExceeded();
  }
}
 
};  // namespace internal
 
inline etcpal::Error SourceDetector::Startup(NotifyHandler& notify_handler,
                                             McastMode      mcast_mode = McastMode::kEnabledOnAllInterfaces)
{
  SacnSourceDetectorConfig config = TranslateConfig(Settings(), notify_handler);
 
  SacnNetintConfig netint_config = SACN_NETINT_CONFIG_DEFAULT_INIT;
  if (mcast_mode == McastMode::kDisabledOnAllInterfaces)
    netint_config.no_netints = true;
 
  return sacn_source_detector_create(&config, &netint_config);
}
 
inline etcpal::Error SourceDetector::Startup(NotifyHandler& notify_handler, std::vector<SacnMcastInterface>& netints)
{
  return Startup(Settings(), notify_handler, netints);
}
 
inline etcpal::Error SourceDetector::Startup(const Settings& settings,
                                             NotifyHandler&  notify_handler,
                                             McastMode       mcast_mode = McastMode::kEnabledOnAllInterfaces)
{
  SacnSourceDetectorConfig config = TranslateConfig(settings, notify_handler);
 
  SacnNetintConfig netint_config = SACN_NETINT_CONFIG_DEFAULT_INIT;
  if (mcast_mode == McastMode::kDisabledOnAllInterfaces)
    netint_config.no_netints = true;
 
  return sacn_source_detector_create(&config, &netint_config);
}
 
inline etcpal::Error SourceDetector::Startup(const Settings&                  settings,
                                             NotifyHandler&                   notify_handler,
                                             std::vector<SacnMcastInterface>& netints)
{
  SacnSourceDetectorConfig config = TranslateConfig(settings, notify_handler);
 
  if (netints.empty())
    return sacn_source_detector_create(&config, nullptr);
 
  SacnNetintConfig netint_config = SACN_NETINT_CONFIG_DEFAULT_INIT;
  netint_config.netints          = netints.data();
  netint_config.num_netints      = netints.size();
 
  return sacn_source_detector_create(&config, &netint_config);
}
 
inline void SourceDetector::Shutdown()
{
  sacn_source_detector_destroy();
}
 
inline etcpal::Error SourceDetector::ResetNetworking(McastMode mcast_mode = McastMode::kEnabledOnAllInterfaces)
{
  SacnNetintConfig netint_config = SACN_NETINT_CONFIG_DEFAULT_INIT;
  if (mcast_mode == McastMode::kDisabledOnAllInterfaces)
    netint_config.no_netints = true;
 
  return sacn_source_detector_reset_networking(&netint_config);
}
 
inline etcpal::Error SourceDetector::ResetNetworking(std::vector<SacnMcastInterface>& sys_netints)
{
  if (sys_netints.empty())
  {
    return sacn_source_detector_reset_networking(nullptr);
  }
 
  SacnNetintConfig netint_config = SACN_NETINT_CONFIG_DEFAULT_INIT;
  netint_config.netints          = sys_netints.data();
  netint_config.num_netints      = sys_netints.size();
 
  return sacn_source_detector_reset_networking(&netint_config);
}
 
inline std::vector<EtcPalMcastNetintId> SourceDetector::GetNetworkInterfaces()
{
  // This uses a guessing algorithm with a while loop to avoid race conditions.
  size_t                           size_guess = 4u;
  std::vector<EtcPalMcastNetintId> netints(size_guess);
  size_t num_netints = sacn_source_detector_get_network_interfaces(netints.data(), netints.size());
 
  while (num_netints > netints.size())
  {
    size_guess = num_netints + 4u;
    netints.resize(size_guess);
    num_netints = sacn_source_detector_get_network_interfaces(netints.data(), netints.size());
  }
 
  netints.resize(num_netints);
  return netints;
}
 
inline SacnSourceDetectorConfig SourceDetector::TranslateConfig(const Settings& settings, NotifyHandler& notify_handler)
{
  // clang-format off
  SacnSourceDetectorConfig config = {
    {
      internal::SourceDetectorCbSourceUpdated,
      internal::SourceDetectorCbSourceExpired,
      internal::SourceDetectorCbMemoryLimitExceeded,
      &notify_handler
    },
    settings.source_count_max,
    settings.universes_per_source_max,
    settings.ip_supported
  };
  // clang-format on
 
  return config;
}
 
};  // namespace sacn
 
#endif  // SACN_CPP_SOURCE_DETECTOR_H_