exodus/1NiM-WatingRoom-WatchController
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: using references where possible

Browse Source
This commit is contained in:
Jakob Gegeniger
2025-04-08 01:07:08 +02:00
parent d1f582e6ba
commit b4277e9261
3 changed files with 164 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/SPIT_Client.h
+17 -17
View File
@@ -212,10 +212,10 @@ class SPIT_Client : I_SAD_Client {
void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage); void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage); void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void addOvertakingSPIT_Message(unique_ptr<SPIT_Message> p_SPIT_Message); void addOvertakingSPIT_Message(unique_ptr<SPIT_Message> p_SPIT_Message);
void parseConnectAnswer(SPIT_Message::ConnectAnswer *p_ConnectAnswer); void parseConnectAnswer(SPIT_Message::ConnectAnswer &p_ConnectAnswer);
void parseDisconnect(SPIT_Message::Disconnect *p_Disconnect); void parseDisconnect(SPIT_Message::Disconnect &p_Disconnect);
void parseWatchdog(SPIT_Message::Watchdog *p_Watchdog); void parseWatchdog(SPIT_Message::Watchdog &p_Watchdog);
void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer *p_WatchdogAnswer); void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer &p_WatchdogAnswer);
public: public:
/** Used internally*/ /** Used internally*/
@@ -224,8 +224,8 @@ class SPIT_Client : I_SAD_Client {
void eventWatchdogLost(); void eventWatchdogLost();
//--------------- SPIT Project --------------- //--------------- SPIT Project ---------------
private: private:
void parseReportSPITProject(SPIT_Message::ReportSPITProject *p_ReportSPITProject); void parseReportSPITProject(SPIT_Message::ReportSPITProject &p_ReportSPITProject);
void parseCloseSPITProject(SPIT_Message::CloseSPITProject *p_CloseSPITProject); void parseCloseSPITProject(SPIT_Message::CloseSPITProject &p_CloseSPITProject);
public: public:
/** Returns the SPITServer's project ID - may be the same as the project's name*/ /** Returns the SPITServer's project ID - may be the same as the project's name*/
@@ -236,9 +236,9 @@ class SPIT_Client : I_SAD_Client {
int getServerFramesPerSecond(); int getServerFramesPerSecond();
private: private:
void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer *p_RequestProjectTransfer); void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer &p_RequestProjectTransfer);
void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer *p_StartProjectTransfer); void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer &p_StartProjectTransfer);
void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer *p_EndProjectTransfer); void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer &p_EndProjectTransfer);
public: public:
static void sendProject(SPIT_Client *p_PtrSPIT_Client); static void sendProject(SPIT_Client *p_PtrSPIT_Client);
@@ -274,8 +274,8 @@ class SPIT_Client : I_SAD_Client {
private: private:
// receive SPITTypes // receive SPITTypes
void parseReportSPITType(SPIT_Message::ReportSPITType *p_ReportSPITType); void parseReportSPITType(SPIT_Message::ReportSPITType &p_ReportSPITType);
void parseRemoveSPITType(SPIT_Message::RemoveSPITType *p_RemoveSPITType); void parseRemoveSPITType(SPIT_Message::RemoveSPITType &p_RemoveSPITType);
int sendSPITTypeInternal(SPITType &p_SPITType); int sendSPITTypeInternal(SPITType &p_SPITType);
public: public:
@@ -297,8 +297,8 @@ class SPIT_Client : I_SAD_Client {
public: public:
//--------------- SPIT Objects --------------- //--------------- SPIT Objects ---------------
private: private:
void parseReportSPITObject(SPIT_Message::ReportSPITObject *p_ReportSPITObject); void parseReportSPITObject(SPIT_Message::ReportSPITObject &p_ReportSPITObject);
void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject); void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject);
int sendSPITObjectInternal(SPITObject *ptrSPITObject); int sendSPITObjectInternal(SPITObject *ptrSPITObject);
public: public:
@@ -320,10 +320,10 @@ class SPIT_Client : I_SAD_Client {
public: public:
//--------------- Play SPIT Objects --------------- //--------------- Play SPIT Objects ---------------
private: private:
void parsePlaySPITStart(SPIT_Message::PlaySPITStart *p_PlaySPITStart); void parsePlaySPITStart(SPIT_Message::PlaySPITStart &p_PlaySPITStart);
void parsePlaySPITObject(SPIT_Message::PlaySPITObject *p_PlaySPITObject); void parsePlaySPITObject(SPIT_Message::PlaySPITObject &p_PlaySPITObject);
void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd *p_PlaySPITEnd); void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd &p_PlaySPITEnd);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_ReportPlayStatus); void parseReportPlayStatus(SPIT_Message::ReportPlayStatus &p_ReportPlayStatus);
public: public:
//--------- Remote ---------- //--------- Remote ----------
components/spit/include/SPIT_Message.h
+2
View File
@@ -156,6 +156,8 @@ class SPIT_Message {
return m_OPPart->getHeader()->getOPFlag(); return m_OPPart->getHeader()->getOPFlag();
} }
const OPPart *getOPPart() const { return m_OPPart.get(); } const OPPart *getOPPart() const { return m_OPPart.get(); }
template<typename T>
T &getOPPartAs() const { return *reinterpret_cast<T *>(m_OPPart.get()); }
private: private:
bool parse(std::vector<char> message); bool parse(std::vector<char> message);
components/spit/src/SPIT_Client.cpp
+145 -183
View File
@@ -213,8 +213,7 @@ void SPIT_Client::eventServerChanged(SAD_DetectedServer &server) {
// // } //Excample // // } //Excample
// } // }
int SPIT_Client::sendSPITMessage(SPIT_Message::OPPart &opPart) {
int SPIT_Client::sendSPITMessage(SPIT_Message::OPPart& opPart) {
if (m_MessageNumber_Send == 255) if (m_MessageNumber_Send == 255)
m_MessageNumber_Send = 1; m_MessageNumber_Send = 1;
else else
@@ -278,16 +277,8 @@ void SPIT_Client::resetMessageNumberReceived() {
void SPIT_Client::checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage) { void SPIT_Client::checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage) {
answerWatchdog(); answerWatchdog();
if (p_SPITMessage == nullptr) { if (!p_SPITMessage || !p_SPITMessage->getHeader() || p_SPITMessage->getOPPart()) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message Parameter == nullptr\n"); ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message incomplete message");
return;
}
if (p_SPITMessage->getHeader() == nullptr) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message no Header\n");
return;
}
if (p_SPITMessage->getOPPart() == nullptr) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message no OPPart\n");
return; return;
} }
@@ -361,82 +352,69 @@ void SPIT_Client::addOvertakingSPIT_Message(unique_ptr<SPIT_Message> p_SPIT_Mess
void SPIT_Client::parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage) { void SPIT_Client::parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage) {
answerWatchdog(); answerWatchdog();
if (!p_SPITMessage) { if (!p_SPITMessage || !p_SPITMessage->getHeader() || !p_SPITMessage->getOPPart()) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message Parameter == nullptr"); ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message incomplete message");
return;
}
if (p_SPITMessage->getHeader() == nullptr) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message no Header");
return;
}
if (p_SPITMessage->getOPPart() == nullptr) {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message no OPPart");
return; return;
} }
switch (p_SPITMessage->getOPFlag()) {
//----- Connection ----- //----- Connection -----
if (p_SPITMessage->getOPFlag() == SPIT_Message::ConnectAnswer::OPFLAG) { case SPIT_Message::ConnectAnswer::OPFLAG:
SPIT_Message::ConnectAnswer *o_ConnectAnswer = (SPIT_Message::ConnectAnswer *)p_SPITMessage->getOPPart(); parseConnectAnswer(p_SPITMessage->getOPPartAs<SPIT_Message::ConnectAnswer>());
parseConnectAnswer(o_ConnectAnswer); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::Disconnect::OPFLAG) { case SPIT_Message::Disconnect::OPFLAG:
SPIT_Message::Disconnect *o_Disconnect = (SPIT_Message::Disconnect *)p_SPITMessage->getOPPart(); parseDisconnect(p_SPITMessage->getOPPartAs<SPIT_Message::Disconnect>());
parseDisconnect(o_Disconnect); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::ReportSPITProject::OPFLAG) { case SPIT_Message::ReportSPITProject::OPFLAG:
SPIT_Message::ReportSPITProject *o_ReportSPITProject = (SPIT_Message::ReportSPITProject *)p_SPITMessage->getOPPart(); parseReportSPITProject(p_SPITMessage->getOPPartAs<SPIT_Message::ReportSPITProject>());
parseReportSPITProject(o_ReportSPITProject); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::Watchdog::OPFLAG) { case SPIT_Message::Watchdog::OPFLAG:
SPIT_Message::Watchdog *o_Watchdog = (SPIT_Message::Watchdog *)p_SPITMessage->getOPPart(); parseWatchdog(p_SPITMessage->getOPPartAs<SPIT_Message::Watchdog>());
parseWatchdog(o_Watchdog); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::WatchdogAnswer::OPFLAG) { case SPIT_Message::WatchdogAnswer::OPFLAG:
SPIT_Message::WatchdogAnswer *o_WatchdogAnswer = (SPIT_Message::WatchdogAnswer *)p_SPITMessage->getOPPart(); parseWatchdogAnswer(p_SPITMessage->getOPPartAs<SPIT_Message::WatchdogAnswer>());
parseWatchdogAnswer(o_WatchdogAnswer); break;
}
//----- SPIT Project ----- //----- SPIT Project -----
else if (p_SPITMessage->getOPFlag() == SPIT_Message::StartProjectTransfer::OPFLAG) { case SPIT_Message::StartProjectTransfer::OPFLAG:
SPIT_Message::StartProjectTransfer *o_StartProjectTransfer = (SPIT_Message::StartProjectTransfer *)p_SPITMessage->getOPPart(); parseStartProjectTransfer(p_SPITMessage->getOPPartAs<SPIT_Message::StartProjectTransfer>());
parseStartProjectTransfer(o_StartProjectTransfer); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::CloseSPITProject::OPFLAG) { case SPIT_Message::CloseSPITProject::OPFLAG:
SPIT_Message::CloseSPITProject *o_CloseSPITProjectr = (SPIT_Message::CloseSPITProject *)p_SPITMessage->getOPPart(); parseCloseSPITProject(p_SPITMessage->getOPPartAs<SPIT_Message::CloseSPITProject>());
parseCloseSPITProject(o_CloseSPITProjectr); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::RequestProjectTransfer::OPFLAG) { case SPIT_Message::RequestProjectTransfer::OPFLAG:
SPIT_Message::RequestProjectTransfer *o_RequestProjectTransfer = (SPIT_Message::RequestProjectTransfer *)p_SPITMessage->getOPPart(); parseRequestProjectTransfer(p_SPITMessage->getOPPartAs<SPIT_Message::RequestProjectTransfer>());
parseRequestProjectTransfer(o_RequestProjectTransfer); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::StartProjectTransfer::OPFLAG) { case SPIT_Message::EndProjectTransfer::OPFLAG:
SPIT_Message::StartProjectTransfer *o_StartProjectTransfer = (SPIT_Message::StartProjectTransfer *)p_SPITMessage->getOPPart(); parseEndProjectTransfer(p_SPITMessage->getOPPartAs<SPIT_Message::EndProjectTransfer>());
parseStartProjectTransfer(o_StartProjectTransfer); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::EndProjectTransfer::OPFLAG) {
SPIT_Message::EndProjectTransfer *o_EndProjectTransfer = (SPIT_Message::EndProjectTransfer *)p_SPITMessage->getOPPart();
parseEndProjectTransfer(o_EndProjectTransfer);
}
//----- SPIT Types ------ //----- SPIT Types ------
else if (p_SPITMessage->getOPFlag() == SPIT_Message::ReportSPITType::OPFLAG) { case SPIT_Message::ReportSPITType::OPFLAG:
SPIT_Message::ReportSPITType *o_ReportSPITType = (SPIT_Message::ReportSPITType *)p_SPITMessage->getOPPart(); parseReportSPITType(p_SPITMessage->getOPPartAs<SPIT_Message::ReportSPITType>());
parseReportSPITType(o_ReportSPITType); break;
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::RemoveSPITType::OPFLAG) { case SPIT_Message::RemoveSPITType::OPFLAG:
SPIT_Message::RemoveSPITType *o_RemoveSPITType = (SPIT_Message::RemoveSPITType *)p_SPITMessage->getOPPart(); parseRemoveSPITType(p_SPITMessage->getOPPartAs<SPIT_Message::RemoveSPITType>());
parseRemoveSPITType(o_RemoveSPITType); //----- SPIT Objects ------
} break;
//----- SPIT Objects ------ case SPIT_Message::ReportSPITObject::OPFLAG:
else if (p_SPITMessage->getOPFlag() == SPIT_Message::ReportSPITObject::OPFLAG) { parseReportSPITObject(p_SPITMessage->getOPPartAs<SPIT_Message::ReportSPITObject>());
SPIT_Message::ReportSPITObject *o_ReportSPITObject = (SPIT_Message::ReportSPITObject *)p_SPITMessage->getOPPart(); break;
parseReportSPITObject(o_ReportSPITObject); case SPIT_Message::RemoveSPITObject::OPFLAG:
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::RemoveSPITObject::OPFLAG) { parseRemoveSPITObject(p_SPITMessage->getOPPartAs<SPIT_Message::RemoveSPITObject>());
SPIT_Message::RemoveSPITObject *o_RemoveSPITObject = (SPIT_Message::RemoveSPITObject *)p_SPITMessage->getOPPart(); break;
parseRemoveSPITObject(o_RemoveSPITObject); //----- Play SPIT Objects ------
} case SPIT_Message::PlaySPITStart::OPFLAG:
//----- Play SPIT Objects ------ parsePlaySPITStart(p_SPITMessage->getOPPartAs<SPIT_Message::PlaySPITStart>());
else if (p_SPITMessage->getOPFlag() == SPIT_Message::PlaySPITStart::OPFLAG) { break;
SPIT_Message::PlaySPITStart *o_PlaySPITStart = (SPIT_Message::PlaySPITStart *)p_SPITMessage->getOPPart(); case SPIT_Message::PlaySPITObject::OPFLAG:
parsePlaySPITStart(o_PlaySPITStart); parsePlaySPITObject(p_SPITMessage->getOPPartAs<SPIT_Message::PlaySPITObject>());
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::PlaySPITObject::OPFLAG) { break;
SPIT_Message::PlaySPITObject *o_PlaySPITObject = (SPIT_Message::PlaySPITObject *)p_SPITMessage->getOPPart(); case SPIT_Message::PlaySPITEnd::OPFLAG:
parsePlaySPITObject(o_PlaySPITObject); parsePlaySPITEnd(p_SPITMessage->getOPPartAs<SPIT_Message::PlaySPITEnd>());
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::PlaySPITEnd::OPFLAG) { break;
SPIT_Message::PlaySPITEnd *o_PlaySPITEnd = (SPIT_Message::PlaySPITEnd *)p_SPITMessage->getOPPart(); case SPIT_Message::ReportPlayStatus::OPFLAG:
parsePlaySPITEnd(o_PlaySPITEnd); parseReportPlayStatus(p_SPITMessage->getOPPartAs<SPIT_Message::ReportPlayStatus>());
} else if (p_SPITMessage->getOPFlag() == SPIT_Message::ReportPlayStatus::OPFLAG) { break;
SPIT_Message::ReportPlayStatus *o_ReportPlayStatus = (SPIT_Message::ReportPlayStatus *)p_SPITMessage->getOPPart(); default:
parseReportPlayStatus(o_ReportPlayStatus);
} else {
ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message: Unknown Message"); ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message: Unknown Message");
} }
} }
@@ -548,21 +526,21 @@ void SPIT_Client::disconnectInternal(Connection p_Cause) {
} }
} }
void SPIT_Client::parseConnectAnswer(SPIT_Message::ConnectAnswer *p_ConnectAnswer) { void SPIT_Client::parseConnectAnswer(SPIT_Message::ConnectAnswer &p_ConnectAnswer) {
Connection intOldConnectionStatus = m_ConnectionStatus; Connection intOldConnectionStatus = m_ConnectionStatus;
if (p_ConnectAnswer->getClientID() != m_ID) if (p_ConnectAnswer.getClientID() != m_ID)
return; return;
m_ServerID = p_ConnectAnswer->getServerID(); m_ServerID = p_ConnectAnswer.getServerID();
m_ServerComputerName = p_ConnectAnswer->getServerComputerName(); m_ServerComputerName = p_ConnectAnswer.getServerComputerName();
m_ServerName = p_ConnectAnswer->getServerName(); m_ServerName = p_ConnectAnswer.getServerName();
m_ServerStepTime = p_ConnectAnswer->getStepTime(); m_ServerStepTime = p_ConnectAnswer.getStepTime();
if (p_ConnectAnswer->getConnected() == false) { if (p_ConnectAnswer.getConnected() == false) {
disconnectInternal(Connection::NoneServer); disconnectInternal(Connection::NoneServer);
} else { } else {
p_ConnectAnswer->getStepTime(); p_ConnectAnswer.getStepTime();
m_ConnectionStatus = Connection::Ok; m_ConnectionStatus = Connection::Ok;
m_DisconnectedByServer = false; m_DisconnectedByServer = false;
ESP_LOGD(TAG, "connection established"); ESP_LOGD(TAG, "connection established");
@@ -580,7 +558,7 @@ void SPIT_Client::parseConnectAnswer(SPIT_Message::ConnectAnswer *p_ConnectAnswe
* The SPIT server was closed * The SPIT server was closed
* @param p_Disconnect * @param p_Disconnect
*/ */
void SPIT_Client::parseDisconnect(SPIT_Message::Disconnect *p_Disconnect) { void SPIT_Client::parseDisconnect(SPIT_Message::Disconnect &p_Disconnect) {
Connection intCauseDisconnect = Connection::NoneServer; Connection intCauseDisconnect = Connection::NoneServer;
/* /*
function<void()> o_Callable = bind(&SPIT_Client::disconnectInternal, this, intCauseDisconnect); function<void()> o_Callable = bind(&SPIT_Client::disconnectInternal, this, intCauseDisconnect);
@@ -597,7 +575,7 @@ void SPIT_Client::parseDisconnect(SPIT_Message::Disconnect *p_Disconnect) {
* This is used to check if the other side is still present. * This is used to check if the other side is still present.
* @param p_Watchdog * @param p_Watchdog
*/ */
void SPIT_Client::parseWatchdog(SPIT_Message::Watchdog *p_Watchdog) { void SPIT_Client::parseWatchdog(SPIT_Message::Watchdog &p_Watchdog) {
// printf("parse Watchdog \n"); // printf("parse Watchdog \n");
SPIT_Message::WatchdogAnswer o_WatchdogAnswer; SPIT_Message::WatchdogAnswer o_WatchdogAnswer;
sendSPITMessage(o_WatchdogAnswer); sendSPITMessage(o_WatchdogAnswer);
@@ -608,7 +586,7 @@ void SPIT_Client::parseWatchdog(SPIT_Message::Watchdog *p_Watchdog) {
* This is used to check if the other side is still present. * This is used to check if the other side is still present.
* @param p_Watchdog * @param p_Watchdog
*/ */
void SPIT_Client::parseWatchdogAnswer(SPIT_Message::WatchdogAnswer *p_WatchdogAnswer) { void SPIT_Client::parseWatchdogAnswer(SPIT_Message::WatchdogAnswer &p_WatchdogAnswer) {
answerWatchdog(); answerWatchdog();
; // is also done by parseSPIT_Message ; // is also done by parseSPIT_Message
} }
@@ -629,13 +607,11 @@ void SPIT_Client::eventWatchdogLost() {
} }
//----- SPIT Project ------ //----- SPIT Project ------
void SPIT_Client::parseReportSPITProject(SPIT_Message::ReportSPITProject *p_ReportSPITProject) { void SPIT_Client::parseReportSPITProject(SPIT_Message::ReportSPITProject &p_ReportSPITProject) {
// printf("parse ReportSPITProject \n"); // printf("parse ReportSPITProject \n");
if (p_ReportSPITProject == nullptr) m_ServerProjectID = p_ReportSPITProject.getProjectID();
return; m_ServerProjectName = p_ReportSPITProject.getProjectName();
m_ServerProjectID = p_ReportSPITProject->getProjectID(); m_ServerFramesPerSecond = p_ReportSPITProject.getFramesPerSecond();
m_ServerProjectName = p_ReportSPITProject->getProjectName();
m_ServerFramesPerSecond = p_ReportSPITProject->getFramesPerSecond();
mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, m_ServerProjectID); mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, m_ServerProjectID);
// Set all SPITTypes and SPITObjects confirmed = false // Set all SPITTypes and SPITObjects confirmed = false
@@ -656,12 +632,10 @@ void SPIT_Client::parseReportSPITProject(SPIT_Message::ReportSPITProject *p_Repo
ESP_LOGD(TAG, "SPIT_Client::parseReportSPITProject could not send Client's ReportSPITProject"); ESP_LOGD(TAG, "SPIT_Client::parseReportSPITProject could not send Client's ReportSPITProject");
} }
} }
void SPIT_Client::parseCloseSPITProject(SPIT_Message::CloseSPITProject *p_CloseSPITProject) { void SPIT_Client::parseCloseSPITProject(SPIT_Message::CloseSPITProject &p_CloseSPITProject) {
// printf("parse CloseSPITProject \n"); // printf("parse CloseSPITProject \n");
if (p_CloseSPITProject == nullptr)
return;
string stringProjectID; string stringProjectID;
mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject->getProjectID()); mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject.getProjectID());
SPITPlayer::clearPlayers(); SPITPlayer::clearPlayers();
} }
@@ -669,7 +643,7 @@ string SPIT_Client::getServerProjectID() { return m_ServerProjectID; }
string SPIT_Client::getServerProjectName() { return m_ServerProjectName; } string SPIT_Client::getServerProjectName() { return m_ServerProjectName; }
int SPIT_Client::getServerFramesPerSecond() { return m_ServerFramesPerSecond; } int SPIT_Client::getServerFramesPerSecond() { return m_ServerFramesPerSecond; }
void SPIT_Client::parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer *p_RequestProjectTransfer) { void SPIT_Client::parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer &p_RequestProjectTransfer) {
// printf("parse RequestProjectTransfer \n"); // printf("parse RequestProjectTransfer \n");
// StartProjectTransfer // StartProjectTransfer
SPIT_Message::StartProjectTransfer sMStartProjectTransfer; SPIT_Message::StartProjectTransfer sMStartProjectTransfer;
@@ -828,10 +802,10 @@ void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
// //Send act // //Send act
} }
void SPIT_Client::parseStartProjectTransfer(SPIT_Message::StartProjectTransfer *p_StartProjectTransfer) { void SPIT_Client::parseStartProjectTransfer(SPIT_Message::StartProjectTransfer &p_StartProjectTransfer) {
mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, m_ServerProjectID); mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, m_ServerProjectID);
} }
void SPIT_Client::parseEndProjectTransfer(SPIT_Message::EndProjectTransfer *p_EndProjectTransfer) { void SPIT_Client::parseEndProjectTransfer(SPIT_Message::EndProjectTransfer &p_EndProjectTransfer) {
SPITObject::clearUnconfirmedSPITObjects(mSpitObjects); SPITObject::clearUnconfirmedSPITObjects(mSpitObjects);
mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, m_ServerProjectID); mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, m_ServerProjectID);
@@ -844,36 +818,34 @@ void SPIT_Client::parseEndProjectTransfer(SPIT_Message::EndProjectTransfer *p_En
} }
//----- SPIT Types ------ //----- SPIT Types ------
void SPIT_Client::parseReportSPITType(SPIT_Message::ReportSPITType *p_ReportSPITType) { void SPIT_Client::parseReportSPITType(SPIT_Message::ReportSPITType &p_ReportSPITType) {
// printf("parse ReportSPITType ID %s Name %s \n",p_ReportSPITType->getID(), p_ReportSPITType->getName()); // printf("parse ReportSPITType ID %s Name %s \n",p_ReportSPITType.getID(), p_ReportSPITType.getName());
if (p_ReportSPITType == nullptr)
return;
SPITType *ptrSPITType; SPITType *ptrSPITType;
bool boolNew = false; bool boolNew = false;
bool boolChanged = false; bool boolChanged = false;
{ {
if (p_ReportSPITType->getServerRemote() == false) { if (p_ReportSPITType.getServerRemote() == false) {
ptrSPITType = mSpitTypes.getEntry(p_ReportSPITType->getID()); ptrSPITType = mSpitTypes.getEntry(p_ReportSPITType.getID());
if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
// The user's app my veto the SPITType // The user's app my veto the SPITType
if (mCallbacks.onCheckSpitTypeVeto(p_ReportSPITType) == false) { if (mCallbacks.onCheckSpitTypeVeto(&p_ReportSPITType) == false) {
return; return;
} }
auto spitType = make_unique<SPITType>(p_ReportSPITType->getID()); auto spitType = make_unique<SPITType>(p_ReportSPITType.getID());
ptrSPITType = spitType.get(); ptrSPITType = spitType.get();
mSpitTypes.addEntry(move(spitType)); mSpitTypes.addEntry(move(spitType));
boolNew = true; boolNew = true;
} }
} else { } else {
ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITType->getID()); ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITType.getID());
if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
auto spitType = make_unique<SPITType>(p_ReportSPITType->getID()); auto spitType = make_unique<SPITType>(p_ReportSPITType.getID());
ptrSPITType = spitType.get(); ptrSPITType = spitType.get();
mRemoteSpitTypes.addEntry(move(spitType)); mRemoteSpitTypes.addEntry(move(spitType));
boolNew = true; boolNew = true;
} }
} }
if (!ptrSPITType->setMessageOP(*p_ReportSPITType)) { if (!ptrSPITType->setMessageOP(p_ReportSPITType)) {
// SPITType is not changable -> send back to the server // SPITType is not changable -> send back to the server
sendSPITTypeInternal(*ptrSPITType); sendSPITTypeInternal(*ptrSPITType);
return; return;
@@ -890,13 +862,10 @@ void SPIT_Client::parseReportSPITType(SPIT_Message::ReportSPITType *p_ReportSPIT
} }
} }
} }
void SPIT_Client::parseRemoveSPITType(SPIT_Message::RemoveSPITType *p_RemoveSPITType) { void SPIT_Client::parseRemoveSPITType(SPIT_Message::RemoveSPITType &p_RemoveSPITType) {
// printf("parse RemoveSPITType %s\n", p_RemoveSPITType->getID()); // printf("parse RemoveSPITType %s\n", p_RemoveSPITType.getID());
if (!p_RemoveSPITType) {
return;
}
bool boolRemote = false; bool boolRemote = false;
string stringSPITTypeID = p_RemoveSPITType->getID(); string stringSPITTypeID = p_RemoveSPITType.getID();
SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(stringSPITTypeID); SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(stringSPITTypeID);
if (!ptrSPITType) { if (!ptrSPITType) {
@@ -1018,21 +987,19 @@ SPITType *SPIT_Client::createSPITType(string p_ID, string p_GroupName, string p_
} }
//----- SPIT Objects ------ //----- SPIT Objects ------
void SPIT_Client::parseReportSPITObject(SPIT_Message::ReportSPITObject *p_ReportSPITObject) { void SPIT_Client::parseReportSPITObject(SPIT_Message::ReportSPITObject &p_ReportSPITObject) {
ESP_LOGD(TAG, "parse ReportSPITObject %s\n", p_ReportSPITObject->getID().c_str()); ESP_LOGD(TAG, "parse ReportSPITObject %s\n", p_ReportSPITObject.getID().c_str());
if (p_ReportSPITObject == nullptr)
return;
SPITObject *ptrSPITObject; SPITObject *ptrSPITObject;
SPITType *ptrSPITType; SPITType *ptrSPITType;
bool boolNew = false; bool boolNew = false;
bool boolRemote = false; bool boolRemote = false;
bool boolChanged = false; bool boolChanged = false;
{ {
ESP_LOGD(TAG, "parseReportSPITObject %s / %s", p_ReportSPITObject->getID().c_str(), p_ReportSPITObject->getName().c_str()); ESP_LOGD(TAG, "parseReportSPITObject %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
if (p_ReportSPITObject->getServerRemote() == false) { if (p_ReportSPITObject.getServerRemote() == false) {
boolRemote = false; boolRemote = false;
ptrSPITObject = mSpitObjects.getEntry(p_ReportSPITObject->getID()); ptrSPITObject = mSpitObjects.getEntry(p_ReportSPITObject.getID());
ptrSPITType = mSpitTypes.getEntry(p_ReportSPITObject->getSPITTypeID()); ptrSPITType = mSpitTypes.getEntry(p_ReportSPITObject.getSPITTypeID());
if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
// No associated SPITType found // No associated SPITType found
@@ -1045,40 +1012,40 @@ void SPIT_Client::parseReportSPITObject(SPIT_Message::ReportSPITObject *p_Report
} }
if (ptrSPITObject == nullptr) { if (ptrSPITObject == nullptr) {
// The user's app my veto the SPITType // The user's app my veto the SPITType
if (mCallbacks.onCheckSpitObjectVeto(p_ReportSPITObject) == false) { if (mCallbacks.onCheckSpitObjectVeto(&p_ReportSPITObject) == false) {
ESP_LOGD(TAG, "ObjectVeto %s / %s", p_ReportSPITObject->getID().c_str(), p_ReportSPITObject->getName().c_str()); ESP_LOGD(TAG, "ObjectVeto %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
return; return;
} }
auto spitObj = make_unique<SPITObject>(p_ReportSPITObject->getID()); auto spitObj = make_unique<SPITObject>(p_ReportSPITObject.getID());
ptrSPITObject = spitObj.get(); ptrSPITObject = spitObj.get();
mSpitObjects.addEntry(move(spitObj)); mSpitObjects.addEntry(move(spitObj));
boolNew = true; boolNew = true;
} else { } else {
// The user's app my veto the SPITType // The user's app my veto the SPITType
if (mCallbacks.onCheckSpitObjectVeto(p_ReportSPITObject) == false) { if (mCallbacks.onCheckSpitObjectVeto(&p_ReportSPITObject) == false) {
// SpitObject exists and User APp denied the SPITObject -> remove the SPITObject without sending a message // SpitObject exists and User APp denied the SPITObject -> remove the SPITObject without sending a message
mSpitObjects.removeEntry(*ptrSPITObject); mSpitObjects.removeEntry(*ptrSPITObject);
ESP_LOGD(TAG, "TypeVeto %s / %s", p_ReportSPITObject->getID().c_str(), p_ReportSPITObject->getName().c_str()); ESP_LOGD(TAG, "TypeVeto %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
return; return;
} }
} }
} else { } else {
boolRemote = true; boolRemote = true;
ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportSPITObject->getID()); ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportSPITObject.getID());
ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITObject->getSPITTypeID()); ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITObject.getSPITTypeID());
if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
// No associated SPITType found // No associated SPITType found
return; return;
} }
if (ptrSPITObject == nullptr) { if (ptrSPITObject == nullptr) {
auto spitObj = make_unique<SPITObject>(p_ReportSPITObject->getID()); auto spitObj = make_unique<SPITObject>(p_ReportSPITObject.getID());
ptrSPITObject = spitObj.get(); ptrSPITObject = spitObj.get();
mRemoteSpitObjects.addEntry(move(spitObj)); mRemoteSpitObjects.addEntry(move(spitObj));
boolNew = true; boolNew = true;
} }
} }
if (!ptrSPITObject->setMessageOP(p_ReportSPITObject)) { if (!ptrSPITObject->setMessageOP(&p_ReportSPITObject)) {
ESP_LOGE(TAG, "Change not allowed"); ESP_LOGE(TAG, "Change not allowed");
// setMessageOP error - the SPITObject can't be changed, it may be fixed and crated by this client // setMessageOP error - the SPITObject can't be changed, it may be fixed and crated by this client
sendSPITObjectInternal(ptrSPITObject); sendSPITObjectInternal(ptrSPITObject);
@@ -1099,13 +1066,9 @@ void SPIT_Client::parseReportSPITObject(SPIT_Message::ReportSPITObject *p_Report
} }
} }
} }
void SPIT_Client::parseRemoveSPITObject(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject) { void SPIT_Client::parseRemoveSPITObject(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject) {
// printf("parse RemoveSPITObject %s\n", p_RemoveSPITObject->getID()); // printf("parse RemoveSPITObject %s\n", p_RemoveSPITObject.getID());
if (!p_RemoveSPITObject) { SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_RemoveSPITObject.getID());
return;
}
SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_RemoveSPITObject->getID());
if (ptrSPITObject != nullptr) { if (ptrSPITObject != nullptr) {
SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->getSPITTypeID()); SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
if (ptrSPITType != nullptr) { if (ptrSPITType != nullptr) {
@@ -1114,7 +1077,7 @@ void SPIT_Client::parseRemoveSPITObject(SPIT_Message::RemoveSPITObject *p_Remove
mRemoteSpitObjects.removeEntry(*ptrSPITObject); mRemoteSpitObjects.removeEntry(*ptrSPITObject);
} else { } else {
// call removeSPITObject, this will notify the server that the object is removed // call removeSPITObject, this will notify the server that the object is removed
removeSPITObject(p_RemoveSPITObject->getID()); removeSPITObject(p_RemoveSPITObject.getID());
} }
} }
@@ -1203,21 +1166,21 @@ int SPIT_Client::removeSPITObject(string p_SPITObjectID) {
//----- Play SPIT Objects ------ //----- Play SPIT Objects ------
void SPIT_Client::parsePlaySPITStart(SPIT_Message::PlaySPITStart *p_PlaySPITStart) { void SPIT_Client::parsePlaySPITStart(SPIT_Message::PlaySPITStart &p_PlaySPITStart) {
ESP_LOGD(TAG, "parse PlaySPITStart ID: %s Name: %s Running: %d", p_PlaySPITStart->getPlayerID().c_str(), p_PlaySPITStart->getPlayerName().c_str(), (int)p_PlaySPITStart->getPlayerIsRunning()); ESP_LOGD(TAG, "parse PlaySPITStart ID: %s Name: %s Running: %d", p_PlaySPITStart.getPlayerID().c_str(), p_PlaySPITStart.getPlayerName().c_str(), (int)p_PlaySPITStart.getPlayerIsRunning());
SPITPlayer &spitPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITStart->getPlayerID()); SPITPlayer &spitPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITStart.getPlayerID());
spitPlayer.setIsRunning(p_PlaySPITStart->getPlayerIsRunning()); spitPlayer.setIsRunning(p_PlaySPITStart.getPlayerIsRunning());
spitPlayer.setName(p_PlaySPITStart->getPlayerName()); spitPlayer.setName(p_PlaySPITStart.getPlayerName());
spitPlayer.setType(p_PlaySPITStart->getPlayerType()); spitPlayer.setType(p_PlaySPITStart.getPlayerType());
spitPlayer.setTime(p_PlaySPITStart->getTime()); spitPlayer.setTime(p_PlaySPITStart.getTime());
spitPlayer.startPlaySequence(); spitPlayer.startPlaySequence();
mCallbacks.onPlay(spitPlayer.getID(), spitPlayer.getName(), spitPlayer.getType(), spitPlayer.getIsRunning(), spitPlayer.getTime()); mCallbacks.onPlay(spitPlayer.getID(), spitPlayer.getName(), spitPlayer.getType(), spitPlayer.getIsRunning(), spitPlayer.getTime());
} }
void SPIT_Client::parsePlaySPITObject(SPIT_Message::PlaySPITObject *p_PlaySPITObject) { void SPIT_Client::parsePlaySPITObject(SPIT_Message::PlaySPITObject &p_PlaySPITObject) {
SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITObject->getPlayerID()); SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITObject.getPlayerID());
SPITObject *ptrSPITObject = mSpitObjects.getEntry(p_PlaySPITObject->getSPITObjectID()); SPITObject *ptrSPITObject = mSpitObjects.getEntry(p_PlaySPITObject.getSPITObjectID());
if (ptrSPITObject == nullptr) { if (ptrSPITObject == nullptr) {
return; return;
@@ -1227,11 +1190,11 @@ void SPIT_Client::parsePlaySPITObject(SPIT_Message::PlaySPITObject *p_PlaySPITOb
return; return;
} }
ptrPlaySPITType->setPlayerIsRunning(ptrSPITPlayer.getIsRunning()); ptrPlaySPITType->setPlayerIsRunning(ptrSPITPlayer.getIsRunning());
ptrPlaySPITType->addValue(((double)p_PlaySPITObject->getValue() / 1000000), ((double)ptrSPITObject->getValueFactor() / 1000000)); ptrPlaySPITType->addValue(((double)p_PlaySPITObject.getValue() / 1000000), ((double)ptrSPITObject->getValueFactor() / 1000000));
} }
void SPIT_Client::parsePlaySPITEnd(SPIT_Message::PlaySPITEnd *p_PlaySPITEnd) { void SPIT_Client::parsePlaySPITEnd(SPIT_Message::PlaySPITEnd &p_PlaySPITEnd) {
SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITEnd->getPlayerID()); SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITEnd.getPlayerID());
// unordered_map<string, SPITPlayer::PlaySPITType*>* ptrPlayObjects; // unordered_map<string, SPITPlayer::PlaySPITType*>* ptrPlayObjects;
// bool boolStarted; // bool boolStarted;
// bool boolStopped; // bool boolStopped;
@@ -1280,12 +1243,12 @@ void SPIT_Client::parsePlaySPITEnd(SPIT_Message::PlaySPITEnd *p_PlaySPITEnd) {
ptrSPITPlayer.endPlaySequence(); ptrSPITPlayer.endPlaySequence();
} }
void SPIT_Client::parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_ReportPlayStatus) { void SPIT_Client::parseReportPlayStatus(SPIT_Message::ReportPlayStatus &p_ReportPlayStatus) {
SPITType *ptrSPITType = NULL; SPITType *ptrSPITType = NULL;
SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportPlayStatus->getID()); SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportPlayStatus.getID());
if (ptrSPITObject == nullptr) { if (ptrSPITObject == nullptr) {
ptrSPITObject = mSpitObjects.getEntry(p_ReportPlayStatus->getID()); ptrSPITObject = mSpitObjects.getEntry(p_ReportPlayStatus.getID());
if (ptrSPITObject == nullptr) { if (ptrSPITObject == nullptr) {
return; return;
} }
@@ -1299,7 +1262,7 @@ void SPIT_Client::parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_Report
if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
return; return;
} }
mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, p_ReportPlayStatus->getFrameInsideObject(), p_ReportPlayStatus->getValue()); mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, p_ReportPlayStatus.getFrameInsideObject(), p_ReportPlayStatus.getValue());
} }
//--------- Remote ---------- //--------- Remote ----------
@@ -1319,26 +1282,25 @@ void SPIT_Client::parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_Report
* VALUEFLAG_DECREASE (0x01) The server decreases his existing value by p_Valueppm * VALUEFLAG_DECREASE (0x01) The server decreases his existing value by p_Valueppm
*/ */
void SPIT_Client::sendRemoteObject(string p_SPITObjectID, int p_Valueppm, char p_ValueFlag) { void SPIT_Client::sendRemoteObject(string p_SPITObjectID, int p_Valueppm, char p_ValueFlag) {
SPITObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID); SPITObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID);
if (ptrRemoteSPITObject == nullptr) if (ptrRemoteSPITObject == nullptr)
return; return;
SPIT_Message::PlaySPITStart playSPITStart(m_ID, m_ProjName, PLAYERTYPE_DISCRETE); SPIT_Message::PlaySPITStart playSPITStart(m_ID, m_ProjName, PLAYERTYPE_DISCRETE);
playSPITStart.setPlayerIsRunning(false); playSPITStart.setPlayerIsRunning(false);
playSPITStart.setTime(0); playSPITStart.setTime(0);
sendSPITMessage(playSPITStart); sendSPITMessage(playSPITStart);
SPIT_Message::PlaySPITObject playSPITObject; SPIT_Message::PlaySPITObject playSPITObject;
playSPITObject.setID(ptrRemoteSPITObject->getID()); playSPITObject.setID(ptrRemoteSPITObject->getID());
playSPITObject.setPlayPrePosition(false); playSPITObject.setPlayPrePosition(false);
playSPITObject.setPlayerID(m_ID); playSPITObject.setPlayerID(m_ID);
playSPITObject.setValue(p_Valueppm); playSPITObject.setValue(p_Valueppm);
playSPITObject.setValueFlag(p_ValueFlag); playSPITObject.setValueFlag(p_ValueFlag);
sendSPITMessage(playSPITObject); sendSPITMessage(playSPITObject);
SPIT_Message::PlaySPITEnd playSPITEnd(m_ID); SPIT_Message::PlaySPITEnd playSPITEnd(m_ID);
sendSPITMessage(playSPITEnd); sendSPITMessage(playSPITEnd);
} }
fos::Semaphore SPIT_Client::sStartSad; fos::Semaphore SPIT_Client::sStartSad;