Initial commit

Lts/Services/AudioVideoManagement/default_av_menus.cpp

@@ -0,0 +1,280 @@
+/**
+  * @RDE_HEADER@
+  * DefaultAvMenus
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Fröbel, NLSE, 2018-03-14
+  */
+
+#include "default_av_menus.h"
+#include "exercise.h"
+#include "object_video_team.h"
+#include "audio_video_handler_impl.h"
+#include <AudioVideoManagement/avm.hpp>
+#include <AudioVideoManagement/avm_dts.h>
+#include <AudioVideoManagement/handler_menu_struct.h>
+#include <InfrastructureManagement/ism_dtc.h>
+#include <QTimer>
+#include <QtGlobal>
+#include <set>
+#include <algorithm>
+#include <iterator>
+
+
+namespace
+{
+
+std::set<int32_t>   mountingPointsOfInterest(const InfrastructureManagement::MainStructureElement &building)
+{
+  std::set<int32_t>   mountingPoints;
+
+  for (const auto &se : building.elements())
+  {
+    if (se.structureElementTypeId() != InfrastructureManagement::StructureElementType::MountingPoint)
+      continue;
+
+    if (se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::AnnouncementUnit ||
+        se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::IndoorCamera ||
+        se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::OutdoorCamera)
+      mountingPoints.insert(se.id());
+  }
+
+  return mountingPoints;
+}
+
+bool isStreamOfInterest(const AudioVideoManagement::Stream &stream, bool isAudio)
+{
+  using AudioVideoManagement::StreamType;
+
+  switch (stream.type().underlying())
+  {
+  case StreamType::Video:
+    return !isAudio;
+
+  case StreamType::AudioIn:
+    return false;
+
+  case StreamType::AudioOut:
+  case StreamType::AudioInOut:
+    return isAudio;
+  }
+  Q_ASSERT(false);
+  return false;
+}
+
+} // anonymous namespace
+
+
+
+namespace AudioVideoManagement
+{
+
+DefaultAvMenus::DefaultAvMenus(const ExerciseContext &context, Interface::Dts *dts, HandlerVideoTeam *handlerVideoTeams, InfrastructureManagement::Interface::Dtc *ismDtc)
+  : m_context(context)
+  , m_dts(dts)
+  , m_videoTeamHandler(handlerVideoTeams)
+  , m_ismDtc(ismDtc)
+  , m_timer(new QTimer)
+  , m_logger(getLogger("DefaultAvMenus"))
+  , m_isInitialized(false)
+{
+  Q_ASSERT(dts);
+  Q_ASSERT(ismDtc);
+  if(!m_ismDtc->isMainStructureElementEnabled())
+    m_ismDtc->enableMainStructureElement();
+  m_timer->setInterval(1000);
+  m_timer->setSingleShot(true);
+  connect(m_videoTeamHandler, &HandlerVideoTeam::mvsChanged, this, &DefaultAvMenus::onStreamMvsChanged);
+  connect(m_timer.get(), &QTimer::timeout, this, &DefaultAvMenus::updateMenus);
+  m_timer->start();
+}
+
+DefaultAvMenus::~DefaultAvMenus() = default;
+
+void DefaultAvMenus::onStreamChanged(const Stream &stream)
+{
+  m_streams[stream.id()] = stream;
+  m_timer->start();
+}
+
+void DefaultAvMenus::onStreamMvsChanged()
+{
+  m_timer->start();
+}
+
+void DefaultAvMenus::onMainStructureElementChanged(const InfrastructureManagement::MainStructureElement &data, DataModification modType)
+{
+  QString buildingDisplayName = getDisplayNameForBuilding(data);
+
+  if(modType == DataModification::eRemoved)
+  {
+    m_buildingDisplayNameForId.remove(data.id());
+    m_timer->start();
+  }
+  else if(modType == DataModification::eAdded)
+  {
+    m_buildingDisplayNameForId[data.id()] = buildingDisplayName;
+    m_timer->start();
+  }
+  else
+  {
+    if(m_buildingDisplayNameForId.value(data.id(),buildingDisplayName) == buildingDisplayName)
+      return;
+
+    m_buildingDisplayNameForId[data.id()] = buildingDisplayName;
+    m_timer->start();
+  }
+}
+
+
+void DefaultAvMenus::onStreamRemoved(int32_t streamId)
+{
+  auto   removeCount = m_streams.erase(streamId);
+  Q_ASSERT(removeCount == 1);
+  m_timer->start();
+}
+
+void DefaultAvMenus::updateMenus()
+{
+  updateMenu(true); // isAudio
+  updateMenu(false); // !isAudio = Video
+}
+
+void DefaultAvMenus::removeMenus()
+{
+  m_dts->removeMenuStructByKey(menuStructId(true));  // isAudio
+  m_dts->removeMenuStructByKey(menuStructId(false)); // !isAudio = Video
+}
+
+void DefaultAvMenus::updateMenu(bool isAudio)
+{
+  MenuStruct   menu;
+  menu.id(menuStructId(isAudio));
+  menu.isDefault(true);
+  menu.name("Default");
+  menu.isAudio(isAudio);
+
+  std::vector<AvMenuEntry>   allEntries;
+
+  const auto &buildings = m_ismDtc->mainStructureElements();
+  for (const auto &building : buildings)
+  {
+    m_buildingDisplayNameForId[building.id()] = getDisplayNameForBuilding(building);
+    std::vector<AvMenuEntry>   subMenu = subMenuForBuilding(building, isAudio);
+    std::move(subMenu.begin(), subMenu.end(), std::back_inserter(allEntries));
+  }
+
+  if (!isAudio)
+  {
+    bool addMenu = false;
+    AvMenuEntry   mvsStreams;
+    mvsStreams.id(1000000);
+    mvsStreams.parentId(menuStructId(isAudio));
+    mvsStreams.name().set("MVS");
+    mvsStreams.isGroup(true);
+
+    const auto &videoTeams = m_videoTeamHandler->videoTeams();
+    for (const auto &videoTeam : videoTeams)
+    {
+      if (videoTeam.exerciseId() != m_context.id())
+        continue;
+      addMenu = true;
+      AvMenuEntry   streamEntry;
+      streamEntry.id(videoTeam.id());
+      streamEntry.parentId(mvsStreams.id());
+      streamEntry.mountingPointId(-1*videoTeam.id());
+      // Also set the stream name which makes it easier for the clients.
+      streamEntry.name().set(videoTeam.streamName());
+      streamEntry.isGroup(false);
+      allEntries.push_back(streamEntry);
+      // What about the rowId?
+    }
+    if (addMenu)
+    {
+      allEntries.push_back(mvsStreams);
+    }
+  }
+
+  menu.menuEntries(allEntries);
+  HandlerMenuStruct::sortEntries(menu);
+
+  m_dts->publish(menu);
+
+  if(!m_isInitialized)
+  {
+    connect(m_ismDtc, &InfrastructureManagement::Interface::Dtc::mainStructureElementChanged, this, &DefaultAvMenus::onMainStructureElementChanged);
+    m_isInitialized = true;
+  }
+}
+
+QString DefaultAvMenus::getDisplayNameForBuilding(const InfrastructureManagement::MainStructureElement &data)
+{
+  for (auto structure : data.elements()) {
+    if(structure.structureElementTypeId() == InfrastructureManagement::StructureElementType::Building)
+      return QString::fromStdString(structure.displayName());
+  }
+  return QString::fromStdString(data.name());
+}
+
+std::vector<AvMenuEntry> DefaultAvMenus::subMenuForBuilding(const InfrastructureManagement::MainStructureElement &building, bool isAudio)
+{
+  std::vector<AvMenuEntry>   entries;
+  std::vector<Stream>        streams = streamsForBuilding(building, isAudio);
+  if (streams.empty())
+    return entries;
+
+  entries.reserve(streams.size() + 1);
+
+  AvMenuEntry   buildingEntry;
+  buildingEntry.id(building.id());
+  buildingEntry.parentId(menuStructId(isAudio));
+  buildingEntry.name(getDisplayNameForBuilding(building).toStdString());
+  buildingEntry.isGroup(true);
+  // What about the rowId?
+
+  entries.push_back(buildingEntry);
+
+  for (const auto &stream : streams)
+  {
+    AvMenuEntry   streamEntry;
+    streamEntry.id(stream.mountingPointId());
+    streamEntry.parentId(buildingEntry.id());
+    streamEntry.mountingPointId(stream.mountingPointId());
+    // Also set the stream name which makes it easier for the clients.
+    streamEntry.name().set(AudioVideoHandlerImpl::internalStreamName(stream.mountingPointId()).toStdString());
+    streamEntry.isGroup(false);
+    // What about the rowId?
+
+    entries.push_back(streamEntry);
+  }
+
+  return entries;
+}
+
+std::vector<Stream> DefaultAvMenus::streamsForBuilding(const InfrastructureManagement::MainStructureElement &building, bool isAudio)
+{
+  std::set<int32_t>     mountingPoints = mountingPointsOfInterest(building);
+  std::vector<Stream>   streams;
+
+  for (const auto &keyValue : m_streams)
+  {
+    const Stream   &stream = keyValue.second;
+    if (!isStreamOfInterest(stream, isAudio))
+      continue;
+
+    if (!mountingPoints.count(stream.mountingPointId()))
+      continue;
+
+    streams.push_back(stream);
+  }
+
+  return streams;
+}
+
+int32_t DefaultAvMenus::menuStructId(bool isAudio)
+{
+  return m_context.id() + (isAudio ? 20000000 : 10000000);
+}
+
+} // namespace AudioVideoManagement