Initial commit

Lts/Services/VideoOverlayManagement/avs_interface.cpp

@@ -0,0 +1,263 @@
+/**
+  * AVS-Interface for VideoOverlayManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by hjl, SLSE, 2016-06-24
+  */
+
+#include "avs_interface.h"
+#include "settings.h"
+
+#include <QTcpSocket>
+#include <QTimer>
+#include <QHostInfo>
+#include <ngltools/ngltools_convert.h>
+
+namespace VideoOverlayManagement
+{
+
+AvsInterface::AvsInterface(bool enableTryReconnect, QObject *parent)
+  : QObject(parent)
+  , m_waitTime(1)
+  , m_enableTryReconnect(enableTryReconnect)
+  , m_tryReconnect(false)
+  , m_avsKeepAliveTimer(new QTimer(this))
+  , m_keepAliveTime(Settings::getAvsKeepAliveTime())
+  , m_avsIfConnectionState(AvsIfConnectionState::Undefined)
+  , m_socket(nullptr)
+  , m_logger(getLogger("AVS_Interface"))
+{
+  doConnect();
+
+  connect(m_avsKeepAliveTimer, &QTimer::timeout,
+          this, &AvsInterface::onAvsKeepAliveTimeout);
+
+} // end of ctor()
+//-----------------------------------------------------------------------------
+
+AvsInterface::~AvsInterface()
+{
+  if (m_socket)
+    m_socket->close();
+  delete m_socket;
+} // end of dtor()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::doConnect()
+{
+  DEBUG_LOG(m_logger) << "doConnect TCP-Socket ";
+
+  if (m_socket)
+    m_socket->deleteLater();
+
+  m_socket = new QTcpSocket(this);
+  connect(m_socket, &QTcpSocket::connected,
+          this, &AvsInterface::onConnected);
+  connect(m_socket, &QTcpSocket::disconnected,
+          this, &AvsInterface::onDisonnected);
+  connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
+          this, &AvsInterface::onError);
+  connect(m_socket, &QTcpSocket::readyRead,
+          this, &AvsInterface::onReadyRead);
+
+  if (m_tryReconnect)
+  {
+    INFO_LOG(m_logger) << "Try reconnect to host: " << m_hostName
+                       << " port: " << m_hostPort
+                       << " ip-address: " << m_ipAddressDNS;
+
+    m_socket->connectToHost(m_hostName, m_hostPort);
+  }
+} //  end of doConnect()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::start(const QString &hostName, quint16 port)
+{
+  QHostInfo hostInfo = QHostInfo::fromName(hostName);
+
+  const QList<QHostAddress> ipList = hostInfo.addresses();
+  if (ipList.isEmpty())
+  {
+    ERROR_LOG(m_logger) << "Non ip-address found for hostname: " << hostName;
+    m_ipAddressDNS.clear();
+  }
+  else
+  {
+    INFO_LOG(m_logger) << "Try connect to AVS: " << hostName
+                       << " port: " << port
+                       << " ip-address: " << ipList.at(0).toString();
+
+    m_ipAddressDNS = ipList.at(0).toString();
+  }
+  m_hostName     = hostName;
+  m_hostPort     = port;
+  m_socket->connectToHost(m_hostName, m_hostPort);
+} //  end of start()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::onConnected()
+{
+  INFO_LOG(m_logger) << "Connected to "
+                     << m_socket->peerAddress().toString()
+                     << ":" << m_socket->peerPort();
+  m_waitTime = 1;
+  m_buffer.clear();
+
+  m_avsIfConnectionState = AvsIfConnectionState::Connected;
+  emit avsIfConnectionState(AvsIfConnectionState::Connected);
+
+  m_avsKeepAliveTimer->start(m_keepAliveTime);
+} //  end of onConnected()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::onDisonnected()
+{
+  INFO_LOG(m_logger) << "Disconnected from " << m_socket->peerAddress().toString()
+                     << ":" << m_socket->peerPort();
+
+  m_avsKeepAliveTimer->stop();
+  m_avsIfConnectionState = AvsIfConnectionState::Disconnected;
+  emit avsIfConnectionState(AvsIfConnectionState::Disconnected);
+} //  end of onDisonnected()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::onError(QAbstractSocket::SocketError err)
+{
+  if (m_enableTryReconnect)
+  {
+    ERROR_LOG(m_logger) << "Socket error: " << err
+                        << " \""  << m_socket->errorString() << "\""
+                        << " Hostname: " << m_hostName
+                        << " Port:" << m_hostPort
+                        << " ip-Address:" << m_ipAddressDNS
+                        << " - trying to reconnect in " << m_waitTime << " seconds";
+  }
+  else
+  {
+    ERROR_LOG(m_logger) << "Socket error: " << err
+                        << " \""  << m_socket->errorString() << "\""
+                        << " Hostname: " << m_hostName
+                        << " Port:" << m_hostPort
+                        << " ip-Address:" << m_ipAddressDNS;
+  }
+
+  m_socket->disconnectFromHost();
+  m_avsKeepAliveTimer->stop();
+
+  m_avsIfConnectionState = AvsIfConnectionState::ConnectionError;
+  emit avsIfConnectionState(AvsIfConnectionState::ConnectionError);
+
+  // try reconnects ....
+  if (m_enableTryReconnect)
+    tryReconnect();
+} //  end of onError()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::tryReconnect()
+{
+  m_tryReconnect = true;
+  m_avsIfConnectionState = AvsIfConnectionState::TryReconnect;
+  emit avsIfConnectionState(AvsIfConnectionState::TryReconnect);
+
+  if (m_socket->state() != QAbstractSocket::UnconnectedState)
+    m_socket->waitForDisconnected();
+
+  m_waitTime += 2;
+
+  if (m_waitTime > 120)
+    m_waitTime = 120;
+
+  QTimer::singleShot(m_waitTime * 1000, this, &AvsInterface::doConnect);
+} //  end of tryReconnect()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::onReadyRead()
+{
+  while (m_socket->canReadLine())
+  {
+    const QByteArray data = m_socket->readLine().trimmed();
+    if (data.isEmpty())
+      continue;
+
+    INFO_LOG(m_logger) << "Incoming RCP_AVA: '" << data << "'";
+    int cmdNr = -1;
+    bool bOk = false;
+
+    const QVector<QByteArray> cmdList = NGL::parseFromTelnet(data);
+
+    if (cmdList.size() > 1)
+      cmdNr = cmdList.at(0).toInt(&bOk);
+
+    if (bOk)
+    {
+      // Fuer VOM sind nur diese 4 Command relavant
+      switch (cmdNr)
+      {
+      case int(AvsCmdState::Ok):
+        emit avsCmdState(AvsCmdState::Ok);
+        break;
+      case int(AvsCmdState::KeepAlive):
+        emit avsCmdState(AvsCmdState::KeepAlive);
+        m_avsKeepAliveTimer->start(m_keepAliveTime);
+        break;
+      case int(AvsCmdState::BadArguments):
+        emit avsCmdState(AvsCmdState::BadArguments);
+        break;
+      case int(AvsCmdState::CommandNotStateValid):
+        emit avsCmdState(AvsCmdState::CommandNotStateValid);
+        break;
+      default:
+        break;
+      }
+    }
+  }  // while
+} //  end of onReadyRead()
+//-----------------------------------------------------------------------------
+
+void AvsInterface::onAvsKeepAliveTimeout()
+{
+  emit avsKeepAliveTimeout();
+
+// try reconnects ....
+  if (m_enableTryReconnect)
+  {
+    m_socket->disconnectFromHost();
+    m_avsKeepAliveTimer->stop();
+
+    if (m_socket->state() != QAbstractSocket::UnconnectedState)
+      m_socket->waitForDisconnected();
+
+    tryReconnect();
+  }
+} // end of onAvsKeepAliveTimeout()
+//-----------------------------------------------------------------------------
+
+bool AvsInterface::sendCommand(const QByteArray &qba)
+{
+  bool bOk = true;
+
+  INFO_LOG(m_logger) << "Send command: " << qba.trimmed();
+
+  if (m_socket->state() != QTcpSocket::ConnectedState)
+  {
+    ERROR_LOG(m_logger) << "sendCommand()"
+                        << " '" << qba.trimmed()
+                        << "' No socket connection established.";
+    return false;
+  }
+
+  int trxBytes = m_socket->write(qba);
+
+  if (trxBytes != qba.size())
+  {
+    bOk = false;
+    ERROR_LOG(m_logger) << "Insufficient number of tansfered bytes."
+                        << " Soll: " << trxBytes << " Ist: " << qba.size();
+  }
+  m_socket->flush();
+  return bOk;
+} //  end of sendCommand()
+//-----------------------------------------------------------------------------
+
+} // namespace VideoOverlayManagement