source_detector.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 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:
    virtual ~NotifyHandler() = 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{SACN_SOURCE_DETECTOR_INFINITE};
 
    int universes_per_source_max{SACN_SOURCE_DETECTOR_INFINITE};
 
    sacn_ip_support_t ip_supported{kSacnIpV4AndIpV6};
 
    Settings() = default;
  };
 
  SourceDetector() = delete;
 
  static etcpal::Error Startup(NotifyHandler& notify_handler);
  static etcpal::Error Startup(NotifyHandler& notify_handler, std::vector<SacnMcastInterface>& netints);
  static etcpal::Error Startup(const Settings& settings, NotifyHandler& notify_handler);
  static etcpal::Error Startup(const Settings& settings, NotifyHandler& notify_handler,
                               std::vector<SacnMcastInterface>& netints);
  static void Shutdown();
  static etcpal::Error ResetNetworking();
  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)
{
  std::vector<SacnMcastInterface> netints;
  return Startup(Settings(), notify_handler, netints);
}
 
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)
{
  std::vector<SacnMcastInterface> netints;
  return Startup(settings, notify_handler, netints);
}
 
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, NULL);
 
  SacnNetintConfig netint_config = {netints.data(), netints.size()};
  return sacn_source_detector_create(&config, &netint_config);
}
 
inline void SourceDetector::Shutdown()
{
  sacn_source_detector_destroy();
}
 
inline etcpal::Error SourceDetector::ResetNetworking()
{
  std::vector<SacnMcastInterface> netints;
  return ResetNetworking(netints);
}
 
inline etcpal::Error SourceDetector::ResetNetworking(std::vector<SacnMcastInterface>& sys_netints)
{
  if (sys_netints.empty())
  {
    return sacn_source_detector_reset_networking(nullptr);
  }
  else
  {
    SacnNetintConfig netint_config = {sys_netints.data(), 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.
  std::vector<EtcPalMcastNetintId> netints;
  size_t size_guess = 4u;
  size_t num_netints = 0u;
 
  do
  {
    netints.resize(size_guess);
    num_netints = sacn_source_detector_get_network_interfaces(netints.data(), netints.size());
    size_guess = num_netints + 4u;
  } while (num_netints > 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_