805 lines
28 KiB
C++
Executable File
805 lines
28 KiB
C++
Executable File
/**
|
|
* Handler for message data request
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by hjl, SLSE, 2016-10-12
|
|
*/
|
|
|
|
#include "handler_sounds.h"
|
|
#include "settings.h"
|
|
#include "dds_handler.h"
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
#include <QJsonValue>
|
|
#include <QSet>
|
|
#include <QTimer>
|
|
#include <QNetworkReply>
|
|
#include <LtsUtilsCore/json_object.h>
|
|
|
|
namespace SoundManagement
|
|
{
|
|
|
|
HandlerSounds::HandlerSounds(const std::shared_ptr<DdsHandler> &ddsHandler,
|
|
const std::shared_ptr<DbHandler> &dbHandler,
|
|
QObject *parent)
|
|
: QObject(parent)
|
|
, GetActiveSoundsRequestHandler(ddsHandler->ftsSom())
|
|
, StopAllSoundsRequestHandler(ddsHandler->ftsSom())
|
|
, GetSoundsRequestHandler(ddsHandler->ftsSom())
|
|
, ControlSoundRequestHandler(ddsHandler->ftsSom())
|
|
, m_ddsHandler(ddsHandler)
|
|
, m_dbHandler(dbHandler)
|
|
, m_logger(getLogger("HandlerSounds"))
|
|
{
|
|
|
|
} // end of ctor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool HandlerSounds::init()
|
|
{
|
|
SoundManagement::Sounds topicData;
|
|
SoundManagement::Sound sound;
|
|
|
|
INFO_LOG(m_logger) << "HandlerConfigureSounds::init";
|
|
|
|
auto dtcIsm = m_ddsHandler->dtcIsm();
|
|
auto dtcSom = m_ddsHandler->dtcSom();
|
|
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::instrumentationAssetChanged,
|
|
this, &HandlerSounds::onInstrumentationAssetChanged);
|
|
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::mountingPointAssetChanged,
|
|
this, &HandlerSounds::onMountingPointAssetChanged);
|
|
connect(dtcSom.get(), &SoundManagement::Interface::Dtc::soundStateChanged,
|
|
this, &HandlerSounds::onSoundStateChanged);
|
|
|
|
m_updateActiveSoundsTimer->setSingleShot(true);
|
|
connect(m_updateActiveSoundsTimer, &QTimer::timeout, this, &HandlerSounds::onTimerTimeout);
|
|
|
|
// load data from db-table
|
|
QVector<Database::SomSound> soundVec;
|
|
if (!m_dbHandler->db()->select(soundVec))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error reading data from database 'som_sound'!";
|
|
return false;
|
|
}
|
|
|
|
for (const Database::SomSound &data : qAsConst(soundVec))
|
|
{
|
|
static int index = 0;
|
|
DEBUG_LOG(m_logger) << "SomSound from DB data: id=" << data.id
|
|
<< " categoryId=" << data.categoryId
|
|
<< " name=" << data.name
|
|
<< " displayName=" << data.displayName;
|
|
|
|
SoundStr soundEntry;
|
|
soundEntry.index = data.id;
|
|
soundEntry.soundId = data.soundId;
|
|
soundEntry.category = static_cast<SoundManagement::SoundCategory>(data.categoryId);
|
|
soundEntry.name = data.name;
|
|
soundEntry.displayName = data.displayName;
|
|
soundEntry.duration = data.duration;
|
|
soundEntry.isRepeatable = data.isRepeatable;
|
|
m_soundNames.append(soundEntry);
|
|
DEBUG_LOG(m_logger) << "id=" << index
|
|
<< " SomSound from DB data: id=" << soundEntry.index
|
|
<< " categoryId=" << soundEntry.category
|
|
<< " name=" << soundEntry.name
|
|
<< " displayName=" << soundEntry.displayName;
|
|
|
|
sound.id(soundEntry.index);
|
|
sound.category(soundEntry.category);
|
|
sound.soundId(soundEntry.soundId);
|
|
sound.name(soundEntry.name.toStdString());
|
|
sound.displayName(soundEntry.displayName.toStdString());
|
|
sound.duration(soundEntry.duration);
|
|
sound.isRepeatable(soundEntry.isRepeatable);
|
|
topicData.sounds().push_back(sound);
|
|
index++;
|
|
|
|
}
|
|
|
|
m_ddsHandler->dtsSom()->publish(topicData);
|
|
getActiveSounds();
|
|
|
|
// Get 'static' data for all MountPointAsset
|
|
{
|
|
auto cb = [this](const InfrastructureManagement::MountingPointAsset & mpa)
|
|
{
|
|
onMountingPointAssetChanged(mpa, DataModification::eAdded);
|
|
};
|
|
if (!dtcIsm->mountingPointAssets(cb))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} // end init()
|
|
|
|
void HandlerSounds::getActiveSounds()
|
|
{
|
|
DEBUG_LOG(m_logger) << "getActiveSounds";
|
|
if (m_hostnames.size() == 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "No EGCUs available send empty topic ActiveSounds";
|
|
m_updateActiveSoundsTimer->stop();
|
|
// TODO alle aktiven Sounds vom DDS-Bus loeschen
|
|
return;
|
|
}
|
|
m_updateActiveSoundsTimer->start(2000);
|
|
|
|
m_activeSounds.clear();
|
|
QHashIterator<int, QString> i(m_hostnames);
|
|
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
QString hostname = i.value();
|
|
DEBUG_LOG(m_logger) << "getActiveSound hostname=" << hostname;
|
|
getActiveSound(getAssetId(hostname));
|
|
}
|
|
}
|
|
|
|
// get the active sounds from each EGCU
|
|
void HandlerSounds::onGetActiveSoundsRequest(const rti::core::SampleIdentity &cookie,
|
|
const GetActiveSoundsRequest &request)
|
|
{
|
|
// 200{ "ID":"0x510","Name":"Sound Report","sounds":[{"category":"Explosions","sound":"0001"}]}
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0, tr_lts("dds", "GetActiveSounds "));
|
|
DEBUG_LOG(m_logger) << "onGetActiveSoundsRequest: " << request;
|
|
m_ddsHandler->ftsSom()->getActiveSoundsReply(cookie, reply);
|
|
// Request each EGCU
|
|
// Wait for response from each EGCU
|
|
|
|
if (!m_updateActiveSoundsTimer->isActive())
|
|
getActiveSounds();
|
|
}
|
|
|
|
void HandlerSounds::onStopAllSoundsRequest(const rti::core::SampleIdentity &cookie,
|
|
const StopAllSoundsRequest &request)
|
|
{
|
|
DEBUG_LOG(m_logger) << "StopAllSounds: " << request;
|
|
int failedCount = 0;
|
|
|
|
if (request.egcuId() == -1) // stopp all sounds on each EGCU
|
|
{
|
|
QHashIterator<int, QString> i(m_hostnames);
|
|
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
const QString hostname = m_hostnames.value(i.key());
|
|
DEBUG_LOG(m_logger) << "hostname=" << hostname;
|
|
if (!stopAllSounds(i.key()).isEmpty()) // BLOCKING
|
|
failedCount++;
|
|
}
|
|
m_soundStates.clear();
|
|
}
|
|
else
|
|
{
|
|
QString hostname = m_hostnames.value(request.egcuId());
|
|
DEBUG_LOG(m_logger) << "getActiveSound hostname=" << hostname;
|
|
if (!stopAllSounds(request.egcuId()).isEmpty()) // BLOCKING
|
|
failedCount++;
|
|
}
|
|
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0);
|
|
if (failedCount > 0)
|
|
reply = Core::FunctionReplyObject(0, tr_lts("dds", "Failed to stop %1 sounds.")).arg(failedCount);
|
|
|
|
m_ddsHandler->ftsSom()->stopAllSoundsReply(cookie, reply);
|
|
}
|
|
|
|
void HandlerSounds::onGetSoundsRequest(const rti::core::SampleIdentity &cookie,
|
|
const GetSoundsRequest &request)
|
|
{
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0, tr_lts("dds", "GetSounds"));
|
|
DEBUG_LOG(m_logger) << "GetSounds: " << request;
|
|
m_ddsHandler->ftsSom()->getSoundsReply(cookie, reply);
|
|
}
|
|
|
|
QString HandlerSounds::enumToString(const SoundCategory &category)
|
|
{
|
|
switch (category.underlying())
|
|
{
|
|
case SoundManagement::SoundCategory::Aircraft:
|
|
return QStringLiteral("Aircrafts");
|
|
case SoundManagement::SoundCategory::Battlefield:
|
|
return QStringLiteral("Battlefields");
|
|
case SoundManagement::SoundCategory::Boat:
|
|
return QStringLiteral("Boats");
|
|
case SoundManagement::SoundCategory::Explosion:
|
|
return QStringLiteral("Explosions");
|
|
case SoundManagement::SoundCategory::Helicopter:
|
|
return QStringLiteral("Helicopter");
|
|
case SoundManagement::SoundCategory::MotorsAndUrbanTraffic:
|
|
return QStringLiteral("Motors_and_urban_traffic");
|
|
case SoundManagement::SoundCategory::Vehicle:
|
|
return QStringLiteral("Vehicles");
|
|
case SoundManagement::SoundCategory::InsideBuilding:
|
|
return QStringLiteral("Inside_buildings");
|
|
case SoundManagement::SoundCategory::Unknown:
|
|
return QStringLiteral("Unknown");
|
|
}
|
|
return QStringLiteral("Unknown");
|
|
}
|
|
|
|
SoundManagement::SoundCategory HandlerSounds::stringToEnum(const QString &category)
|
|
{
|
|
if (category.contains(QStringLiteral("Aircrafts"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Aircraft;
|
|
if (category.contains(QStringLiteral("Battlefields"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Battlefield;
|
|
if (category.contains(QStringLiteral("Boats"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Boat;
|
|
if (category.contains(QStringLiteral("Explosions"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Explosion;
|
|
if (category.contains(QStringLiteral("Helicopter"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Helicopter;
|
|
if (category.contains(QStringLiteral("Motors_and_urban_traffic"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::MotorsAndUrbanTraffic;
|
|
if (category.contains(QStringLiteral("Vehicles"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Vehicle;
|
|
if (category.contains(QStringLiteral("Inside_buildings"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::InsideBuilding;
|
|
if (category.contains(QStringLiteral("Unknown"), Qt::CaseInsensitive))
|
|
return SoundManagement::SoundCategory::Unknown;
|
|
|
|
return SoundManagement::SoundCategory::Unknown;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* void HandlerMenuStruct::onModifyMenuStructRequest(const rti::core::SampleIdentity &cookie,
|
|
const MenuStruct &request)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onModifyMenuStructRequest: " << request;
|
|
auto ret = request.id() > 0 ? modifyMenuStructRequest(request) : createMenuStructRequest(request);
|
|
if (ret.error())
|
|
WARNING_LOG(m_logger) << ret();
|
|
m_fts->modifyMenuStructReply(cookie, ret);
|
|
}
|
|
|
|
Core::FunctionReplyObject HandlerMenuStruct::createMenuStructRequest(const MenuStruct &request)
|
|
{
|
|
ObjectMenuStruct *ifs = new ObjectMenuStruct(m_dts, m_db);
|
|
|
|
DEBUG_LOG(m_logger) << "request.menuEntries.size() : " << request.menuEntries().size();
|
|
Core::FunctionReplyObject ret = ifs->createFromDds(request);
|
|
|
|
if (ret.error())
|
|
delete ifs;
|
|
else
|
|
m_objMap.insert(ifs->getId(), ifs);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
void HandlerSounds::onControlSoundRequest(const rti::core::SampleIdentity &cookie,
|
|
const ControlSoundRequest &request)
|
|
{
|
|
DEBUG_LOG(m_logger) << "ControlSound: " << request
|
|
<< " category=" << request.category();
|
|
|
|
const QString user = Settings::somUser();
|
|
const QString passwd = Settings::somPasswd();
|
|
const QString hostname = m_hostnames.value(request.egcuId());
|
|
|
|
switch (request.control().underlying())
|
|
{
|
|
case SoundManagement::PlayControl::StopSound:
|
|
{
|
|
onStopSingleSound(request.egcuId(), request.category(), request.soundId());
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0);
|
|
m_ddsHandler->ftsSom()->controlSoundReply(cookie, reply);
|
|
break;
|
|
}
|
|
case SoundManagement::PlayControl::PlaySingle:
|
|
case SoundManagement::PlayControl::PlayLoop: // NOTE: falls through if PlaySingle !
|
|
{
|
|
const bool loop = (request.control().underlying() == SoundManagement::PlayControl::PlayLoop);
|
|
const int durationMs = getDuration(request.category(), request.soundId());
|
|
// QTimer::singleShot(1 * 60 * 1000, this, [id, this]() { m_mainHandler->dds()->dtsAlm()->removeNotificationByKey(id); });
|
|
const int soundId = request.soundId();
|
|
const int egcuId = request.egcuId();
|
|
const SoundManagement::SoundCategory category = request.category();
|
|
DEBUG_LOG(m_logger) << "Play: durationMs=" << durationMs
|
|
<< " egcuId=" << egcuId
|
|
<< " soundId=" << soundId
|
|
<< " loop=" << loop;
|
|
const int control = static_cast<int>(request.control().underlying());
|
|
const int volumePercent = static_cast<int>(request.volumePercent());
|
|
const QString msg(playBackgroundSound(user, passwd, hostname, enumToString(request.category()), request.soundId(), volumePercent, control)); // => blocking !!
|
|
|
|
if (!msg.isEmpty())
|
|
{
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(-1, tr_lts("dds", "Playing sound failed: %1"), { msg.toStdString() });
|
|
m_ddsHandler->ftsSom()->controlSoundReply(cookie, reply);
|
|
return;
|
|
}
|
|
|
|
if (!loop)
|
|
QTimer::singleShot(durationMs, this, [ egcuId, category, soundId, this]() { onStopSingleSound(egcuId, category, soundId); }); // stop sound after n ms (aka. after clip ends)
|
|
|
|
// Publish on DDS
|
|
// insert into m_soundStates
|
|
|
|
SoundManagement::SoundState soundState;
|
|
soundState.egcuId(egcuId);
|
|
soundState.soundId(soundId);
|
|
soundState.category(request.category());
|
|
soundState.id(m_indexActiveSound);
|
|
soundState.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
soundState.inLoop(loop);
|
|
DEBUG_LOG(m_logger) << "id=" << m_indexActiveSound
|
|
<< " category=" << request.category()
|
|
<< " egcuId=" << request.egcuId()
|
|
<< " soundId=" << request.soundId()
|
|
<< " time=" << soundState.sampleTime();
|
|
m_ddsHandler->dtsSom()->publish(soundState);
|
|
m_soundStates.append(soundState);
|
|
|
|
m_indexActiveSound++;
|
|
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0);
|
|
m_ddsHandler->ftsSom()->controlSoundReply(cookie, reply);
|
|
|
|
break;
|
|
}
|
|
case SoundManagement::PlayControl::StopAllSounds:
|
|
{
|
|
stopAllSounds(request.egcuId());
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0);
|
|
m_ddsHandler->ftsSom()->controlSoundReply(cookie, reply);
|
|
break;
|
|
}
|
|
case SoundManagement::PlayControl::GetState:
|
|
{
|
|
getActiveSound(request.egcuId());
|
|
Core::FunctionReplyObject reply = Core::FunctionReplyObject(0);
|
|
m_ddsHandler->ftsSom()->controlSoundReply(cookie, reply);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandlerSounds::onStopSingleSound(const int egcuId, const SoundManagement::SoundCategory soundCategory, const int soundId)
|
|
{
|
|
QString user = Settings::somUser();
|
|
QString passwd = Settings::somPasswd();
|
|
QString host = m_hostnames.value(egcuId);
|
|
|
|
DEBUG_LOG(m_logger) << "egcuId=" << egcuId
|
|
<< " soundId=" << soundId
|
|
<< " category=" << enumToString(soundCategory);
|
|
|
|
// QMutableVectorIterator simplifies and is less errorprone :-)
|
|
QMutableVectorIterator<SoundState> it(m_soundStates);
|
|
while (it.hasNext())
|
|
{
|
|
const SoundState &item = it.next();
|
|
if ((item.soundId() == soundId) && (item.egcuId() == egcuId) && item.category() == soundCategory)
|
|
{
|
|
DEBUG_LOG(m_logger) << "remove Sound from DDS-BUS id=" << item.id()
|
|
<< " egcuId=" << item.egcuId();
|
|
|
|
{
|
|
// start update request
|
|
|
|
// http://ubeecu0001/bgsound.php?category=Vehicles&sound=2&control=2
|
|
|
|
QUrl url;
|
|
int control = SoundManagement::PlayControl::StopSound;
|
|
QString category = enumToString(soundCategory);
|
|
QString request = QStringLiteral("http://%1/bgsound.php?category=%2&sound=%3&control=%4")
|
|
.arg(host)
|
|
.arg(category)
|
|
.arg(soundId)
|
|
.arg(control);
|
|
url.setUrl(request);
|
|
url.setUserName(user);
|
|
url.setPassword(passwd);
|
|
startRequest(url);
|
|
}
|
|
|
|
m_ddsHandler->dtsSom()->removeSoundStateByKey(item.id());
|
|
it.remove();
|
|
// combination of soundId and egcuId may occur more than once, do not break the loop
|
|
}
|
|
} //while
|
|
}
|
|
|
|
QString HandlerSounds::stopAllSounds(const int egcuId)
|
|
{
|
|
const QString user(Settings::somUser());
|
|
const QString passwd(Settings::somPasswd());
|
|
const QString host(m_hostnames.value(egcuId));
|
|
|
|
// http://ubeecu0001/bgsound.php?control=5
|
|
// 200{ "ID":"0x510","Name":"Sound Report","sounds":[{"category":"Explosions","sound":"0001"}]}
|
|
// 200{ "ID":"0x510","Name":"Sound Report","sounds":[{"category":"Explosions","sound":"0001"},{"category":"Explosions","sound":"0001"}]}
|
|
QUrl url;
|
|
const int control = SoundManagement::PlayControl::StopAllSounds;
|
|
const QString request = QStringLiteral("http://%1/bgsound.php?control=%2")
|
|
.arg(host)
|
|
.arg(control);
|
|
url.setUrl(request);
|
|
url.setUserName(user);
|
|
url.setPassword(passwd);
|
|
|
|
|
|
const QString msg(startRequestBlocking(url));
|
|
|
|
if (!msg.isEmpty())
|
|
return msg;
|
|
|
|
QMutableVectorIterator<SoundState> it(m_soundStates);
|
|
while (it.hasNext())
|
|
{
|
|
const SoundState &ss(it.next());
|
|
|
|
DEBUG_LOG(m_logger) << "Sound EGCU=" << ss.egcuId() << " soundId=" << ss.soundId();
|
|
if (ss.egcuId() != egcuId)
|
|
continue;
|
|
|
|
DEBUG_LOG(m_logger) << "remove Sound from DDS-BUS id=" << ss.id()
|
|
<< " egcuId=" << ss.egcuId();
|
|
m_ddsHandler->dtsSom()->removeSoundStateByKey(ss.id());
|
|
it.remove();
|
|
}
|
|
|
|
return {}; // no error
|
|
}
|
|
|
|
void HandlerSounds::getActiveSound(const int egcuId)
|
|
{
|
|
QString user = Settings::somUser();
|
|
QString passwd = Settings::somPasswd();
|
|
QString host = m_hostnames.value(egcuId);
|
|
|
|
// http://ubeecu0001/bgsound.php?control=5
|
|
// 200{ "ID":"0x510","Name":"Sound Report","sounds":[{"category":"Explosions","sound":"0001"}]}
|
|
// 200{ "ID":"0x510","Name":"Sound Report","sounds":[{"category":"Explosions","sound":"0001"},{"category":"Explosions","sound":"0001"}]}
|
|
QUrl url;
|
|
int control = SoundManagement::PlayControl::GetState;
|
|
QString request = QStringLiteral("http://%1/bgsound.php?control=%2")
|
|
.arg(host)
|
|
.arg(control);
|
|
url.setUrl(request);
|
|
url.setUserName(user);
|
|
url.setPassword(passwd);
|
|
DEBUG_LOG(m_logger) << "startRequest: " << url.toString();
|
|
startRequest(url);
|
|
}
|
|
|
|
QString HandlerSounds::playBackgroundSound(const QString &user,
|
|
const QString &passwd,
|
|
const QString &host,
|
|
const QString &category,
|
|
const int sound,
|
|
const int volume,
|
|
const int control)
|
|
{
|
|
QUrl url;
|
|
//http://localhost/bgsound.php?category=Aircrafts&sound=2&control=3&vol=50
|
|
QString request = QStringLiteral("http://%1/bgsound.php?category=%2&sound=%3&control=%4&vol=%5")
|
|
.arg(host)
|
|
.arg(category)
|
|
.arg(sound)
|
|
.arg(control)
|
|
.arg(volume);
|
|
url.setUrl(request);
|
|
url.setUserName(user);
|
|
url.setPassword(passwd);
|
|
DEBUG_LOG(m_logger) << "startRequest: " << url.toString()
|
|
<< " host=" << host;
|
|
return startRequestBlocking(url);
|
|
}
|
|
|
|
QString HandlerSounds::startRequestBlocking(const QUrl &requestedUrl)
|
|
{
|
|
DEBUG_LOG(m_logger) << "startRequest: " << requestedUrl.toString();
|
|
m_httpRequestAborted = false;
|
|
auto reply = m_qnam.get(QNetworkRequest(requestedUrl));
|
|
await(reply, &QNetworkReply::finished);
|
|
return httpFinishedBlocking(reply);
|
|
}
|
|
|
|
void HandlerSounds::startRequest(const QUrl &requestedUrl)
|
|
{
|
|
DEBUG_LOG(m_logger) << "startRequest: " << requestedUrl.toString();
|
|
m_httpRequestAborted = false;
|
|
auto reply = m_qnam.get(QNetworkRequest(requestedUrl));
|
|
connect(reply, &QNetworkReply::finished, this, &HandlerSounds::httpFinished);
|
|
}
|
|
|
|
QString HandlerSounds::httpFinishedBlocking(QNetworkReply *reply)
|
|
{
|
|
DEBUG_LOG(m_logger) << "httpFinishedBlocking";
|
|
QUrl url;
|
|
// auto reply = qobject_cast<QNetworkReply *>(sender());
|
|
// Q_ASSERT(reply);
|
|
// if (!reply)
|
|
// return {};
|
|
QNetworkRequest request = reply->request();
|
|
url = request.url();
|
|
|
|
if (m_httpRequestAborted)
|
|
{
|
|
ERROR_LOG(m_logger) << "httpRequestAborted";
|
|
reply->deleteLater();
|
|
return QString::fromStdString(tr_lts("dds", "httpRequestAborted"));
|
|
}
|
|
|
|
if (reply->error())
|
|
{
|
|
QByteArray data = reply->readAll();
|
|
QString dataStr = QString::fromStdString(data.toStdString());
|
|
ERROR_LOG(m_logger) << "reply->error: " << reply->errorString()
|
|
<< " host=" << url.host()
|
|
<< " query='" << url.query()
|
|
<< "' '" << qUtf8Printable(url.toString()) << "'"
|
|
<< " data=" << dataStr;
|
|
// Also add unsuccessful feedback
|
|
QString query = url.query();
|
|
if (query.contains(QStringLiteral("control=5")))
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_activeSounds.insert host=" << url.host();
|
|
m_activeSounds.insert(url.host(), QString());
|
|
}
|
|
reply->deleteLater();
|
|
return reply->errorString();
|
|
}
|
|
|
|
|
|
// Sucess
|
|
|
|
//parse the reply JSON and display result in the UI
|
|
const QByteArray json(reply->readAll());
|
|
DEBUG_LOG(m_logger) << "Sucess " << json;
|
|
QString jsonStr = QString::fromStdString(json.toStdString());
|
|
if (jsonStr.contains(QStringLiteral("510"))) // 510 = Sound Report
|
|
handleSoundReport(jsonStr, url.host());
|
|
|
|
reply->deleteLater();
|
|
return {};
|
|
}
|
|
|
|
void HandlerSounds::httpFinished()
|
|
{
|
|
DEBUG_LOG(m_logger) << "httpFinished";
|
|
QUrl url;
|
|
auto reply = qobject_cast<QNetworkReply *>(sender());
|
|
if (!reply)
|
|
return;
|
|
QNetworkRequest request = reply->request();
|
|
url = request.url();
|
|
|
|
if (m_httpRequestAborted)
|
|
{
|
|
ERROR_LOG(m_logger) << "httpRequestAborted";
|
|
reply->deleteLater();
|
|
return;
|
|
}
|
|
|
|
if (reply->error())
|
|
{
|
|
QByteArray data = reply->readAll();
|
|
QString dataStr = QString::fromStdString(data.toStdString());
|
|
ERROR_LOG(m_logger) << "reply->error: " << reply->errorString()
|
|
<< " host=" << url.host()
|
|
<< " query='" << url.query()
|
|
<< "' '" << qUtf8Printable(url.toString()) << "'"
|
|
<< " data=" << dataStr;
|
|
// Also add unsuccessful feedback
|
|
QString query = url.query();
|
|
if (query.contains(QStringLiteral("control=5")))
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_activeSounds.insert host=" << url.host();
|
|
m_activeSounds.insert(url.host(), QString());
|
|
}
|
|
reply->deleteLater();
|
|
return;
|
|
}
|
|
|
|
|
|
// Sucess
|
|
|
|
//parse the reply JSON and display result in the UI
|
|
const QByteArray json(reply->readAll());
|
|
DEBUG_LOG(m_logger) << "Sucess " << json;
|
|
QString jsonStr = QString::fromStdString(json.toStdString());
|
|
if (jsonStr.contains(QStringLiteral("510"))) // 510 = Sound Report
|
|
handleSoundReport(jsonStr, url.host());
|
|
|
|
reply->deleteLater();
|
|
}
|
|
|
|
int HandlerSounds::getAssetId(const QString &hostName)
|
|
{
|
|
QHashIterator<int, QString> i(m_hostnames);
|
|
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
QString name = i.value();
|
|
if (name.contains(hostName, Qt::CaseInsensitive))
|
|
return i.key();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int HandlerSounds::getSoundIndex(const SoundCategory &category, const QString &name)
|
|
{
|
|
for (const SoundStr &soundName: qAsConst(m_soundNames))
|
|
if ((category == soundName.category) && (name == soundName.name))
|
|
return soundName.index;
|
|
return -1;
|
|
}
|
|
|
|
int HandlerSounds::getDuration(const SoundManagement::SoundCategory& category,const int soundId)
|
|
{
|
|
for (const SoundStr &soundName: qAsConst(m_soundNames))
|
|
{
|
|
if ( soundId == soundName.soundId
|
|
&& category == soundName.category)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Duration=" << soundName.duration << "ms";
|
|
return soundName.duration;
|
|
}
|
|
} // for
|
|
return -1;
|
|
}
|
|
|
|
void HandlerSounds::handleSoundReport(const QString &json, const QString &host)
|
|
{
|
|
SoundManagement::SoundState soundState;
|
|
QString jsonString;
|
|
QString jsonStr = QString::fromStdString(json.toStdString());
|
|
DEBUG_LOG(m_logger) << "remove 200";
|
|
jsonString = jsonStr.remove(QStringLiteral("200"));
|
|
m_activeSounds.insert(host, jsonString);
|
|
// Send Result Topic
|
|
DEBUG_LOG(m_logger) << "Send Result Topic";
|
|
|
|
DEBUG_LOG(m_logger) << "m_updateActiveSoundsTimer->stop();";
|
|
|
|
DEBUG_LOG(m_logger) << "host=" << host
|
|
<< " jsonString= " << jsonString;
|
|
// decode JSON-Object
|
|
QJsonDocument doc = QJsonDocument::fromJson(jsonString.toUtf8());
|
|
QJsonObject jsonObject;
|
|
// check validity of the document
|
|
if (!doc.isNull())
|
|
{
|
|
if (doc.isObject())
|
|
{
|
|
jsonObject = doc.object();
|
|
|
|
const QJsonArray &sounds = jsonObject[QStringLiteral("sounds")].toArray();
|
|
|
|
// TODO Pruefen, ob in der lokalen Verwaltung noch Sounds sind, die geloescht und vom DDS-Bus genommen
|
|
// werden muessen.
|
|
|
|
for (const QJsonValue &valSound : qAsConst(sounds))
|
|
{
|
|
const QJsonObject &sound = valSound.toObject();
|
|
bool found = false;
|
|
QString categoryStr = sound.value(QStringLiteral("category")).toString();
|
|
QString name = sound.value(QStringLiteral("sound")).toString();
|
|
int egcuId = getAssetId(host);
|
|
SoundManagement::SoundCategory category = stringToEnum(categoryStr);
|
|
int soundId = getSoundIndex(category, name);
|
|
|
|
|
|
soundState.egcuId(egcuId);
|
|
soundState.soundId(soundId);
|
|
soundState.category(category);
|
|
soundState.id(m_indexActiveSound);
|
|
soundState.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
DEBUG_LOG(m_logger) << "id=" << m_indexActiveSound
|
|
<< " category=" << categoryStr
|
|
<< " name=" << name
|
|
<< " egcuId=" << egcuId
|
|
<< " soundId=" << soundId
|
|
<< " time=" << soundState.sampleTime();
|
|
|
|
for (const SoundManagement::SoundState& item : qAsConst(m_soundStates))
|
|
{
|
|
if ( (item.egcuId() == soundState.egcuId()) &&
|
|
(item.category() == soundState.category()) &&
|
|
(item.soundId() == soundState.soundId()) )
|
|
{
|
|
DEBUG_LOG(m_logger) << "Sound is already on DDS-Bus";
|
|
found = true;
|
|
break;
|
|
}
|
|
} // for
|
|
|
|
if (!found)
|
|
{
|
|
m_indexActiveSound++;
|
|
DEBUG_LOG(m_logger) << "Sound publish";
|
|
m_ddsHandler->dtsSom()->publish(soundState);
|
|
m_soundStates.append(soundState);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << "Document is not an object";
|
|
}
|
|
else
|
|
{
|
|
if (jsonStr.size() == 0)
|
|
DEBUG_LOG(m_logger) << "No Sounds for " << host;
|
|
else
|
|
ERROR_LOG(m_logger) << "Invalid JSON...\n" << jsonStr;
|
|
}
|
|
m_updateActiveSoundsTimer->stop();
|
|
}
|
|
|
|
void HandlerSounds::onTimerTimeout()
|
|
{
|
|
ERROR_LOG(m_logger) << "Problem when querying the active sounds from the EGCU's";
|
|
}
|
|
|
|
void HandlerSounds::onInstrumentationAssetChanged(const InfrastructureManagement::InstrumentationAsset &data, DataModification modType)
|
|
{
|
|
if (modType != DataModification::eAdded &&
|
|
modType != DataModification::eModified)
|
|
return;
|
|
|
|
DEBUG_LOG(m_logger) << "onInstrumentationAssetChanged id=" << data.id()
|
|
<< " hostname=" << QString::fromStdString(data.hostname())
|
|
<< " mountingPointTypeId=" << data.mountingPointTypeId()
|
|
<< " assetStateId=" << data.assetStateId();
|
|
if ((data.mountingPointTypeId() == InfrastructureManagement::MountingPointType::EffectGenerationControlUnit)
|
|
&& data.assetStateId() == InfrastructureManagement::InstrumentationAssetState::Mounted
|
|
&& data.hostname().size() > 0)
|
|
{
|
|
QString hostname = QString::fromStdString(data.hostname());
|
|
DEBUG_LOG(m_logger) << "m_hostnames.insert id=" << data.id()
|
|
<< " hostname=" << hostname
|
|
<< " hostname.size=" << hostname.size()
|
|
<< " mountingPointTypeId=" << data.mountingPointTypeId()
|
|
<< " assetStateId=" << data.assetStateId();
|
|
if (hostname.size() > 0 )
|
|
{
|
|
DEBUG_LOG(m_logger) << "insert EGCU in m_hostnames " << data.hostname();
|
|
m_hostnames.insert(data.id(), QString::fromStdString(data.hostname()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandlerSounds::onMountingPointAssetChanged(const InfrastructureManagement::MountingPointAsset &data, DataModification modType)
|
|
{
|
|
if (modType != DataModification::eAdded &&
|
|
modType != DataModification::eModified)
|
|
return;
|
|
DEBUG_LOG(m_logger) << "onMountingPointAssetChanged"
|
|
<< " id= " << data.id()
|
|
<< " assetId= " << data.assetId()
|
|
<< " structureElementId= " << data.structureElementId();
|
|
m_mountingPointAsset.insert(data.structureElementId(),data.assetId());
|
|
}
|
|
|
|
void HandlerSounds::onSoundStateChanged(const SoundManagement::SoundState &data, DataModification modType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onSoundStateChanged"
|
|
<< " id= " << data.id()
|
|
<< " egcuId= " << data.egcuId()
|
|
<< " soundId=" << data.soundId()
|
|
<< " modType=" << modType;
|
|
|
|
if (modType != DataModification::eAdded &&
|
|
modType != DataModification::eModified)
|
|
return;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
|
|
} // namespace SoundManagement
|