ScStw/shared-libraries
ScStw/shared-libraries
Archived
2
0
Fork 0
Code Issues 5 Pull requests Projects Releases Packages Wiki Activity

some more fixes and additions;

Browse source 
completed #5
This commit is contained in:
Dorian Zedler 2020-10-03 15:15:49 +02:00
parent 46c62ba187
commit a56eae71a7
Signed by: dorian
GPG key ID: D3B255CB8BC7CD37
7 changed files with 147 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
ScStwLibraries/headers/client/scstwremoterace.h
View file

@ -29,7 +29,7 @@ class ScStwRemoteRace : public ScStwRace
{
Q_OBJECT
public:
ScStwRemoteRace(ScStwClient *scStwClient, QObject *parent = nullptr);
ScStwRemoteRace(ScStwClient *scStwClient, ScStwSettings *settings = nullptr, QObject *parent = nullptr);
enum RaceMode {
LOCAL,
@ -60,13 +60,14 @@ public slots:
private slots:
void handleBaseStationSignal(ScStw::SignalKey key, QVariant data);
void handleSettingChange(int keyInt, int keyLevel, QVariant value);
bool refreshRemoteTimers(QVariantList remoteTimers);
void rebuildRemoteTimers(QVariantList remoteTimers);
void refreshDetails(QVariantMap details);
void handleClientStateChange();
RaceMode getMode();
bool local();
};
#endif // SCSTWREMOTEMONITORRACE_H

13
ScStwLibraries/headers/scstwrace.h
View file

@ -25,6 +25,7 @@
#include <QEventLoop>
#include "scstwtimer.h"
#include "scstwsoundplayer.h"
#include "scstwsettings.h"
class ScStwRemoteRace;
@ -61,6 +62,7 @@ class ScStwRace : public QObject
public:
explicit ScStwRace(QObject *parent = nullptr);
explicit ScStwRace(ScStwSettings *settings, QObject *parent = nullptr);
friend class ScStwRemoteRace;
@ -80,7 +82,8 @@ private:
// sounds
ScStwSoundPlayer * soundPlayer;
// some settings
// settings
ScStwSettings *settings;
double soundVolume;
bool competitionMode;
bool competitionModeChangedRecently;
@ -128,7 +131,7 @@ public slots:
bool writeStartSoundSetting(ScStwSoundPlayer::StartSound sound, bool enabled, int delay);
bool setSoundVolume(double volume);
virtual bool addTimer(ScStwTimer *timer);
void setCompetitionMode(bool competitionMode);
bool setCompetitionMode(bool competitionMode);
// getters
RaceState getState();
@ -148,6 +151,7 @@ private slots:
bool playSoundsAndStartTimers();
bool doDelayAndSoundOfCurrentStartState(double *timeOfSoundPlaybackStart = nullptr);
void enableAllTimers();
void technicalIncident();
/**
* \brief Function to declare the winner and looser timers after a timer has been stopped
@ -158,6 +162,11 @@ private slots:
virtual bool getIsReadyForNextState();
void handleTimerReadyStateChange(ScStwTimer::ReadyState readyState);
// settings
bool writeStartSoundSettingKey(ScStwSoundPlayer::StartSound sound, QString key, QVariant value);
virtual void handleSettingChange(int keyInt, int keyLevel, QVariant value);
void reloadAllSettings();
signals:
void startTimers();
void stopTimers(int type);

9
ScStwLibraries/sources/client/scstwremoterace.cpp
View file

@ -18,7 +18,7 @@
#include "scstwremoterace.h"
ScStwRemoteRace::ScStwRemoteRace(ScStwClient *scStwClient, QObject *parent) : ScStwRace(parent)
ScStwRemoteRace::ScStwRemoteRace(ScStwClient *scStwClient, ScStwSettings *settings, QObject *parent) : ScStwRace(settings, parent)
{
this->isReadyForNextState = true;
@ -90,7 +90,6 @@ ScStw::StatusCode ScStwRemoteRace::reset() {
return ScStw::StatusCode(reply["status"].toInt());
}
// -------------------------
// --- Base Station sync ---
// -------------------------
@ -130,6 +129,12 @@ bool ScStwRemoteRace::local() {
return this->getMode() == LOCAL;
}
void ScStwRemoteRace::handleSettingChange(int keyInt, int keyLevel, QVariant value) {
if(this->local())
return ScStwRace::handleSettingChange(keyInt, keyLevel, value);
}
/**
* @brief ScStwAppBackend::handleBaseStationUpdate
*

5
ScStwLibraries/sources/client/scstwremotesettings.cpp
View file

@ -37,6 +37,8 @@ QVariant ScStwRemoteSettings::readSetting(QString key, int keyInt, int keyLevel)
if(this->getMode() == LOCAL || keyLevel > ScStwSettings::KeyLevel)
return ScStwSettings::readSetting(key, keyInt, keyLevel);
qDebug() << "Setting read: keyLevel: " << keyLevel << " key: " << key;
return this->scStwClient->readRemoteSetting(ScStwSettings::BaseStationSetting(keyInt));
}
@ -44,6 +46,9 @@ bool ScStwRemoteSettings::writeSetting(QString key, QVariant value, int keyInt,
if(this->getMode() == LOCAL || keyLevel > ScStwSettings::KeyLevel)
return ScStwSettings::writeSetting(key, value, keyInt, keyLevel);
qDebug() << "Setting write: keyLevel: " << keyLevel << " key: " << key << " value: " << value;
ScStw::StatusCode res = this->scStwClient->writeRemoteSetting(ScStwSettings::BaseStationSetting(keyInt), value);
return res == ScStw::Success;

128
ScStwLibraries/sources/scstwrace.cpp
View file

@ -18,7 +18,11 @@
#include "../headers/scstwrace.h"
ScStwRace::ScStwRace(QObject *parent) : QObject(parent)
ScStwRace::ScStwRace(QObject * parent) : ScStwRace(nullptr, parent)
{
}
ScStwRace::ScStwRace(ScStwSettings *settings, QObject *parent) : QObject(parent)
{
this->state = IDLE;
@ -36,12 +40,18 @@ ScStwRace::ScStwRace(QObject *parent) : QObject(parent)
connect(this, &ScStwRace::timersChanged, this, &ScStwRace::detailsChanged);
connect(this, &ScStwRace::stateChanged, this, &ScStwRace::detailsChanged);
// write default settings
// init settings
this->competitionMode = false;
this->soundVolume = 1;
this->startSoundSettings.insert(ScStwSoundPlayer::Start, {{"Enabled", true}, {"Delay", 1}});
this->writeStartSoundSetting(ScStwSoundPlayer::AtYourMarks, false, 0);
this->writeStartSoundSetting(ScStwSoundPlayer::Ready, false, 0);
this->setSoundVolume(1.0);
this->competitionMode = false;
this->settings = settings;
if(this->settings != nullptr) {
connect(this->settings, &ScStwSettings::settingChanged, this, &ScStwRace::handleSettingChange);
}
}
// --------------------------
@ -81,6 +91,9 @@ ScStw::StatusCode ScStwRace::stop() {
return ScStw::CurrentStateNotVaildForOperationError;
}
if(this->competitionMode)
return this->cancel();
qDebug() << "+ [INFO] stopping race";
double timeOfStop = QDateTime::currentMSecsSinceEpoch();
@ -150,7 +163,7 @@ ScStw::StatusCode ScStwRace::reset() {
ScStw::StatusCode returnCode = ScStw::Success;
foreach(ScStwTimer *speedTimer, this->timers){
if(!speedTimer->reset() && speedTimer->getState() != ScStwTimer::DISABLED) {
if(!speedTimer->reset() && speedTimer->getState() != ScStwTimer::DISABLED && speedTimer->getState() != ScStwTimer::IDLE) {
returnCode = ScStw::InternalErrorTimerOperationFailed;
}
}
@ -190,6 +203,13 @@ ScStw::StatusCode ScStwRace::cancel() {
return returnCode;
}
void ScStwRace::technicalIncident() {
foreach(ScStwTimer *timer, this->timers){
timer->cancel();
}
this->setState(INCIDENT);
}
int ScStwRace::handleFalseStart() {
if(this->getState() != STARTING && this->getState() != RUNNING)
return ScStw::CurrentStateNotVaildForOperationError;
@ -284,7 +304,7 @@ bool ScStwRace::playSoundsAndStartTimers() {
// play ready tone
if(!this->soundPlayer->play(ScStwSoundPlayer::Ready, this->soundVolume)) {
qDebug() << "Ready sound redturned false!";
this->setState(INCIDENT);
this->technicalIncident();
return false;
}
}
@ -316,7 +336,7 @@ bool ScStwRace::playSoundsAndStartTimers() {
qDebug() << "now playing start sound";
double timeOfSoundPlaybackStart;
if(!this->doDelayAndSoundOfCurrentStartState(&timeOfSoundPlaybackStart)) {
this->setState(INCIDENT);
this->technicalIncident();
return false;
}
@ -331,13 +351,13 @@ bool ScStwRace::playSoundsAndStartTimers() {
}
if(!startOk) {
qDebug() << "[ERROR][START] error staring all timers";
this->setState(INCIDENT);
this->technicalIncident();
return false;
}
if(!this->soundPlayer->waitForSoundFinish()) {
qDebug() << "[ERROR][START] start sound wait error";
this->setState(INCIDENT);
this->technicalIncident();
return false;
}
@ -474,7 +494,7 @@ bool ScStwRace::getIsReadyForNextState() {
subTimer->setState(ScStwTimer::CANCELLED);
}
this->setState(INCIDENT);
this->technicalIncident();
qDebug() << "[ERROR][RACE] Could not start due to not-ready timers";
@ -514,9 +534,12 @@ void ScStwRace::handleTimerWantsToBeDisabledChange(ScStwTimer* timer, bool wants
}
}
void ScStwRace::setCompetitionMode(bool competitionMode) {
bool ScStwRace::setCompetitionMode(bool competitionMode) {
if(this->settings != nullptr)
return false;
if(this->competitionMode == competitionMode)
return;
return true;
qDebug() << "Setting competition mode to " << competitionMode;
@ -526,6 +549,8 @@ void ScStwRace::setCompetitionMode(bool competitionMode) {
this->competitionModeChangedRecently = true;
else if(this->competitionMode)
this->enableAllTimers();
return true;
}
void ScStwRace::enableAllTimers() {
@ -587,20 +612,38 @@ QVariantMap ScStwRace::getCurrentStartDelay() {
}
bool ScStwRace::writeStartSoundSetting(ScStwSoundPlayer::StartSound sound, bool enabled, int delay) {
if(this->settings != nullptr)
return false;
if(sound != ScStwSoundPlayer::AtYourMarks && sound != ScStwSoundPlayer::Ready)
return false;
QVariantMap setting = {{"Enabled", enabled}, {"Delay", delay}};
this->writeStartSoundSettingKey(sound, "Enabled", enabled);
this->writeStartSoundSettingKey(sound, "Delay", delay);
return true;
}
bool ScStwRace::writeStartSoundSettingKey(ScStwSoundPlayer::StartSound sound, QString key, QVariant value) {
if(key != "Delay" && key != "Enabled")
return false;
if(!this->startSoundSettings.contains(sound))
this->startSoundSettings.insert(sound, setting);
this->startSoundSettings.insert(sound, {});
if(!this->startSoundSettings[sound].contains(key))
this->startSoundSettings[sound].insert(key, value);
else
this->startSoundSettings[sound] = setting;
this->startSoundSettings[sound][key] = value;
return true;
}
bool ScStwRace::setSoundVolume(double volume) {
if(this->settings != nullptr)
return false;
if(volume >= 0 && volume <= 1) {
this->soundVolume = volume;
return true;
@ -637,6 +680,63 @@ bool ScStwRace::addTimer(ScStwTimer *timer) {
}
void ScStwRace::reloadAllSettings() {
this->writeStartSoundSetting(
ScStwSoundPlayer::AtYourMarks,
this->settings->readSetting(ScStwSettings::BaseStationSetting::AtYourMarksSoundEnableSetting).toBool(),
this->settings->readSetting(ScStwSettings::BaseStationSetting::AtYourMarksSoundDelaySetting).toDouble()
);
this->writeStartSoundSetting(
ScStwSoundPlayer::Ready,
this->settings->readSetting(ScStwSettings::BaseStationSetting::ReadySoundEnableSetting).toBool(),
this->settings->readSetting(ScStwSettings::BaseStationSetting::ReadySoundDelaySetting).toDouble()
);
this->setSoundVolume(this->settings->readSetting(ScStwSettings::SoundVolumeSetting).toDouble());
this->setCompetitionMode(this->settings->readSetting(ScStwSettings::CompetitionModeSetting).toBool());
}
void ScStwRace::handleSettingChange(int keyInt, int keyLevel, QVariant value) {
if(keyInt == -1) {
this->reloadAllSettings();
return;
}
qDebug() << "Setting changed";
switch (keyLevel) {
case 0: {
// BaseStationSetting!!
ScStwSettings::BaseStationSetting key = static_cast<ScStwSettings::BaseStationSetting>(keyInt);
switch (key) {
case ScStwSettings::AtYourMarksSoundEnableSetting:
this->writeStartSoundSettingKey(ScStwSoundPlayer::AtYourMarks, "Enabled", value);
break;
case ScStwSettings::AtYourMarksSoundDelaySetting:
this->writeStartSoundSettingKey(ScStwSoundPlayer::AtYourMarks, "Delay", value);
break;
case ScStwSettings::ReadySoundEnableSetting:
this->writeStartSoundSettingKey(ScStwSoundPlayer::Ready, "Enabled", value);
break;
case ScStwSettings::ReadySoundDelaySetting:
this->writeStartSoundSettingKey(ScStwSoundPlayer::Ready, "Delay", value);
break;
case ScStwSettings::SoundVolumeSetting:
this->setSoundVolume(value.toDouble());
break;
case ScStwSettings::CompetitionModeSetting:
this->setCompetitionMode(value.toBool());
default:
return;
}
break;
}
}
}
ScStwRace::RaceState ScStwRace::getState() {
return this->state;
}

2
ScStwLibraries/sources/scstwsetting.cpp
View file

@ -35,8 +35,6 @@ QVariant ScStwSetting::getValue() {
this->hasToReload = false;
}
qDebug() << "Setting read: keyLevel: " << this->keyLevel << " key: " << this->key << " value: " << this->valueCache;
return this->valueCache;
}

7
ScStwLibraries/sources/scstwsettings.cpp
View file

@ -36,6 +36,13 @@ ScStwSettings::ScStwSettings(QObject *parent) : QObject(parent)
connect(this, &ScStwSettings::settingChanged, this, &ScStwSettings::writeSettingsToFile);
this->registerKeyLevelConverters(ScStwSettings::KeyLevel, &ScStwSettings::keyToString, &ScStwSettings::keyToType);
this->setDefaultSetting(ScStwSettings::BaseStationSetting::ReadySoundEnableSetting, false);
this->setDefaultSetting(ScStwSettings::BaseStationSetting::ReadySoundDelaySetting, 0);
this->setDefaultSetting(ScStwSettings::BaseStationSetting::AtYourMarksSoundEnableSetting, false);
this->setDefaultSetting(ScStwSettings::BaseStationSetting::AtYourMarksSoundDelaySetting, 0);
this->setDefaultSetting(ScStwSettings::SoundVolumeSetting, 1);
this->setDefaultSetting(ScStwSettings::CompetitionModeSetting, false);
}
QVariant ScStwSettings::readSetting(BaseStationSetting key) {