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

temp1

Browse Source
This commit is contained in:
Gustice
2025-11-15 13:50:18 +01:00
parent 331258692b
commit 7edc57784c
6 changed files with 470 additions and 1004 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/spit_client.hpp
+5 -53
View File
@@ -11,7 +11,6 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <functional> #include <functional>
#include "syslog.hpp"
using namespace std; using namespace std;
@@ -80,11 +79,6 @@ class SClient : ISadClient {
string mServerComputerName{}; string mServerComputerName{};
int mServerStepTime{-1}; int mServerStepTime{-1};
//--- Server Project ---
string mServerProjectID;
string mServerProjectName;
int mServerFramesPerSecond;
public: public:
/** The ID of the client.<br>Every client instance should set an unique id*/ /** The ID of the client.<br>Every client instance should set an unique id*/
string getID() { return mID; } string getID() { return mID; }
@@ -129,7 +123,7 @@ class SClient : ISadClient {
// Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected // Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected
bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID
public: public:
int sendSPITMessage(Message::OPPart & spitMessageOPPart); int sendMessage(Message::OPPart & spitMessageOPPart);
//--------------- ServerAutoDetection SAD --------------- //--------------- ServerAutoDetection SAD ---------------
public: public:
@@ -179,11 +173,7 @@ class SClient : ISadClient {
/** Used internally. When the connection to the SPITServer is lost an eventConnectionStatus will occur*/ /** Used internally. When the connection to the SPITServer is lost an eventConnectionStatus will occur*/
void eventWatchdogLost(); void eventWatchdogLost();
//--------------- SPIT Project --------------- //--------------- SPIT Project ---------------
private:
void parseReportProject(Message::ReportProject &message);
void parseCloseProject(Message::CloseProject &message);
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*/
string getServerProjectID(); string getServerProjectID();
/** Returns the SPITServer's project name*/ /** Returns the SPITServer's project name*/
@@ -191,11 +181,6 @@ class SClient : ISadClient {
/** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/ /** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/
int getServerFramesPerSecond(); int getServerFramesPerSecond();
private:
void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
void parseStartProjectTransfer(Message::StartProjectTransfer &message);
void parseEndProjectTransfer(Message::EndProjectTransfer &message);
public: public:
static void sendProject(SClient *p_PtrSClient); static void sendProject(SClient *p_PtrSClient);
@@ -231,31 +216,16 @@ class SClient : ISadClient {
private: private:
// receive SPIT-Types // receive SPIT-Types
void parseReportType(Message::ReportType &message); void parseReportType(Message::ReportType &message);
void parseRemoveSPITType(Message::RemoveType &message); int sendTypeInternal(SType &spitType);
int sendSPITTypeInternal(SType &spitType);
public: public:
/** bool changeType(SType *spitType) { return mProcessor.changeType(spitType); }
* If a client wants to change a SPITType, he should send it to the server.<br> int removeType(string spitypeID) { return mProcessor.removeType(spitypeID); }
* If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br>
* @param spitypeID the id of the SPITType to remove.
* @return 0 = is sended, -1 = is not sended
*/
bool changeSPITType(SType *spitType);
/**
* If a client wants to remove a SPITType, he should send it to the server.<br>
* If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br>
* @param spitypeID the id of the SPITType to remove.
* @return 0 = is sended, -1 = is not sended
*/
int removeSPITType(string spitypeID);
public: public:
//--------------- SPIT Objects --------------- //--------------- SPIT Objects ---------------
private: private:
void parseReportSPITObject(Message::ReportObject &message); int sendObjectInternal(SObject *sObject);
void parseRemoveSPITObject(Message::RemoveObject &message);
int sendSPITObjectInternal(SObject *ptrObject);
public: public:
/** /**
@@ -265,21 +235,6 @@ class SClient : ISadClient {
* @return 0 = sended, -1 = not sended * @return 0 = sended, -1 = not sended
*/ */
bool changeSPITObject(SObject *spitObject); bool changeSPITObject(SObject *spitObject);
/**
* When the client removes a SPITObject (normally the client should not do this), then he should send it to the SPITServer.<br>
* The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
* @param objectID the id of the SPITObject to remove.
* @return 0 = sended, -1 = not sended
*/
int removeSPITObject(string objectID);
public:
//--------------- Play SPIT Objects ---------------
private:
void parsePlaySPITStart(Message::PlayStart &message);
void parsePlaySPITObject(Message::PlayObject &message);
void parsePlaySPITEnd(Message::PlayEnd &message);
void parseReportPlayStatus(Message::ReportPlayStatus &message);
public: public:
//--------- Remote ---------- //--------- Remote ----------
@@ -295,9 +250,6 @@ class SClient : ISadClient {
void answerWatchdog() { void answerWatchdog() {
sAnswered = true; sAnswered = true;
} }
SpitRepo<SObject> mSpitObjects;
SpitRepo<SObject> mRemoteSpitObjects;
}; };
} }
components/spit/include/spit_processor.hpp
+57 -67
View File
@@ -57,7 +57,10 @@ class SProcessor {
}; };
struct InternalCallbacks { struct InternalCallbacks {
function<int(SType &sType)> sendSpitTypeInternal; function<void(int ms)> delay;
function<int(Message::OPPart &msg)> sendMessage;
function<int(SType &sType)> sendTypeInternal;
function<int(SObject *sObject)> sendObjectInternal;
}; };
// //------ PlayerType ------ // //------ PlayerType ------
@@ -99,20 +102,20 @@ class SProcessor {
// string mClientProjectName; // string mClientProjectName;
// uint8_t mMessageNumberSend{1}; uint8_t mMessageNumberSend{1};
// int mMessageNumberReceived{-1}; // set to -1 because the first received message will set the number (1..255) int mMessageNumberReceived{-1}; // set to -1 because the first received message will set the number (1..255)
// vector<unique_ptr<Message>> mOvertakingMessages; vector<unique_ptr<Message>> mOvertakingMessages;
// // Server's info filled by parseConnectAnswer // // Server's info filled by parseConnectAnswer
// string mServerID{}; string mServerID{};
// string mServerName{}; // string mServerName{};
// string mServerComputerName{}; // string mServerComputerName{};
// int mServerStepTime{-1}; // int mServerStepTime{-1};
// //--- Server Project --- // //--- Server Project ---
// string mServerProjectID; string mServerProjectID;
// string mServerProjectName; string mServerProjectName;
// int mServerFramesPerSecond; int mServerFramesPerSecond;
// public: // public:
// /** The ID of the client.<br>Every client instance should set an unique id*/ // /** The ID of the client.<br>Every client instance should set an unique id*/
@@ -153,9 +156,9 @@ class SProcessor {
// private: // private:
// // Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected // // Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected
// bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID // bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID
// public: public:
// std::vector<char> createMessage(Message::OPPart & spitMessageOPPart); std::vector<char> createMessage(Message::OPPart & spitMessageOPPart);
// void checkParseMessageData(vector<char> data); void checkParseMessageData(vector<char> data);
// //--------------- ServerAutoDetection SAD --------------- // //--------------- ServerAutoDetection SAD ---------------
// public: // public:
@@ -191,7 +194,7 @@ class SProcessor {
// private: // private:
// void disconnectInternal(Connection cause); // void disconnectInternal(Connection cause);
// void resetMessageNumberReceived(); // void resetMessageNumberReceived();
// void parseMessage(Message& message); void parseMessage(Message& message);
// void addOvertakingMessage(unique_ptr<Message> message); // void addOvertakingMessage(unique_ptr<Message> message);
// void parseConnectAnswer(Message::ConnectAnswer &message); // void parseConnectAnswer(Message::ConnectAnswer &message);
// void parseDisconnect(Message::Disconnect &message); // void parseDisconnect(Message::Disconnect &message);
@@ -205,24 +208,23 @@ class SProcessor {
// void eventWatchdogLost(); // void eventWatchdogLost();
// //--------------- SPIT Project --------------- // //--------------- SPIT Project ---------------
// private: // private:
// void parseReportProject(Message::ReportProject &message); public: // tood remove
// void parseCloseProject(Message::CloseProject &message); void parseReportProject(Message::ReportProject &message);
void parseCloseProject(Message::CloseProject &message);
// 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*/
// string getServerProjectID(); string getServerProjectID();
// /** Returns the SPITServer's project name*/ /** Returns the SPITServer's project name*/
// string getServerProjectName(); string getServerProjectName();
// /** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/ /** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/
// int getServerFramesPerSecond(); int getServerFramesPerSecond();
// private: // private:
// void parseRequestProjectTransfer(Message::RequestProjectTransfer &message); public: // todo remove
// void parseStartProjectTransfer(Message::StartProjectTransfer &message); void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
// void parseEndProjectTransfer(Message::EndProjectTransfer &message); void parseStartProjectTransfer(Message::StartProjectTransfer &message);
void parseEndProjectTransfer(Message::EndProjectTransfer &message);
// public:
// // static void sendProject(SClient *p_PtrSProcessor);
// // --------------- SPIT Types --------------- // // --------------- SPIT Types ---------------
// public: // public:
@@ -255,55 +257,43 @@ class SProcessor {
private: private:
public: // @todo delete public: // @todo delete
void parseReportType(Message::ReportType &message); void parseReportType(Message::ReportType &message);
// void parseRemoveSPITType(Message::RemoveType &message); void parseRemoveType(Message::RemoveType &message);
// int sendSPITTypeInternal(SType &sType);
// public: public:
// /** /**
// * If a client wants to change a SPITType, he should send it to the server.<br> * If a client wants to change a SPITType, he should send it to the server.<br>
// * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br> * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br>
// * @param spitypeID the id of the SPITType to remove. * @param spitypeID the id of the SPITType to remove.
// * @return 0 = is sended, -1 = is not sended * @return 0 = is sended, -1 = is not sended
// */ */
// bool changeSPITType(SType *spitType); bool changeType(SType *spitType);
// /** /**
// * If a client wants to remove a SPITType, he should send it to the server.<br> * If a client wants to remove a SPITType, he should send it to the server.<br>
// * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br> * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br>
// * @param spitypeID the id of the SPITType to remove. * @param spitypeID the id of the SPITType to remove.
// * @return 0 = is sended, -1 = is not sended * @return 0 = is sended, -1 = is not sended
// */ */
// int removeSPITType(string spitypeID); int removeType(string spitypeID);
// public: // public:
// //--------------- SPIT Objects --------------- // //--------------- SPIT Objects ---------------
// private: // private:
// void parseReportSPITObject(Message::ReportObject &message); public:
// void parseRemoveSPITObject(Message::RemoveObject &message); void parseReportObject(Message::ReportObject &message);
void parseRemoveObject(Message::RemoveObject &message);
// int sendSPITObjectInternal(SObject *ptrObject); // int sendSPITObjectInternal(SObject *ptrObject);
// public: // public:
// /** int removeObject(string objectID);
// * When the client changes a SPITObject (normally the client should not do this), then it should send the changes to the SPITServer.<br>
// * The SPITServer may discard the changes and an eventSPITObject occurs.<br>
// * @param spitObject the pointer to the changed SPITObject.
// * @return 0 = sended, -1 = not sended
// */
// bool changeSPITObject(SObject *spitObject);
// /**
// * When the client removes a SPITObject (normally the client should not do this), then he should send it to the SPITServer.<br>
// * The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
// * @param objectID the id of the SPITObject to remove.
// * @return 0 = sended, -1 = not sended
// */
// int removeSPITObject(string objectID);
// public: // public:
// //--------------- Play SPIT Objects --------------- // //--------------- Play SPIT Objects ---------------
// private: // private:
// void parsePlaySPITStart(Message::PlayStart &message); public:
// void parsePlaySPITObject(Message::PlayObject &message); void parsePlayStart(Message::PlayStart &message);
// void parsePlaySPITEnd(Message::PlayEnd &message); void parsePlayObject(Message::PlayObject &message);
// void parseReportPlayStatus(Message::ReportPlayStatus &message); void parsePlayEnd(Message::PlayEnd &message);
void parseReportPlayStatus(Message::ReportPlayStatus &message);
// public: // public:
// //--------- Remote ---------- // //--------- Remote ----------
@@ -316,9 +306,9 @@ public: // @todo delete
// sAnswered = true; // sAnswered = true;
// } // }
// SpitRepo<SObject> mSpitObjects; public: // @todo remove
// SpitRepo<SObject> mRemoteSpitObjects; SpitRepo<SObject> mSpitObjects;
public: // @todo remove SpitRepo<SObject> mRemoteSpitObjects;
SpitRepo<SType> mSpitTypes; SpitRepo<SType> mSpitTypes;
SpitRepo<SType> mRemoteSpitTypes; SpitRepo<SType> mRemoteSpitTypes;
}; };
components/spit/src/spit_client.cpp
+49 -463
View File
@@ -20,7 +20,10 @@ SClient::SClient(string name, string projName, ISocket &socket, Callbacks calls)
mProjName(projName), mProjName(projName),
mProcessor(name, projName, getClientHostName(), createGUID(), calls, mProcessor(name, projName, getClientHostName(), createGUID(), calls,
{ {
.sendSpitTypeInternal = [&](SType &sType) { return sendSPITTypeInternal(sType);} .delay = [&](int ms){ return fos::Task::delayMs(ms); },
.sendMessage = [&](Message::OPPart &msg){ return sendMessage(msg); },
.sendTypeInternal = [&](SType &sType) { return sendTypeInternal(sType);},
.sendObjectInternal = [&](SObject *sObject) { return sendObjectInternal(sObject);}
} }
), ),
mSocket(socket) { mSocket(socket) {
@@ -37,7 +40,7 @@ void SClient::clientProjectClose() {
if (mConnectionStatus == Connection::Ok) { if (mConnectionStatus == Connection::Ok) {
ESP_LOGI(TAG, " ... tidy up ressources"); ESP_LOGI(TAG, " ... tidy up ressources");
Message::CloseProject closeSPITProject(mProjName); Message::CloseProject closeSPITProject(mProjName);
if (sendSPITMessage(closeSPITProject) < 0) { if (sendMessage(closeSPITProject) < 0) {
ESP_LOGD(TAG, "Client could not send Client's ReportProject"); ESP_LOGD(TAG, "Client could not send Client's ReportProject");
} }
} }
@@ -46,19 +49,19 @@ void SClient::clientProjectClose() {
void SClient::clientProjectLoaded() { void SClient::clientProjectLoaded() {
// set confirmed = false for all SPITTypes and SPITObjects // set confirmed = false for all SPITTypes and SPITObjects
SType::setConfirmedFalse(mProcessor.mSpitTypes); SType::setConfirmedFalse(mProcessor.mSpitTypes);
SObject::setConfirmedFalse(mSpitObjects); SObject::setConfirmedFalse(mProcessor.mSpitObjects);
if (mConnectionStatus == Connection::Ok) { if (mConnectionStatus == Connection::Ok) {
// send ReportProject to the server // send ReportProject to the server
Message::ReportProject reportSPITProject(mProjName, mProjName); Message::ReportProject reportSPITProject(mProjName, mProjName);
reportSPITProject.setFramesPerSecond(0); reportSPITProject.setFramesPerSecond(0);
if (sendSPITMessage(reportSPITProject) < 0) { if (sendMessage(reportSPITProject) < 0) {
ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send Client's ReportProject"); ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send Client's ReportProject");
} }
// send RequestProjectTransfer // send RequestProjectTransfer
Message::RequestProjectTransfer sMRequestProjectTransfer; Message::RequestProjectTransfer sMRequestProjectTransfer;
if (sendSPITMessage(sMRequestProjectTransfer) < 0) { if (sendMessage(sMRequestProjectTransfer) < 0) {
ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send RequestProjectTransfer"); ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send RequestProjectTransfer");
} }
} }
@@ -77,11 +80,11 @@ void SClient::setActionSPITType(string typeId, bool actionAssigned) {
if (spitType == nullptr) if (spitType == nullptr)
return; return;
if (spitType->ActionAssigned.set(actionAssigned)) { if (spitType->ActionAssigned.set(actionAssigned)) {
sendSPITTypeInternal(*spitType); sendTypeInternal(*spitType);
for (auto& [key, value] : mSpitObjects.getRepo()) { for (auto& [key, value] : mProcessor.mSpitObjects.getRepo()) {
if (value->SPITTypeID.get() == spitType->getID()) { if (value->SPITTypeID.get() == spitType->getID()) {
if (value->setActionAssignedType(actionAssigned) == true) { if (value->setActionAssignedType(actionAssigned) == true) {
sendSPITObjectInternal(value.get()); sendObjectInternal(value.get());
} }
} }
} }
@@ -90,11 +93,11 @@ void SClient::setActionSPITType(string typeId, bool actionAssigned) {
/** This should be called if the user wants to associate/remove an action with a SPITObject. */ /** This should be called if the user wants to associate/remove an action with a SPITObject. */
void SClient::setActionSPITObject(string spitObjId, bool actionAssigned) { void SClient::setActionSPITObject(string spitObjId, bool actionAssigned) {
SObject *spitObject = mSpitObjects.getEntry(spitObjId); SObject *spitObject = mProcessor.mSpitObjects.getEntry(spitObjId);
if (spitObject == nullptr) if (spitObject == nullptr)
return; return;
if (spitObject->setActionAssigned(actionAssigned) == true) { if (spitObject->setActionAssigned(actionAssigned) == true) {
sendSPITObjectInternal(spitObject); sendObjectInternal(spitObject);
} }
} }
//---------- ServerAutoDetection SAD ----------- //---------- ServerAutoDetection SAD -----------
@@ -205,7 +208,7 @@ void SClient::eventServerChanged(SadDetectedServer &server) {
// // } //Excample // // } //Excample
// } // }
int SClient::sendSPITMessage(Message::OPPart &opPart) { int SClient::sendMessage(Message::OPPart &opPart) {
if (mMessageNumberSend == 255) if (mMessageNumberSend == 255)
mMessageNumberSend = 1; mMessageNumberSend = 1;
else else
@@ -365,7 +368,7 @@ void SClient::parseMessage(unique_ptr<Message> message) {
parseDisconnect(message->getAs<Message::Disconnect>()); parseDisconnect(message->getAs<Message::Disconnect>());
break; break;
case Message::ReportProject::OPFLAG: case Message::ReportProject::OPFLAG:
parseReportProject(message->getAs<Message::ReportProject>()); mProcessor.parseReportProject(message->getAs<Message::ReportProject>());
break; break;
case Message::Watchdog::OPFLAG: case Message::Watchdog::OPFLAG:
parseWatchdog(message->getAs<Message::Watchdog>()); parseWatchdog(message->getAs<Message::Watchdog>());
@@ -375,43 +378,43 @@ void SClient::parseMessage(unique_ptr<Message> message) {
break; break;
//----- SPIT Project ----- //----- SPIT Project -----
case Message::StartProjectTransfer::OPFLAG: case Message::StartProjectTransfer::OPFLAG:
parseStartProjectTransfer(message->getAs<Message::StartProjectTransfer>()); mProcessor.parseStartProjectTransfer(message->getAs<Message::StartProjectTransfer>());
break; break;
case Message::CloseProject::OPFLAG: case Message::CloseProject::OPFLAG:
parseCloseProject(message->getAs<Message::CloseProject>()); mProcessor.parseCloseProject(message->getAs<Message::CloseProject>());
break; break;
case Message::RequestProjectTransfer::OPFLAG: case Message::RequestProjectTransfer::OPFLAG:
parseRequestProjectTransfer(message->getAs<Message::RequestProjectTransfer>()); mProcessor.parseRequestProjectTransfer(message->getAs<Message::RequestProjectTransfer>());
break; break;
case Message::EndProjectTransfer::OPFLAG: case Message::EndProjectTransfer::OPFLAG:
parseEndProjectTransfer(message->getAs<Message::EndProjectTransfer>()); mProcessor.parseEndProjectTransfer(message->getAs<Message::EndProjectTransfer>());
break; break;
//----- SPIT Types ------ //----- SPIT Types ------
case Message::ReportType::OPFLAG: case Message::ReportType::OPFLAG:
mProcessor.parseReportType(message->getAs<Message::ReportType>()); mProcessor.parseReportType(message->getAs<Message::ReportType>());
break; break;
case Message::RemoveType::OPFLAG: case Message::RemoveType::OPFLAG:
parseRemoveSPITType(message->getAs<Message::RemoveType>()); mProcessor. parseRemoveType(message->getAs<Message::RemoveType>());
//----- SPIT Objects ------ //----- SPIT Objects ------
break; break;
case Message::ReportObject::OPFLAG: case Message::ReportObject::OPFLAG:
parseReportSPITObject(message->getAs<Message::ReportObject>()); mProcessor.parseReportObject(message->getAs<Message::ReportObject>());
break; break;
case Message::RemoveObject::OPFLAG: case Message::RemoveObject::OPFLAG:
parseRemoveSPITObject(message->getAs<Message::RemoveObject>()); mProcessor.parseRemoveObject(message->getAs<Message::RemoveObject>());
break; break;
//----- Play SPIT Objects ------ //----- Play SPIT Objects ------
case Message::PlayStart::OPFLAG: case Message::PlayStart::OPFLAG:
parsePlaySPITStart(message->getAs<Message::PlayStart>()); mProcessor.parsePlayStart(message->getAs<Message::PlayStart>());
break; break;
case Message::PlayObject::OPFLAG: case Message::PlayObject::OPFLAG:
parsePlaySPITObject(message->getAs<Message::PlayObject>()); mProcessor.parsePlayObject(message->getAs<Message::PlayObject>());
break; break;
case Message::PlayEnd::OPFLAG: case Message::PlayEnd::OPFLAG:
parsePlaySPITEnd(message->getAs<Message::PlayEnd>()); mProcessor.parsePlayEnd(message->getAs<Message::PlayEnd>());
break; break;
case Message::ReportPlayStatus::OPFLAG: case Message::ReportPlayStatus::OPFLAG:
parseReportPlayStatus(message->getAs<Message::ReportPlayStatus>()); mProcessor.parseReportPlayStatus(message->getAs<Message::ReportPlayStatus>());
break; break;
default: default:
ESP_LOGD(TAG, "Client::parseMessage: Unknown Message"); ESP_LOGD(TAG, "Client::parseMessage: Unknown Message");
@@ -459,7 +462,7 @@ bool SClient::connect(string serverIP, string serverPort, string clientIP, strin
// sleep a little to make sure that the reception of the messages is started // sleep a little to make sure that the reception of the messages is started
fos::Task::delayMs(500); fos::Task::delayMs(500);
if (sendSPITMessage(sMConnect) < 0) { if (sendMessage(sMConnect) < 0) {
mConnectionStatus = Connection::None; mConnectionStatus = Connection::None;
mStopReceiveMessages = true; mStopReceiveMessages = true;
return false; return false;
@@ -483,7 +486,7 @@ void SClient::disconnectInternal(Connection cause) {
break; break;
case Connection::None: { case Connection::None: {
Message::Disconnect sMDisconnect; Message::Disconnect sMDisconnect;
sendSPITMessage(sMDisconnect); sendMessage(sMDisconnect);
} break; } break;
case Connection::NoneServer: case Connection::NoneServer:
break; break;
@@ -505,7 +508,7 @@ void SClient::disconnectInternal(Connection cause) {
ESP_LOGD(TAG, "connection terminated by server"); ESP_LOGD(TAG, "connection terminated by server");
// call eventProjectClosed because this may not be sended by the server, // call eventProjectClosed because this may not be sended by the server,
// when the connection is closed // when the connection is closed
mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, mServerProjectID); mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, mProcessor.getServerProjectID());
// Server has terminated the connection -> start a new game // Server has terminated the connection -> start a new game
// _doReconnect = false; // _doReconnect = false;
@@ -574,7 +577,7 @@ void SClient::parseDisconnect(Message::Disconnect &message) {
void SClient::parseWatchdog(Message::Watchdog &message) { void SClient::parseWatchdog(Message::Watchdog &message) {
// ESP_LOGD(TAG, "parse Watchdog "); // ESP_LOGD(TAG, "parse Watchdog ");
Message::WatchdogAnswer o_WatchdogAnswer; Message::WatchdogAnswer o_WatchdogAnswer;
sendSPITMessage(o_WatchdogAnswer); sendMessage(o_WatchdogAnswer);
} }
/** /**
* The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
@@ -588,7 +591,7 @@ void SClient::parseWatchdogAnswer(Message::WatchdogAnswer &message) {
void SClient::sendWatchdog() { void SClient::sendWatchdog() {
int intResult; int intResult;
Message::Watchdog message; Message::Watchdog message;
intResult = sendSPITMessage(message); intResult = sendMessage(message);
if (intResult < 0) { if (intResult < 0) {
ESP_LOGW("WDT", "Failed to send Watchdog msg"); ESP_LOGW("WDT", "Failed to send Watchdog msg");
} }
@@ -601,130 +604,9 @@ void SClient::eventWatchdogLost() {
} }
} }
//----- SPIT Project ------ string SClient::getServerProjectID() { return mProcessor.getServerProjectID(); }
void SClient::parseReportProject(Message::ReportProject &message) { string SClient::getServerProjectName() { return mProcessor.getServerProjectName(); }
ESP_LOGD(TAG, "parse ReportProject"); int SClient::getServerFramesPerSecond() { return mProcessor.getServerFramesPerSecond(); }
mServerProjectID = message.getProjectID();
mServerProjectName = message.getProjectName();
mServerFramesPerSecond = message.getFramesPerSecond();
mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, mServerProjectID);
// Set all SPITTypes and SPITObjects confirmed = false
SType::setConfirmedFalse(mProcessor.mSpitTypes);
SObject::setConfirmedFalse(mSpitObjects);
// Send RequestProjectTransfer
Message::RequestProjectTransfer sMRequestProjectTransfer;
if (sendSPITMessage(sMRequestProjectTransfer) < 0) {
ESP_LOGD(TAG, "Client::parseReportProject could not send RequestProjectTransfer");
}
// todo Don't send the ReportProject here it should be sended after parseEndProjectTransfer
// Send client's ReportProject
Message::ReportProject reportProject(mProjName, mProjName);
reportProject.setFramesPerSecond(0);
if (sendSPITMessage(reportProject) < 0) {
ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
}
}
void SClient::parseCloseProject(Message::CloseProject &p_CloseSPITProject) {
ESP_LOGD(TAG, "parse CloseProject");
string stringProjectID;
mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject.getProjectID());
SPlayer::clearPlayers();
}
string SClient::getServerProjectID() { return mServerProjectID; }
string SClient::getServerProjectName() { return mServerProjectName; }
int SClient::getServerFramesPerSecond() { return mServerFramesPerSecond; }
void SClient::parseRequestProjectTransfer(Message::RequestProjectTransfer &message) {
ESP_LOGD(TAG, "parse RequestProjectTransfer");
// StartProjectTransfer
Message::StartProjectTransfer sMStartProjectTransfer;
if (sendSPITMessage(sMStartProjectTransfer) < 0) {
return;
}
// send all listes SPITTypes
for (const auto& [key, value] : mProcessor.mSpitTypes.getRepo()) {
sendSPITTypeInternal(*value);
fos::Task::delayMs(10);
}
for (auto& [key, value] : mSpitObjects.getRepo()) {
sendSPITObjectInternal(value.get());
fos::Task::delayMs(10);
}
// EndProjectTransfer
Message::EndProjectTransfer sMEndProjectTransfer;
sendSPITMessage(sMEndProjectTransfer);
}
/* NEW IMPLEMENTATION
void SClient::parseRequestProjectTransfer(Message::RequestProjectTransfer* message) {
// ESP_LOGD(TAG, "parse RequestProjectTransfer");
thread* o_ThreadSend;
o_ThreadSend = new thread(&this->sendProject, this);
// int intResult;
// Message::StartProjectTransfer* ptrSMStartProjectTransfer;
// Message::EndProjectTransfer* ptrSMEndProjectTransfer;
// int intCount;
// SPITType* ptrSPITType;
// SObject* ptrSPITObject;
// //StartProjectTransfer
// NotifyStartProjectTransfer_Client* o_RunnableStart = new NotifyStartProjectTransfer_Client(mSPITClientInterface);
// SPIT_Handler::addRunnable(o_RunnableStart);
// ptrSMStartProjectTransfer = new Message::StartProjectTransfer();
// intResult = sendSPITMessage(ptrSMStartProjectTransfer);
// if (intResult < 0) {
// return;
// }
// mWatchdog->answerWatchdog();
// {
// //send all listes SPITTypes
// unique_lock<recursive_mutex> o_LockType(*SPITType::getMutex());
// intCount = SPITType::getSPITTypeCount();
// for (int i = 0; i < intCount; i++) {
// ptrSPITType = mSpitTypes.getEntry(i);
// if (ptrSPITType == nullptr) continue;
// intResult = sendSPITTypeInternal(ptrSPITType);
// if (intResult < 0) return;
// mWatchdog->answerWatchdog();
// this_thread::sleep_for(chrono::milliseconds(7));
// }
// }
// {
// unique_lock<recursive_mutex> o_LockObject(*SObject::getMutex());
// intCount = mSpitObjects.getEntryCount();
// for (int i = 0; i < intCount; i++) {
// ptrSPITObject = mSpitObjects.getEntry(i);
// if (ptrSPITObject == nullptr) continue;
// intResult = sendSPITObjectInternal(ptrSPITObject);
// if (intResult < 0) return;
// mWatchdog->answerWatchdog();
// this_thread::sleep_for(chrono::milliseconds(7));
// }
// }
// //EndProjectTransfer
// ptrSMEndProjectTransfer = new Message::EndProjectTransfer();
// intResult = sendSPITMessage(ptrSMEndProjectTransfer);
// if (intResult < 0) {
// return;
// }
// mWatchdog->answerWatchdog();
// NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(mSPITClientInterface);
// SPIT_Handler::addRunnable(o_RunnableEnd);
// //Send act
}
*/
void SClient::sendProject(SClient *p_PtrSPIT_Client) { void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// int intResult; // int intResult;
@@ -739,7 +621,7 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// SPIT_Handler::addRunnable(o_RunnableStart); // SPIT_Handler::addRunnable(o_RunnableStart);
// ptrSMStartProjectTransfer = new Message::StartProjectTransfer(); // ptrSMStartProjectTransfer = new Message::StartProjectTransfer();
// intResult = p_PtrSPIT_Client->sendSPITMessage(ptrSMStartProjectTransfer); // intResult = p_PtrSPIT_Client->sendMessage(ptrSMStartProjectTransfer);
// if (intResult < 0) { // if (intResult < 0) {
// return; // return;
// } // }
@@ -753,7 +635,7 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// ptrSPITType = mSpitTypes.getEntry(i); // ptrSPITType = mSpitTypes.getEntry(i);
// if (ptrSPITType == nullptr) continue; // if (ptrSPITType == nullptr) continue;
// if (ptrSPITType->getCreatedByClient() == false) continue; // if (ptrSPITType->getCreatedByClient() == false) continue;
// intResult = p_PtrSPIT_Client->sendSPITTypeInternal(ptrSPITType); // intResult = p_PtrSPIT_Client->sendTypeInternal(ptrSPITType);
// if (intResult < 0) return; // if (intResult < 0) return;
// // mWatchdog->answerWatchdog(); // // mWatchdog->answerWatchdog();
// this_thread::sleep_for(chrono::milliseconds(7)); // this_thread::sleep_for(chrono::milliseconds(7));
@@ -767,7 +649,7 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// ptrSPITObject = mSpitObjects.getEntry(i); // ptrSPITObject = mSpitObjects.getEntry(i);
// if (ptrSPITObject == nullptr) continue; // if (ptrSPITObject == nullptr) continue;
// if (ptrSPITObject->getCreatedByClient() == false) continue; // if (ptrSPITObject->getCreatedByClient() == false) continue;
// intResult = p_PtrSPIT_Client->sendSPITObjectInternal(ptrSPITObject); // intResult = p_PtrSPIT_Client->sendObjectInternal(ptrSPITObject);
// if (intResult < 0) return; // if (intResult < 0) return;
// // mWatchdog->answerWatchdog(); // // mWatchdog->answerWatchdog();
// this_thread::sleep_for(chrono::milliseconds(7)); // this_thread::sleep_for(chrono::milliseconds(7));
@@ -776,7 +658,7 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// //EndProjectTransfer // //EndProjectTransfer
// ptrSMEndProjectTransfer = new Message::EndProjectTransfer(); // ptrSMEndProjectTransfer = new Message::EndProjectTransfer();
// intResult = p_PtrSPIT_Client->sendSPITMessage(ptrSMEndProjectTransfer); // intResult = p_PtrSPIT_Client->sendMessage(ptrSMEndProjectTransfer);
// if (intResult < 0) { // if (intResult < 0) {
// return; // return;
// } // }
@@ -787,115 +669,16 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// //Send act // //Send act
} }
void SClient::parseStartProjectTransfer(Message::StartProjectTransfer &message) {
mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID);
}
void SClient::parseEndProjectTransfer(Message::EndProjectTransfer &message) {
SObject::clearUnconfirmedObjects(mSpitObjects);
mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, mServerProjectID);
// Send Message::ReportProject after the mSPITClientInterface is notfied of EndProjectTransfer
Message::ReportProject reportSPITProject(mProjName, mProjName);
reportSPITProject.setFramesPerSecond(0);
if (sendSPITMessage(reportSPITProject) < 0) {
ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
}
}
void SClient::parseRemoveSPITType(Message::RemoveType &message) {
ESP_LOGD(TAG, "parse RemoveType %s", message.getID().c_str());
bool boolRemote = false;
string stringSPITTypeID = message.getID();
SType *ptrSPITType = mProcessor.mRemoteSpitTypes.getEntry(stringSPITTypeID);
if (!ptrSPITType) {
boolRemote = true;
} else {
ptrSPITType = mProcessor.mSpitTypes.getEntry(stringSPITTypeID);
if (!ptrSPITType) {
boolRemote = false;
} else {
// No SPITType with stringSPITTypeID is listet
return;
}
}
if (ptrSPITType->getCreatedByClient() && ptrSPITType->Fixed.get()) {
// the SPITyte is created by client himself and it is fixed -> don't remove the SPITType!!
// Send the SPITTyp back to the server
sendSPITTypeInternal(*ptrSPITType);
return;
}
mCallbacks.onSpitType(ObjectEvent::Deleted, boolRemote, *ptrSPITType);
if (boolRemote == false) {
mProcessor.mSpitTypes.removeEntry(*ptrSPITType);
} else {
mProcessor.mRemoteSpitTypes.removeEntry(*ptrSPITType);
}
}
/** /**
* If a client has changed a SPITType, it should send it to the server to transmit the changes. * If a client has changed a SPITType, it should send it to the server to transmit the changes.
* If the SPITType is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the changes. * If the SPITType is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the changes.
* @param p_SPITType the pointer to the changed SPITType * @param p_SPITType the pointer to the changed SPITType
* @return 0 = is sended, -1 = is not sended * @return 0 = is sended, -1 = is not sended
*/ */
int SClient::sendSPITTypeInternal(SType &p_SPITType) { int SClient::sendTypeInternal(SType &p_SPITType) {
Message::ReportType sMReportSPITType; Message::ReportType sMReportSPITType;
p_SPITType.fillMessageOP(sMReportSPITType); p_SPITType.fillMessageOP(sMReportSPITType);
return sendSPITMessage(sMReportSPITType); return sendMessage(sMReportSPITType);
}
/**
* Change an existing SPIT_Type.
* @param p_SPITType the SPITType vont
* @return true = changed, false = not changed maybe p_SPITType is NULL or the SPITType doesn't exists
*/
bool SClient::changeSPITType(SType *p_SPITType) {
if (p_SPITType == nullptr)
return false;
SType *ptrSPITType = mProcessor.mSpitTypes.getEntry(p_SPITType->getID());
if (ptrSPITType == nullptr)
return false;
ptrSPITType->DefaultDelay.set(p_SPITType->DefaultDelay.get());
ptrSPITType->DefaultDuration.set(p_SPITType->DefaultDuration.get());
ptrSPITType->Fixed.set(p_SPITType->Fixed.get());
ptrSPITType->GroupName.set(p_SPITType->GroupName.get());
ptrSPITType->Name.set(p_SPITType->Name.get());
ptrSPITType->ProjectIndepended.set(p_SPITType->ProjectIndepended.get());
mCallbacks.onSpitType(ObjectEvent::Changed, false, *ptrSPITType);
sendSPITTypeInternal(*ptrSPITType);
return true;
}
/**
* If a client has removed a SPITType where id == p_SPITTypeID, it should send it to the server.
* The corresponding SPITType if listet in SPITType will be deleted.
* An eventRemoveSPITType will occur.
* If a connection to a SPITServer is established, the SPITServer may dicard the deletion an an eventSPITType will occur
* -> the SPITType will be listet again.
* @param p_SPITType the id of the SPITType ro remove
* @return 0 = is sended, -1 = is not sended
*/
int SClient::removeSPITType(string p_SPITTypeID) {
if (p_SPITTypeID.length() <= 0)
return -1;
SType *ptrSPITType;
{
ptrSPITType = mProcessor.mSpitTypes.getEntry(p_SPITTypeID);
if (ptrSPITType == nullptr)
return -1;
Message::RemoveType sMRemoveSPITType;
ptrSPITType->fillMessageOP(sMRemoveSPITType);
mCallbacks.onSpitType(ObjectEvent::Deleted, false, *ptrSPITType);
mProcessor.mSpitTypes.removeEntry(*ptrSPITType);
return sendSPITMessage(sMRemoveSPITType);
}
return -1;
} }
SType *SClient::createTypeFixed(string iD, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration) { SType *SClient::createTypeFixed(string iD, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration) {
@@ -923,113 +706,17 @@ SType *SClient::createType(string p_ID, string p_GroupName, string p_Name, uint6
auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed; auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
mCallbacks.onSpitType(eventType, false, *ptrSPITType); mCallbacks.onSpitType(eventType, false, *ptrSPITType);
sendSPITTypeInternal(*ptrSPITType); sendTypeInternal(*ptrSPITType);
return ptrSPITType; return ptrSPITType;
} }
//----- SPIT Objects ------ int SClient::sendObjectInternal(SObject *ptrSPITObject) {
void SClient::parseReportSPITObject(Message::ReportObject &message) {
ESP_LOGD(TAG, "parse ReportObject %s", message.getID().c_str());
SObject *ptrSPITObject;
SType *ptrSPITType;
bool boolNew = false;
bool boolRemote = false;
bool boolChanged = false;
{
ESP_LOGD(TAG, "parse ReportObject %s / %s", message.getID().c_str(), message.getName().c_str());
if (message.getServerRemote() == false) {
boolRemote = false;
ptrSPITObject = mSpitObjects.getEntry(message.getID());
ptrSPITType = mProcessor.mSpitTypes.getEntry(message.getSPITTypeID());
if (ptrSPITType == nullptr) {
// No associated SPITType found
if (ptrSPITObject != nullptr) {
// SpitObject exists but has no corresponding SPITType -> remove the SPITObject without sending a message
// Maybe the SPITObject has changed the SPITTypeID to a SPITTypeID of another board
mSpitObjects.removeEntry(*ptrSPITObject);
}
return;
}
bool isKnownType = ptrSPITType != nullptr;
if (ptrSPITObject == nullptr) {
// The user's app my veto the SPITType
if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) {
ESP_LOGW(TAG, "ObjectVeto %s / %s", message.getID().c_str(), message.getName().c_str());
return;
}
auto spitObj = make_unique<SObject>(message.getID());
ptrSPITObject = spitObj.get();
mSpitObjects.addEntry(move(spitObj));
boolNew = true;
} else {
// The user's app my veto the SPITType
if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) {
// SpitObject exists and User APp denied the SPITObject -> remove the SPITObject without sending a message
mSpitObjects.removeEntry(*ptrSPITObject);
ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
return;
}
}
} else {
boolRemote = true;
ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
ptrSPITType = mProcessor.mRemoteSpitTypes.getEntry(message.getSPITTypeID());
if (ptrSPITType == nullptr) {
// No associated SPITType found
return;
}
if (ptrSPITObject == nullptr) {
auto spitObj = make_unique<SObject>(message.getID());
ptrSPITObject = spitObj.get();
mRemoteSpitObjects.addEntry(move(spitObj));
boolNew = true;
}
}
if (!ptrSPITObject->setMessageOP(&message)) {
ESP_LOGE(TAG, "Change not allowed");
// setMessageOP error - the SPITObject can't be changed, it may be fixed and crated by this client
sendSPITObjectInternal(ptrSPITObject);
return;
}
if (boolRemote == false) {
// set the virtual action assignment
ptrSPITObject->setActionAssignedType(ptrSPITType->ActionAssigned.get());
}
auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
mCallbacks.onSpitObject(eventType, boolRemote, *ptrSPITType, *ptrSPITObject);
if (ptrSPITObject->setConfirmed(true) == true || boolChanged == true) {
// Confirmation has changed
sendSPITObjectInternal(ptrSPITObject);
}
}
}
void SClient::parseRemoveSPITObject(Message::RemoveObject &message) {
ESP_LOGD(TAG, "parse RemoveObject %s", message.getID().c_str());
SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
if (ptrSPITObject != nullptr) {
SType *ptrSPITType = mProcessor.mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
if (ptrSPITType != nullptr) {
mCallbacks.onSpitObject(ObjectEvent::Deleted, true, *ptrSPITType, *ptrSPITObject);
}
mRemoteSpitObjects.removeEntry(*ptrSPITObject);
} else {
// call removeSPITObject, this will notify the server that the object is removed
removeSPITObject(message.getID());
}
}
int SClient::sendSPITObjectInternal(SObject *ptrSPITObject) {
if (ptrSPITObject == nullptr) if (ptrSPITObject == nullptr)
return -1; return -1;
Message::ReportObject sMReportSPITObject; Message::ReportObject sMReportSPITObject;
ptrSPITObject->fillMessageOP(sMReportSPITObject); ptrSPITObject->fillMessageOP(sMReportSPITObject);
return sendSPITMessage(sMReportSPITObject); return sendMessage(sMReportSPITObject);
} }
/** /**
* When the client changes an existing SPITObject (normally the client should not do this), then he should send the changes to the SPITServer. * When the client changes an existing SPITObject (normally the client should not do this), then he should send the changes to the SPITServer.
@@ -1045,7 +732,7 @@ bool SClient::changeSPITObject(SObject *obj) {
SObject *ptrSPITObject; SObject *ptrSPITObject;
SType *ptrSPITType; SType *ptrSPITType;
{ {
ptrSPITObject = mSpitObjects.getEntry(obj->getID()); ptrSPITObject = mProcessor.mSpitObjects.getEntry(obj->getID());
if (ptrSPITObject == nullptr) if (ptrSPITObject == nullptr)
return false; return false;
ptrSPITType = mProcessor.mSpitTypes.getEntry(obj->getID()); ptrSPITType = mProcessor.mSpitTypes.getEntry(obj->getID());
@@ -1070,112 +757,11 @@ bool SClient::changeSPITObject(SObject *obj) {
ptrSPITObject->ValueUse.set(obj->ValueUse.get()); ptrSPITObject->ValueUse.set(obj->ValueUse.get());
mCallbacks.onSpitObject(ObjectEvent::Changed, false, *ptrSPITType, *ptrSPITObject); mCallbacks.onSpitObject(ObjectEvent::Changed, false, *ptrSPITType, *ptrSPITObject);
sendSPITObjectInternal(ptrSPITObject); sendObjectInternal(ptrSPITObject);
} }
return true; return true;
} }
/**
* When the client wants to remove a SPITObject with id == p_SPITObjectID (normally the client should not do this), then he should send it to the SPITServer.
* The corresponding SPITObject if listet in SPITObject will be deleted.
* An eventRemoveSPITType will occur.
* If an connection to a SPITServer is established, the SPITServer may discard the deletion and an eventSPITObject occurs
* -> the SPITObject is listet again.
* @param objId the id of the SPITObject to remove.
* @return 0 = sended to the SPITServer, -1 = not sended to the SPITServer or nos SPITObject with id == objId exists.
*/
int SClient::removeSPITObject(string objId) {
if (objId.length() <= 0)
return -1;
SType *ptrSPITType;
SObject *ptrSPITObject;
{
Message::RemoveObject sMRemoveSPITObject;
ptrSPITObject = mSpitObjects.getEntry(objId);
if (ptrSPITObject == nullptr)
return -1;
ptrSPITType = mProcessor.mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
if (ptrSPITType == nullptr)
return -1;
ptrSPITObject->fillMessageOP(sMRemoveSPITObject);
mCallbacks.onSpitObject(ObjectEvent::Deleted, false, *ptrSPITType, *ptrSPITObject);
mSpitObjects.removeEntry(*ptrSPITObject);
return sendSPITMessage(sMRemoveSPITObject);
}
return -1;
}
//----- Play SPIT Objects ------
void SClient::parsePlaySPITStart(Message::PlayStart &message) {
ESP_LOGD(TAG, "parse PlayStart ID: %s Name: %s Running: %d", message.getPlayerID().c_str(), message.getPlayerName().c_str(), (int)message.getPlayerIsRunning());
SPlayer &spitPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
spitPlayer.setIsRunning(message.getPlayerIsRunning());
spitPlayer.setName(message.getPlayerName());
spitPlayer.setType(message.getPlayerType());
spitPlayer.setTime(message.getTime());
spitPlayer.startPlaySequence();
mCallbacks.onPlay(spitPlayer.getID(), spitPlayer.getName(), spitPlayer.getType(), spitPlayer.getIsRunning(), spitPlayer.getTime());
}
void SClient::parsePlaySPITObject(Message::PlayObject &message) {
SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
SObject *ptrSPITObject = mSpitObjects.getEntry(message.getSPITObjectID());
if (ptrSPITObject == nullptr) {
return;
}
SPlayer::PlayType *ptrPlaySPITType = ptrSPITPlayer.addTypePlaying(ptrSPITObject->SPITTypeID.get());
if (ptrPlaySPITType == nullptr) {
return;
}
ptrPlaySPITType->setPlayerIsRunning(ptrSPITPlayer.getIsRunning());
ptrPlaySPITType->addValue(((double)message.getValue() / 1000000), ((double)ptrSPITObject->ValueFactor.get() / 1000000));
}
void SClient::parsePlaySPITEnd(Message::PlayEnd &message) {
SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
auto &ptrPlaySPITTypes = ptrSPITPlayer.getPlaySPITTypes();
for (auto i = ptrPlaySPITTypes.begin(); i != ptrPlaySPITTypes.end(); i++) {
SPlayer::PlayType *ptrPlaySPITType = i->second.get();
bool boolStarted = ptrPlaySPITType->getIsNew();
bool boolStopped = (ptrPlaySPITType->getIsPlayed() == false);
SType *ptrSPITType = mProcessor.mSpitTypes.getEntry(ptrPlaySPITType->getSPITTypeID());
if (ptrSPITType == nullptr) {
// set isplayed to false, the ptrPlayObject will be removed by ptrSPITPlayer.endPlaySequence()
ptrPlaySPITType->setIsPlayed(false);
continue;
}
mCallbacks.onPlaySpitType(ptrPlaySPITType->getPlayerID(), ptrPlaySPITType->getSPITTypeID(), ptrPlaySPITType->getPlayerIsRunning(), boolStarted, boolStopped, ptrPlaySPITType->getValue());
}
ptrSPITPlayer.endPlaySequence();
}
void SClient::parseReportPlayStatus(Message::ReportPlayStatus &message) {
SType *ptrSPITType = NULL;
SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
if (ptrSPITObject == nullptr) {
ptrSPITObject = mSpitObjects.getEntry(message.getID());
if (ptrSPITObject == nullptr) {
return;
}
}
if (ptrSPITObject->ServerRemote.get() == false) {
ptrSPITType = mProcessor.mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
} else {
ptrSPITType = mProcessor.mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
}
if (ptrSPITType == nullptr) {
return;
}
mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, message.getFrameInsideObject(), message.getValue());
}
//--------- Remote ---------- //--------- Remote ----------
/** /**
@@ -1193,14 +779,14 @@ void SClient::parseReportPlayStatus(Message::ReportPlayStatus &message) {
* VALUEFLAG_DECREASE (0x01) The server decreases his existing value by valuePpm * VALUEFLAG_DECREASE (0x01) The server decreases his existing value by valuePpm
*/ */
void SClient::sendRemoteObject(string p_SPITObjectID, int valuePpm, char valueFlag) { void SClient::sendRemoteObject(string p_SPITObjectID, int valuePpm, char valueFlag) {
SObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID); SObject *ptrRemoteSPITObject = mProcessor.mRemoteSpitObjects.getEntry(p_SPITObjectID);
if (ptrRemoteSPITObject == nullptr) if (ptrRemoteSPITObject == nullptr)
return; return;
Message::PlayStart playSPITStart(mID, mProjName, PLAYERTYPE_DISCRETE); Message::PlayStart playSPITStart(mID, mProjName, PLAYERTYPE_DISCRETE);
playSPITStart.setPlayerIsRunning(false); playSPITStart.setPlayerIsRunning(false);
playSPITStart.setTime(0); playSPITStart.setTime(0);
sendSPITMessage(playSPITStart); sendMessage(playSPITStart);
Message::PlayObject playSPITObject; Message::PlayObject playSPITObject;
playSPITObject.setID(ptrRemoteSPITObject->getID()); playSPITObject.setID(ptrRemoteSPITObject->getID());
@@ -1208,10 +794,10 @@ void SClient::sendRemoteObject(string p_SPITObjectID, int valuePpm, char valueFl
playSPITObject.setPlayerID(mID); playSPITObject.setPlayerID(mID);
playSPITObject.setValue(valuePpm); playSPITObject.setValue(valuePpm);
playSPITObject.setValueFlag(valueFlag); playSPITObject.setValueFlag(valueFlag);
sendSPITMessage(playSPITObject); sendMessage(playSPITObject);
Message::PlayEnd playSPITEnd(mID); Message::PlayEnd playSPITEnd(mID);
sendSPITMessage(playSPITEnd); sendMessage(playSPITEnd);
} }
fos::Semaphore SClient::sStartSad; fos::Semaphore SClient::sStartSad;
components/spit/src/spit_processor.cpp
+345 -419
View File
@@ -27,7 +27,7 @@ SProcessor::~SProcessor() {
// if (mConnectionStatus == Connection::Ok) { // if (mConnectionStatus == Connection::Ok) {
// ESP_LOGI(TAG, " ... tidy up ressources"); // ESP_LOGI(TAG, " ... tidy up ressources");
// Message::CloseProject closeSPITProject(mProjName); // Message::CloseProject closeSPITProject(mProjName);
// // if (sendSPITMessage(closeSPITProject) < 0) { // // if (mInternCallbacks.sendMessage(closeSPITProject) < 0) {
// // ESP_LOGD(TAG, "Client could not send Client's ReportProject"); // // ESP_LOGD(TAG, "Client could not send Client's ReportProject");
// // } // // }
// } // }
@@ -42,13 +42,13 @@ SProcessor::~SProcessor() {
// // send ReportProject to the server // // send ReportProject to the server
// Message::ReportProject reportSPITProject(mProjName, mProjName); // Message::ReportProject reportSPITProject(mProjName, mProjName);
// reportSPITProject.setFramesPerSecond(0); // reportSPITProject.setFramesPerSecond(0);
// // if (sendSPITMessage(reportSPITProject) < 0) { // // if (mInternCallbacks.sendMessage(reportSPITProject) < 0) {
// // ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send Client's ReportProject"); // // ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send Client's ReportProject");
// // } // // }
// // send RequestProjectTransfer // // send RequestProjectTransfer
// Message::RequestProjectTransfer sMRequestProjectTransfer; // Message::RequestProjectTransfer sMRequestProjectTransfer;
// // if (sendSPITMessage(sMRequestProjectTransfer) < 0) { // // if (mInternCallbacks.sendMessage(sMRequestProjectTransfer) < 0) {
// // ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send RequestProjectTransfer"); // // ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send RequestProjectTransfer");
// // } // // }
// } // }
@@ -67,7 +67,7 @@ SProcessor::~SProcessor() {
// if (spitType == nullptr) // if (spitType == nullptr)
// return; // return;
// if (spitType->ActionAssigned.set(actionAssigned)) { // if (spitType->ActionAssigned.set(actionAssigned)) {
// sendSPITTypeInternal(*spitType); // sendTypeInternal(*spitType);
// for (auto& [key, value] : mSpitObjects.getRepo()) { // for (auto& [key, value] : mSpitObjects.getRepo()) {
// if (value->SPITTypeID.get() == spitType->getID()) { // if (value->SPITTypeID.get() == spitType->getID()) {
// if (value->setActionAssignedType(actionAssigned) == true) { // if (value->setActionAssignedType(actionAssigned) == true) {
@@ -211,7 +211,7 @@ SProcessor::~SProcessor() {
// } // }
// return {}; // return {};
// } // }
// // todo Delete SProcessor::sendSPITMessage(Message::OPPart &opPart // // todo Delete SProcessor::mInternCallbacks.sendMessage(Message::OPPart &opPart
// // void SProcessor::receiveSPITMessage(SClient &rM) { // // void SProcessor::receiveSPITMessage(SClient &rM) {
// // char buffer[MAXSPITMESSAGEBYTECOUNT + 1]; // // char buffer[MAXSPITMESSAGEBYTECOUNT + 1];
@@ -357,7 +357,7 @@ SProcessor::~SProcessor() {
// //----- SPIT Objects ------ // //----- SPIT Objects ------
// break; // break;
// case Message::ReportObject::OPFLAG: // case Message::ReportObject::OPFLAG:
// parseReportSPITObject(message.getAs<Message::ReportObject>()); // parseReportObject(message.getAs<Message::ReportObject>());
// break; // break;
// case Message::RemoveObject::OPFLAG: // case Message::RemoveObject::OPFLAG:
// parseRemoveSPITObject(message.getAs<Message::RemoveObject>()); // parseRemoveSPITObject(message.getAs<Message::RemoveObject>());
@@ -421,7 +421,7 @@ SProcessor::~SProcessor() {
// // sleep a little to make sure that the reception of the messages is started // // sleep a little to make sure that the reception of the messages is started
// // fos::Task::delayMs(500); // // fos::Task::delayMs(500);
// // if (sendSPITMessage(sMConnect) < 0) { // // if (mInternCallbacks.sendMessage(sMConnect) < 0) {
// // mConnectionStatus = Connection::None; // // mConnectionStatus = Connection::None;
// // mStopReceiveMessages = true; // // mStopReceiveMessages = true;
// // return false; // // return false;
@@ -445,7 +445,7 @@ SProcessor::~SProcessor() {
// break; // break;
// case Connection::None: { // case Connection::None: {
// Message::Disconnect sMDisconnect; // Message::Disconnect sMDisconnect;
// // sendSPITMessage(sMDisconnect); // // mInternCallbacks.sendMessage(sMDisconnect);
// } break; // } break;
// case Connection::NoneServer: // case Connection::NoneServer:
// break; // break;
@@ -536,7 +536,7 @@ SProcessor::~SProcessor() {
// void SProcessor::parseWatchdog(Message::Watchdog &message) { // void SProcessor::parseWatchdog(Message::Watchdog &message) {
// // ESP_LOGD(TAG, "parse Watchdog "); // // ESP_LOGD(TAG, "parse Watchdog ");
// Message::WatchdogAnswer o_WatchdogAnswer; // Message::WatchdogAnswer o_WatchdogAnswer;
// // sendSPITMessage(o_WatchdogAnswer); // // mInternCallbacks.sendMessage(o_WatchdogAnswer);
// } // }
// /** // /**
// * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer // * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
@@ -550,7 +550,7 @@ SProcessor::~SProcessor() {
// void SProcessor::sendWatchdog() { // void SProcessor::sendWatchdog() {
// int intResult{}; // int intResult{};
// Message::Watchdog message; // Message::Watchdog message;
// // intResult = sendSPITMessage(message); // // intResult = mInternCallbacks.sendMessage(message);
// if (intResult < 0) { // if (intResult < 0) {
// ESP_LOGW("WDT", "Failed to send Watchdog msg"); // ESP_LOGW("WDT", "Failed to send Watchdog msg");
// } // }
@@ -563,65 +563,66 @@ SProcessor::~SProcessor() {
// } // }
// } // }
// //----- SPIT Project ------ //----- SPIT Project ------
// void SProcessor::parseReportProject(Message::ReportProject &message) { void SProcessor::parseReportProject(Message::ReportProject &message) {
// ESP_LOGD(TAG, "parse ReportProject"); ESP_LOGD(TAG, "parse ReportProject");
// mServerProjectID = message.getProjectID(); mServerProjectID = message.getProjectID();
// mServerProjectName = message.getProjectName(); mServerProjectName = message.getProjectName();
// mServerFramesPerSecond = message.getFramesPerSecond(); mServerFramesPerSecond = message.getFramesPerSecond();
// mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, mServerProjectID); mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, mServerProjectID);
// // Set all SPITTypes and SPITObjects confirmed = false // Set all SPITTypes and SPITObjects confirmed = false
// SType::setConfirmedFalse(mSpitTypes); SType::setConfirmedFalse(mSpitTypes);
// SObject::setConfirmedFalse(mSpitObjects); SObject::setConfirmedFalse(mSpitObjects);
// // Send RequestProjectTransfer // Send RequestProjectTransfer
// Message::RequestProjectTransfer sMRequestProjectTransfer; Message::RequestProjectTransfer sMRequestProjectTransfer;
// // if (sendSPITMessage(sMRequestProjectTransfer) < 0) { if (mInternCallbacks.sendMessage(sMRequestProjectTransfer) < 0) {
// // ESP_LOGD(TAG, "Client::parseReportProject could not send RequestProjectTransfer"); ESP_LOGD(TAG, "Client::parseReportProject could not send RequestProjectTransfer");
// // } }
// // todo Don't send the ReportProject here it should be sended after parseEndProjectTransfer // todo Don't send the ReportProject here it should be sended after parseEndProjectTransfer
// // Send client's ReportProject // Send client's ReportProject
// Message::ReportProject reportProject(mProjName, mProjName); Message::ReportProject reportProject(mProjName, mProjName);
// reportProject.setFramesPerSecond(0); reportProject.setFramesPerSecond(0);
// // if (sendSPITMessage(reportProject) < 0) { if (mInternCallbacks.sendMessage(reportProject) < 0) {
// // ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject"); ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
// // } }
// } }
// void SProcessor::parseCloseProject(Message::CloseProject &p_CloseSPITProject) {
// ESP_LOGD(TAG, "parse CloseProject");
// string stringProjectID;
// mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject.getProjectID());
// SPlayer::clearPlayers();
// }
// string SProcessor::getServerProjectID() { return mServerProjectID; } void SProcessor::parseCloseProject(Message::CloseProject &p_CloseSPITProject) {
// string SProcessor::getServerProjectName() { return mServerProjectName; } ESP_LOGD(TAG, "parse CloseProject");
// int SProcessor::getServerFramesPerSecond() { return mServerFramesPerSecond; } string stringProjectID;
mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject.getProjectID());
SPlayer::clearPlayers();
}
// void SProcessor::parseRequestProjectTransfer(Message::RequestProjectTransfer &message) { string SProcessor::getServerProjectID() { return mServerProjectID; }
// ESP_LOGD(TAG, "parse RequestProjectTransfer"); string SProcessor::getServerProjectName() { return mServerProjectName; }
// // StartProjectTransfer int SProcessor::getServerFramesPerSecond() { return mServerFramesPerSecond; }
// Message::StartProjectTransfer sMStartProjectTransfer;
// // if (sendSPITMessage(sMStartProjectTransfer) < 0) {
// // return;
// // }
// // send all listes SPITTypes void SProcessor::parseRequestProjectTransfer(Message::RequestProjectTransfer &message) {
// for (const auto& [key, value] : mSpitTypes.getRepo()) { ESP_LOGD(TAG, "parse RequestProjectTransfer");
// sendSPITTypeInternal(*value); // StartProjectTransfer
// // fos::Task::delayMs(10); Message::StartProjectTransfer sMStartProjectTransfer;
// } if (mInternCallbacks.sendMessage(sMStartProjectTransfer) < 0) {
// for (auto& [key, value] : mSpitObjects.getRepo()) { return;
// sendSPITObjectInternal(value.get()); }
// // fos::Task::delayMs(10);
// }
// // EndProjectTransfer // send all listes SPITTypes
// Message::EndProjectTransfer sMEndProjectTransfer; for (const auto& [key, value] : mSpitTypes.getRepo()) {
// // sendSPITMessage(sMEndProjectTransfer); mInternCallbacks.sendTypeInternal(*value);
// } mInternCallbacks.delay(10);
}
for (auto& [key, value] : mSpitObjects.getRepo()) {
mInternCallbacks.sendObjectInternal(value.get());
mInternCallbacks.delay(10);
}
// EndProjectTransfer
Message::EndProjectTransfer sMEndProjectTransfer;
// mInternCallbacks.sendMessage(sMEndProjectTransfer);
}
// /* NEW IMPLEMENTATION // /* NEW IMPLEMENTATION
@@ -641,7 +642,7 @@ SProcessor::~SProcessor() {
// // SPIT_Handler::addRunnable(o_RunnableStart); // // SPIT_Handler::addRunnable(o_RunnableStart);
// // ptrSMStartProjectTransfer = new Message::StartProjectTransfer(); // // ptrSMStartProjectTransfer = new Message::StartProjectTransfer();
// // intResult = sendSPITMessage(ptrSMStartProjectTransfer); // // intResult = mInternCallbacks.sendMessage(ptrSMStartProjectTransfer);
// // if (intResult < 0) { // // if (intResult < 0) {
// // return; // // return;
// // } // // }
@@ -653,7 +654,7 @@ SProcessor::~SProcessor() {
// // for (int i = 0; i < intCount; i++) { // // for (int i = 0; i < intCount; i++) {
// // ptrSPITType = mSpitTypes.getEntry(i); // // ptrSPITType = mSpitTypes.getEntry(i);
// // if (ptrSPITType == nullptr) continue; // // if (ptrSPITType == nullptr) continue;
// // intResult = sendSPITTypeInternal(ptrSPITType); // // intResult = mInternCallbacks.sendTypeInternal(ptrSPITType);
// // if (intResult < 0) return; // // if (intResult < 0) return;
// // mWatchdog->answerWatchdog(); // // mWatchdog->answerWatchdog();
// // this_thread::sleep_for(chrono::milliseconds(7)); // // this_thread::sleep_for(chrono::milliseconds(7));
@@ -675,7 +676,7 @@ SProcessor::~SProcessor() {
// // //EndProjectTransfer // // //EndProjectTransfer
// // ptrSMEndProjectTransfer = new Message::EndProjectTransfer(); // // ptrSMEndProjectTransfer = new Message::EndProjectTransfer();
// // intResult = sendSPITMessage(ptrSMEndProjectTransfer); // // intResult = mInternCallbacks.sendMessage(ptrSMEndProjectTransfer);
// // if (intResult < 0) { // // if (intResult < 0) {
// // return; // // return;
// // } // // }
@@ -687,87 +688,27 @@ SProcessor::~SProcessor() {
// } // }
// */ // */
// // void SProcessor::sendProject(SClient *p_PtrSPIT_Client) { void SProcessor::parseStartProjectTransfer(Message::StartProjectTransfer &message) {
// // int intResult; mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID);
// // Message::StartProjectTransfer* ptrSMStartProjectTransfer; }
// // Message::EndProjectTransfer* ptrSMEndProjectTransfer;
// // int intCount;
// // SPITType* ptrSPITType;
// // SObject* ptrSPITObject;
// // //StartProjectTransfer void SProcessor::parseEndProjectTransfer(Message::EndProjectTransfer &message) {
// // NotifyStartProjectTransfer_Client* o_RunnableStart = new NotifyStartProjectTransfer_Client(p_PtrSPIT_Client->getSPITClientInterface()); SObject::clearUnconfirmedObjects(mSpitObjects);
// // SPIT_Handler::addRunnable(o_RunnableStart); mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, mServerProjectID);
// // ptrSMStartProjectTransfer = new Message::StartProjectTransfer(); // Send Message::ReportProject after the mSPITClientInterface is notfied of EndProjectTransfer
// // intResult = p_PtrSPIT_Client->sendSPITMessage(ptrSMStartProjectTransfer); Message::ReportProject reportSPITProject(mProjName, mProjName);
// // if (intResult < 0) { reportSPITProject.setFramesPerSecond(0);
// // return; if (mInternCallbacks.sendMessage(reportSPITProject) < 0) {
// // } ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
}
// // // mWatchdog->answerWatchdog(); }
// // // {
// // //send all listes SPITTypes
// // // unique_lock<recursive_mutex> o_LockType(*SPITType::getMutex());
// // intCount = SPITType::getSPITTypeCount();
// // for (int i = 0; i < intCount; i++) {
// // ptrSPITType = mSpitTypes.getEntry(i);
// // if (ptrSPITType == nullptr) continue;
// // if (ptrSPITType->getCreatedByClient() == false) continue;
// // intResult = p_PtrSPIT_Client->sendSPITTypeInternal(ptrSPITType);
// // if (intResult < 0) return;
// // // mWatchdog->answerWatchdog();
// // this_thread::sleep_for(chrono::milliseconds(7));
// // }
// // // }
// // // {
// // // unique_lock<recursive_mutex> o_LockObject(*SObject::getMutex());
// // intCount = mSpitObjects.getEntryCount();
// // for (int i = 0; i < intCount; i++) {
// // ptrSPITObject = mSpitObjects.getEntry(i);
// // if (ptrSPITObject == nullptr) continue;
// // if (ptrSPITObject->getCreatedByClient() == false) continue;
// // intResult = p_PtrSPIT_Client->sendSPITObjectInternal(ptrSPITObject);
// // if (intResult < 0) return;
// // // mWatchdog->answerWatchdog();
// // this_thread::sleep_for(chrono::milliseconds(7));
// // }
// // // }
// // //EndProjectTransfer
// // ptrSMEndProjectTransfer = new Message::EndProjectTransfer();
// // intResult = p_PtrSPIT_Client->sendSPITMessage(ptrSMEndProjectTransfer);
// // if (intResult < 0) {
// // return;
// // }
// // // mWatchdog->answerWatchdog();
// // NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(p_PtrSPIT_Client->getSPITClientInterface());
// // SPIT_Handler::addRunnable(o_RunnableEnd);
// // //Send act
// // }
// void SProcessor::parseStartProjectTransfer(Message::StartProjectTransfer &message) {
// mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID);
// }
// void SProcessor::parseEndProjectTransfer(Message::EndProjectTransfer &message) {
// SObject::clearUnconfirmedObjects(mSpitObjects);
// mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, mServerProjectID);
// // Send Message::ReportProject after the mSPITClientInterface is notfied of EndProjectTransfer
// Message::ReportProject reportSPITProject(mProjName, mProjName);
// reportSPITProject.setFramesPerSecond(0);
// // if (sendSPITMessage(reportSPITProject) < 0) {
// // ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
// // }
// }
void SProcessor::parseReportType(Message::ReportType &message) { void SProcessor::parseReportType(Message::ReportType &message) {
ESP_LOGD(TAG, "parse ReportType ID %s Name %s", message.getID().c_str(), message.getName().c_str()); ESP_LOGD(TAG, "parse ReportType ID %s Name %s", message.getID().c_str(), message.getName().c_str());
SType *sType; SType *sType;
bool boolNew = false; bool isNew = false;
bool boolChanged = false; bool isChanged = false;
{ {
if (message.getServerRemote() == false) { if (message.getServerRemote() == false) {
sType = mSpitTypes.getEntry(message.getID()); sType = mSpitTypes.getEntry(message.getID());
@@ -785,7 +726,7 @@ void SProcessor::parseReportType(Message::ReportType &message) {
auto spitType = make_unique<SType>(message.getID()); auto spitType = make_unique<SType>(message.getID());
sType = spitType.get(); sType = spitType.get();
mSpitTypes.addEntry(move(spitType)); mSpitTypes.addEntry(move(spitType));
boolNew = true; isNew = true;
} }
} else { } else {
sType = mRemoteSpitTypes.getEntry(message.getID()); sType = mRemoteSpitTypes.getEntry(message.getID());
@@ -793,123 +734,109 @@ void SProcessor::parseReportType(Message::ReportType &message) {
auto spitType = make_unique<SType>(message.getID()); auto spitType = make_unique<SType>(message.getID());
sType = spitType.get(); sType = spitType.get();
mRemoteSpitTypes.addEntry(move(spitType)); mRemoteSpitTypes.addEntry(move(spitType));
boolNew = true; isNew = true;
} }
} }
if (!sType->setMessageOP(message)) { if (!sType->setMessageOP(message)) {
// SPITType is not changable -> send back to the server // SPITType is not changable -> send back to the server
mInternCallbacks.sendSpitTypeInternal(*sType); mInternCallbacks.sendTypeInternal(*sType);
return; return;
} }
auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed; auto eventType = isNew ? ObjectEvent::Created : ObjectEvent::Changed;
// add or change SPITType // add or change SPITType
mCallbacks.onSpitType(eventType, sType->ServerRemote.get(), *sType); mCallbacks.onSpitType(eventType, sType->ServerRemote.get(), *sType);
if (sType != nullptr) { if (sType != nullptr) {
if (sType->setConfirmed(true) == true || boolChanged == true) { if (sType->setConfirmed(true) == true || isChanged == true) {
mInternCallbacks.sendSpitTypeInternal(*sType); mInternCallbacks.sendTypeInternal(*sType);
} }
} }
} }
} }
// void SProcessor::parseRemoveSPITType(Message::RemoveType &message) { void SProcessor::parseRemoveType(Message::RemoveType &message) {
// ESP_LOGD(TAG, "parse RemoveType %s", message.getID().c_str()); ESP_LOGD(TAG, "parse RemoveType %s", message.getID().c_str());
// bool boolRemote = false; bool isRemote = false;
// string stringSPITTypeID = message.getID(); string sTypeID = message.getID();
// SType *ptrSPITType = mRemoteSpitTypes.getEntry(stringSPITTypeID); SType *sType = mRemoteSpitTypes.getEntry(sTypeID);
// if (!ptrSPITType) { if (!sType) {
// boolRemote = true; isRemote = true;
// } else { } else {
// ptrSPITType = mSpitTypes.getEntry(stringSPITTypeID); sType = mSpitTypes.getEntry(sTypeID);
// if (!ptrSPITType) { if (!sType) {
// boolRemote = false; isRemote = false;
// } else { } else {
// // No SPITType with stringSPITTypeID is listet // No SType with sTypeID is listet
// return; return;
// } }
// } }
// if (ptrSPITType->getCreatedByClient() && ptrSPITType->Fixed.get()) { if (sType->getCreatedByClient() && sType->Fixed.get()) {
// // the SPITyte is created by client himself and it is fixed -> don't remove the SPITType!! // the SPITyte is created by client himself and it is fixed -> don't remove the SType!!
// // Send the SPITTyp back to the server // Send the SPITTyp back to the server
// sendSPITTypeInternal(*ptrSPITType); mInternCallbacks.sendTypeInternal(*sType);
// return; return;
// } }
// mCallbacks.onSpitType(ObjectEvent::Deleted, boolRemote, *ptrSPITType); mCallbacks.onSpitType(ObjectEvent::Deleted, isRemote, *sType);
// if (boolRemote == false) { if (isRemote == false) {
// mSpitTypes.removeEntry(*ptrSPITType); mSpitTypes.removeEntry(*sType);
// } else { } else {
// mRemoteSpitTypes.removeEntry(*ptrSPITType); mRemoteSpitTypes.removeEntry(*sType);
// } }
// } }
// /** /**
// * If a client has changed a SPITType, it should send it to the server to transmit the changes. * Change an existing SPIT_Type.
// * If the SPITType is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the changes. * @param p_SPITType the SPITType vont
// * @param p_SPITType the pointer to the changed SPITType * @return true = changed, false = not changed maybe p_SPITType is NULL or the SPITType doesn't exists
// * @return 0 = is sended, -1 = is not sended */
// */ bool SProcessor::changeType(SType *p_SPITType) {
// int SProcessor::sendSPITTypeInternal(SType &p_SPITType) { if (p_SPITType == nullptr)
// Message::ReportType sMReportSPITType; return false;
// p_SPITType.fillMessageOP(sMReportSPITType); SType *ptrSPITType = mSpitTypes.getEntry(p_SPITType->getID());
// // return sendSPITMessage(sMReportSPITType); if (ptrSPITType == nullptr)
// return 1; return false;
// }
// /** ptrSPITType->DefaultDelay.set(p_SPITType->DefaultDelay.get());
// * Change an existing SPIT_Type. ptrSPITType->DefaultDuration.set(p_SPITType->DefaultDuration.get());
// * @param p_SPITType the SPITType vont ptrSPITType->Fixed.set(p_SPITType->Fixed.get());
// * @return true = changed, false = not changed maybe p_SPITType is NULL or the SPITType doesn't exists ptrSPITType->GroupName.set(p_SPITType->GroupName.get());
// */ ptrSPITType->Name.set(p_SPITType->Name.get());
// bool SProcessor::changeSPITType(SType *p_SPITType) { ptrSPITType->ProjectIndepended.set(p_SPITType->ProjectIndepended.get());
// if (p_SPITType == nullptr)
// return false;
// SType *ptrSPITType = mSpitTypes.getEntry(p_SPITType->getID());
// if (ptrSPITType == nullptr)
// return false;
// ptrSPITType->DefaultDelay.set(p_SPITType->DefaultDelay.get()); mCallbacks.onSpitType(ObjectEvent::Changed, false, *ptrSPITType);
// ptrSPITType->DefaultDuration.set(p_SPITType->DefaultDuration.get()); mInternCallbacks.sendTypeInternal(*ptrSPITType);
// ptrSPITType->Fixed.set(p_SPITType->Fixed.get());
// ptrSPITType->GroupName.set(p_SPITType->GroupName.get());
// ptrSPITType->Name.set(p_SPITType->Name.get());
// ptrSPITType->ProjectIndepended.set(p_SPITType->ProjectIndepended.get());
// mCallbacks.onSpitType(ObjectEvent::Changed, false, *ptrSPITType); return true;
// sendSPITTypeInternal(*ptrSPITType); }
// return true; /**
// } * If a client has removed a SPITType where id == p_SPITTypeID, it should send it to the server.
* The corresponding SPITType if listet in SPITType will be deleted.
// /** * An eventRemoveSPITType will occur.
// * If a client has removed a SPITType where id == p_SPITTypeID, it should send it to the server. * If a connection to a SPITServer is established, the SPITServer may dicard the deletion an an eventSPITType will occur
// * The corresponding SPITType if listet in SPITType will be deleted. * -> the SPITType will be listet again.
// * An eventRemoveSPITType will occur. * @param p_SPITType the id of the SPITType ro remove
// * If a connection to a SPITServer is established, the SPITServer may dicard the deletion an an eventSPITType will occur * @return 0 = is sended, -1 = is not sended
// * -> the SPITType will be listet again. */
// * @param p_SPITType the id of the SPITType ro remove int SProcessor::removeType(string p_SPITTypeID) {
// * @return 0 = is sended, -1 = is not sended if (p_SPITTypeID.length() <= 0)
// */ return -1;
// int SProcessor::removeSPITType(string p_SPITTypeID) { SType *ptrSPITType;
// if (p_SPITTypeID.length() <= 0) {
// return -1; ptrSPITType = mSpitTypes.getEntry(p_SPITTypeID);
// SType *ptrSPITType; if (ptrSPITType == nullptr)
// { return -1;
// ptrSPITType = mSpitTypes.getEntry(p_SPITTypeID); Message::RemoveType sMRemoveSPITType;
// if (ptrSPITType == nullptr) ptrSPITType->fillMessageOP(sMRemoveSPITType);
// return -1; mCallbacks.onSpitType(ObjectEvent::Deleted, false, *ptrSPITType);
// Message::RemoveType sMRemoveSPITType; mSpitTypes.removeEntry(*ptrSPITType);
// ptrSPITType->fillMessageOP(sMRemoveSPITType); return mInternCallbacks.sendMessage(sMRemoveSPITType);
// mCallbacks.onSpitType(ObjectEvent::Deleted, false, *ptrSPITType); }
// mSpitTypes.removeEntry(*ptrSPITType); return -1;
// // return sendSPITMessage(sMRemoveSPITType); }
// return 1;
// }
// return -1;
// }
// SType *SProcessor::createTypeFixed(string iD, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration) { // SType *SProcessor::createTypeFixed(string iD, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration) {
// return createType(iD, p_GroupName, p_Name, p_DefaultDelay, p_DefaultDuration, true, true); // return createType(iD, p_GroupName, p_Name, p_DefaultDelay, p_DefaultDuration, true, true);
@@ -936,105 +863,105 @@ void SProcessor::parseReportType(Message::ReportType &message) {
// auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed; // auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
// mCallbacks.onSpitType(eventType, false, *ptrSPITType); // mCallbacks.onSpitType(eventType, false, *ptrSPITType);
// sendSPITTypeInternal(*ptrSPITType); // sendTypeInternal(*ptrSPITType);
// return ptrSPITType; // return ptrSPITType;
// } // }
// //----- SPIT Objects ------ //----- SPIT Objects ------
// void SProcessor::parseReportSPITObject(Message::ReportObject &message) { void SProcessor::parseReportObject(Message::ReportObject &message) {
// ESP_LOGD(TAG, "parse ReportObject %s", message.getID().c_str()); ESP_LOGD(TAG, "parse ReportObject %s", message.getID().c_str());
// SObject *ptrSPITObject; SObject *sObject;
// SType *ptrSPITType; SType *SType;
// bool boolNew = false; bool isNew = false;
// bool boolRemote = false; bool isRemote = false;
// bool boolChanged = false; bool isChanged = false;
// { {
// ESP_LOGD(TAG, "parse ReportObject %s / %s", message.getID().c_str(), message.getName().c_str()); ESP_LOGD(TAG, "parse ReportObject %s / %s", message.getID().c_str(), message.getName().c_str());
// if (message.getServerRemote() == false) { if (message.getServerRemote() == false) {
// boolRemote = false; isRemote = false;
// ptrSPITObject = mSpitObjects.getEntry(message.getID()); sObject = mSpitObjects.getEntry(message.getID());
// ptrSPITType = mSpitTypes.getEntry(message.getSPITTypeID()); SType = mSpitTypes.getEntry(message.getSPITTypeID());
// if (ptrSPITType == nullptr) { if (SType == nullptr) {
// // No associated SPITType found // No associated SPITType found
// if (ptrSPITObject != nullptr) { if (sObject != nullptr) {
// // SpitObject exists but has no corresponding SPITType -> remove the SPITObject without sending a message // SpitObject exists but has no corresponding SPITType -> remove the SPITObject without sending a message
// // Maybe the SPITObject has changed the SPITTypeID to a SPITTypeID of another board // Maybe the SPITObject has changed the SPITTypeID to a SPITTypeID of another board
// mSpitObjects.removeEntry(*ptrSPITObject); mSpitObjects.removeEntry(*sObject);
// } }
// return; return;
// } }
// bool isKnownType = ptrSPITType != nullptr; bool isKnownType = SType != nullptr;
// if (ptrSPITObject == nullptr) { if (sObject == nullptr) {
// // The user's app my veto the SPITType // The user's app my veto the SPITType
// if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) { if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) {
// ESP_LOGW(TAG, "ObjectVeto %s / %s", message.getID().c_str(), message.getName().c_str()); ESP_LOGW(TAG, "ObjectVeto %s / %s", message.getID().c_str(), message.getName().c_str());
// return; return;
// } }
// auto spitObj = make_unique<SObject>(message.getID()); auto spitObj = make_unique<SObject>(message.getID());
// ptrSPITObject = spitObj.get(); sObject = spitObj.get();
// mSpitObjects.addEntry(move(spitObj)); mSpitObjects.addEntry(move(spitObj));
// boolNew = true; isNew = true;
// } else { } else {
// // The user's app my veto the SPITType // The user's app my veto the SPITType
// if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) { if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == 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(*sObject);
// ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str()); ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
// return; return;
// } }
// } }
// } else { } else {
// boolRemote = true; isRemote = true;
// ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID()); sObject = mRemoteSpitObjects.getEntry(message.getID());
// ptrSPITType = mRemoteSpitTypes.getEntry(message.getSPITTypeID()); SType = mRemoteSpitTypes.getEntry(message.getSPITTypeID());
// if (ptrSPITType == nullptr) { if (SType == nullptr) {
// // No associated SPITType found // No associated SPITType found
// return; return;
// } }
// if (ptrSPITObject == nullptr) { if (sObject == nullptr) {
// auto spitObj = make_unique<SObject>(message.getID()); auto spitObj = make_unique<SObject>(message.getID());
// ptrSPITObject = spitObj.get(); sObject = spitObj.get();
// mRemoteSpitObjects.addEntry(move(spitObj)); mRemoteSpitObjects.addEntry(move(spitObj));
// boolNew = true; isNew = true;
// } }
// } }
// if (!ptrSPITObject->setMessageOP(&message)) { if (!sObject->setMessageOP(&message)) {
// 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); mInternCallbacks.sendObjectInternal(sObject);
// return; return;
// } }
// if (boolRemote == false) { if (isRemote == false) {
// // set the virtual action assignment // set the virtual action assignment
// ptrSPITObject->setActionAssignedType(ptrSPITType->ActionAssigned.get()); sObject->setActionAssignedType(SType->ActionAssigned.get());
// } }
// auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed; auto eventType = isNew ? ObjectEvent::Created : ObjectEvent::Changed;
// mCallbacks.onSpitObject(eventType, boolRemote, *ptrSPITType, *ptrSPITObject); mCallbacks.onSpitObject(eventType, isRemote, *SType, *sObject);
// if (ptrSPITObject->setConfirmed(true) == true || boolChanged == true) { if (sObject->setConfirmed(true) == true || isChanged == true) {
// // Confirmation has changed // Confirmation has changed
// sendSPITObjectInternal(ptrSPITObject); mInternCallbacks.sendObjectInternal(sObject);
// } }
// } }
// } }
// void SProcessor::parseRemoveSPITObject(Message::RemoveObject &message) { void SProcessor::parseRemoveObject(Message::RemoveObject &message) {
// ESP_LOGD(TAG, "parse RemoveObject %s", message.getID().c_str()); ESP_LOGD(TAG, "parse RemoveObject %s", message.getID().c_str());
// SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID()); SObject *sObject = mRemoteSpitObjects.getEntry(message.getID());
// if (ptrSPITObject != nullptr) { if (sObject != nullptr) {
// SType *ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get()); SType *sType = mRemoteSpitTypes.getEntry(sObject->SPITTypeID.get());
// if (ptrSPITType != nullptr) { if (sType != nullptr) {
// mCallbacks.onSpitObject(ObjectEvent::Deleted, true, *ptrSPITType, *ptrSPITObject); mCallbacks.onSpitObject(ObjectEvent::Deleted, true, *sType, *sObject);
// } }
// mRemoteSpitObjects.removeEntry(*ptrSPITObject); mRemoteSpitObjects.removeEntry(*sObject);
// } else { } else {
// // call removeSPITObject, this will notify the server that the object is removed // call removeObject, this will notify the server that the object is removed
// removeSPITObject(message.getID()); removeObject(message.getID());
// } }
// } }
// int SProcessor::sendSPITObjectInternal(SObject *ptrSPITObject) { // int SProcessor::sendSPITObjectInternal(SObject *ptrSPITObject) {
// if (ptrSPITObject == nullptr) // if (ptrSPITObject == nullptr)
@@ -1042,7 +969,7 @@ void SProcessor::parseReportType(Message::ReportType &message) {
// Message::ReportObject sMReportSPITObject; // Message::ReportObject sMReportSPITObject;
// ptrSPITObject->fillMessageOP(sMReportSPITObject); // ptrSPITObject->fillMessageOP(sMReportSPITObject);
// // return sendSPITMessage(sMReportSPITObject); // // return mInternCallbacks.sendMessage(sMReportSPITObject);
// return 1; // return 1;
// } // }
// /** // /**
@@ -1089,107 +1016,106 @@ void SProcessor::parseReportType(Message::ReportType &message) {
// return true; // return true;
// } // }
// /** /**
// * When the client wants to remove a SPITObject with id == p_SPITObjectID (normally the client should not do this), then he should send it to the SPITServer. * When the client wants to remove a SPITObject with id == p_SPITObjectID (normally the client should not do this), then he should send it to the SPITServer.
// * The corresponding SPITObject if listet in SPITObject will be deleted. * The corresponding SPITObject if listet in SPITObject will be deleted.
// * An eventRemoveSPITType will occur. * An eventRemoveSPITType will occur.
// * If an connection to a SPITServer is established, the SPITServer may discard the deletion and an eventSPITObject occurs * If an connection to a SPITServer is established, the SPITServer may discard the deletion and an eventSPITObject occurs
// * -> the SPITObject is listet again. * -> the SPITObject is listet again.
// * @param objId the id of the SPITObject to remove. * @param objId the id of the SPITObject to remove.
// * @return 0 = sended to the SPITServer, -1 = not sended to the SPITServer or nos SPITObject with id == objId exists. * @return 0 = sended to the SPITServer, -1 = not sended to the SPITServer or nos SPITObject with id == objId exists.
// */ */
// int SProcessor::removeSPITObject(string objId) { int SProcessor::removeObject(string objId) {
// if (objId.length() <= 0) if (objId.length() <= 0)
// return -1; return -1;
// SType *ptrSPITType; SType *sType;
// SObject *ptrSPITObject; SObject *sObject;
// { {
// Message::RemoveObject sMRemoveSPITObject; Message::RemoveObject remObj;
// ptrSPITObject = mSpitObjects.getEntry(objId); sObject = mSpitObjects.getEntry(objId);
// if (ptrSPITObject == nullptr) if (sObject == nullptr)
// return -1; return -1;
// ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get()); sType = mSpitTypes.getEntry(sObject->SPITTypeID.get());
// if (ptrSPITType == nullptr) if (sType == nullptr)
// return -1; return -1;
// ptrSPITObject->fillMessageOP(sMRemoveSPITObject); sObject->fillMessageOP(remObj);
// mCallbacks.onSpitObject(ObjectEvent::Deleted, false, *ptrSPITType, *ptrSPITObject); mCallbacks.onSpitObject(ObjectEvent::Deleted, false, *sType, *sObject);
// mSpitObjects.removeEntry(*ptrSPITObject); mSpitObjects.removeEntry(*sObject);
// // return sendSPITMessage(sMRemoveSPITObject); mInternCallbacks.sendMessage(remObj);
// return 1; }
// } return -1;
// return -1; }
// }
// //----- Play SPIT Objects ------ // //----- Play SPIT Objects ------
// void SProcessor::parsePlaySPITStart(Message::PlayStart &message) { void SProcessor::parsePlayStart(Message::PlayStart &message) {
// ESP_LOGD(TAG, "parse PlayStart ID: %s Name: %s Running: %d", message.getPlayerID().c_str(), message.getPlayerName().c_str(), (int)message.getPlayerIsRunning()); ESP_LOGD(TAG, "parse PlayStart ID: %s Name: %s Running: %d", message.getPlayerID().c_str(), message.getPlayerName().c_str(), (int)message.getPlayerIsRunning());
// SPlayer &spitPlayer = SPlayer::getSPITPlayer(message.getPlayerID()); SPlayer &player = SPlayer::getSPITPlayer(message.getPlayerID());
// spitPlayer.setIsRunning(message.getPlayerIsRunning()); player.setIsRunning(message.getPlayerIsRunning());
// spitPlayer.setName(message.getPlayerName()); player.setName(message.getPlayerName());
// spitPlayer.setType(message.getPlayerType()); player.setType(message.getPlayerType());
// spitPlayer.setTime(message.getTime()); player.setTime(message.getTime());
// spitPlayer.startPlaySequence(); player.startPlaySequence();
// mCallbacks.onPlay(spitPlayer.getID(), spitPlayer.getName(), spitPlayer.getType(), spitPlayer.getIsRunning(), spitPlayer.getTime()); mCallbacks.onPlay(player.getID(), player.getName(), player.getType(), player.getIsRunning(), player.getTime());
// } }
// void SProcessor::parsePlaySPITObject(Message::PlayObject &message) { void SProcessor::parsePlayObject(Message::PlayObject &message) {
// SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID()); SPlayer &player = SPlayer::getSPITPlayer(message.getPlayerID());
// SObject *ptrSPITObject = mSpitObjects.getEntry(message.getSPITObjectID()); SObject *sObject = mSpitObjects.getEntry(message.getSPITObjectID());
// if (ptrSPITObject == nullptr) { if (sObject == nullptr) {
// return; return;
// } }
// SPlayer::PlayType *ptrPlaySPITType = ptrSPITPlayer.addTypePlaying(ptrSPITObject->SPITTypeID.get()); SPlayer::PlayType *playType = player.addTypePlaying(sObject->SPITTypeID.get());
// if (ptrPlaySPITType == nullptr) { if (playType == nullptr) {
// return; return;
// } }
// ptrPlaySPITType->setPlayerIsRunning(ptrSPITPlayer.getIsRunning()); playType->setPlayerIsRunning(player.getIsRunning());
// ptrPlaySPITType->addValue(((double)message.getValue() / 1000000), ((double)ptrSPITObject->ValueFactor.get() / 1000000)); playType->addValue(((double)message.getValue() / 1000000), ((double)sObject->ValueFactor.get() / 1000000));
// } }
// void SProcessor::parsePlaySPITEnd(Message::PlayEnd &message) { void SProcessor::parsePlayEnd(Message::PlayEnd &message) {
// SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID()); SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
// auto &ptrPlaySPITTypes = ptrSPITPlayer.getPlaySPITTypes(); auto &playTypes = ptrSPITPlayer.getPlaySPITTypes();
// for (auto i = ptrPlaySPITTypes.begin(); i != ptrPlaySPITTypes.end(); i++) { for (auto i = playTypes.begin(); i != playTypes.end(); i++) {
// SPlayer::PlayType *ptrPlaySPITType = i->second.get(); SPlayer::PlayType *playType = i->second.get();
// bool boolStarted = ptrPlaySPITType->getIsNew(); bool isStarted = playType->getIsNew();
// bool boolStopped = (ptrPlaySPITType->getIsPlayed() == false); bool iStopped = (playType->getIsPlayed() == false);
// SType *ptrSPITType = mSpitTypes.getEntry(ptrPlaySPITType->getSPITTypeID()); SType *ptrSPITType = mSpitTypes.getEntry(playType->getSPITTypeID());
// if (ptrSPITType == nullptr) { if (ptrSPITType == nullptr) {
// // set isplayed to false, the ptrPlayObject will be removed by ptrSPITPlayer.endPlaySequence() // set isplayed to false, the ptrPlayObject will be removed by ptrSPITPlayer.endPlaySequence()
// ptrPlaySPITType->setIsPlayed(false); playType->setIsPlayed(false);
// continue; continue;
// } }
// mCallbacks.onPlaySpitType(ptrPlaySPITType->getPlayerID(), ptrPlaySPITType->getSPITTypeID(), ptrPlaySPITType->getPlayerIsRunning(), boolStarted, boolStopped, ptrPlaySPITType->getValue()); mCallbacks.onPlaySpitType(playType->getPlayerID(), playType->getSPITTypeID(), playType->getPlayerIsRunning(), isStarted, iStopped, playType->getValue());
// } }
// ptrSPITPlayer.endPlaySequence(); ptrSPITPlayer.endPlaySequence();
// } }
// void SProcessor::parseReportPlayStatus(Message::ReportPlayStatus &message) { void SProcessor::parseReportPlayStatus(Message::ReportPlayStatus &message) {
// SType *ptrSPITType = NULL; SType *sType = NULL;
// SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID()); SObject *sObject = mRemoteSpitObjects.getEntry(message.getID());
// if (ptrSPITObject == nullptr) { if (sObject == nullptr) {
// ptrSPITObject = mSpitObjects.getEntry(message.getID()); sObject = mSpitObjects.getEntry(message.getID());
// if (ptrSPITObject == nullptr) { if (sObject == nullptr) {
// return; return;
// } }
// } }
// if (ptrSPITObject->ServerRemote.get() == false) { if (sObject->ServerRemote.get() == false) {
// ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get()); sType = mSpitTypes.getEntry(sObject->SPITTypeID.get());
// } else { } else {
// ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get()); sType = mRemoteSpitTypes.getEntry(sObject->SPITTypeID.get());
// } }
// if (ptrSPITType == nullptr) { if (sType == nullptr) {
// return; return;
// } }
// mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, message.getFrameInsideObject(), message.getValue()); mCallbacks.onPlayRemoteObjectStatus(*sType, *sObject, message.getFrameInsideObject(), message.getValue());
// } }
// //--------- Remote ---------- // //--------- Remote ----------
@@ -1215,7 +1141,7 @@ void SProcessor::parseReportType(Message::ReportType &message) {
// Message::PlayStart playSPITStart(mGuid, mProjName, PLAYERTYPE_DISCRETE); // Message::PlayStart playSPITStart(mGuid, mProjName, PLAYERTYPE_DISCRETE);
// playSPITStart.setPlayerIsRunning(false); // playSPITStart.setPlayerIsRunning(false);
// playSPITStart.setTime(0); // playSPITStart.setTime(0);
// // sendSPITMessage(playSPITStart); // // mInternCallbacks.sendMessage(playSPITStart);
// Message::PlayObject playSPITObject; // Message::PlayObject playSPITObject;
// playSPITObject.setID(ptrRemoteSPITObject->getID()); // playSPITObject.setID(ptrRemoteSPITObject->getID());
@@ -1223,10 +1149,10 @@ void SProcessor::parseReportType(Message::ReportType &message) {
// playSPITObject.setPlayerID(mGuid); // playSPITObject.setPlayerID(mGuid);
// playSPITObject.setValue(valuePpm); // playSPITObject.setValue(valuePpm);
// playSPITObject.setValueFlag(valueFlag); // playSPITObject.setValueFlag(valueFlag);
// // sendSPITMessage(playSPITObject); // // mInternCallbacks.sendMessage(playSPITObject);
// Message::PlayEnd playSPITEnd(mGuid); // Message::PlayEnd playSPITEnd(mGuid);
// // sendSPITMessage(playSPITEnd); // // mInternCallbacks.sendMessage(playSPITEnd);
// } // }
} // namespace spit } // namespace spit
components/spit/uTest/spitProcessorTest.cpp
+7 -1
View File
@@ -58,7 +58,13 @@ class SpitClientFix {
.onPlayRemoteObjectStatus = [&](const SType &t, const SObject &o, uint64_t p_FrameInsideObject, int value) { client.onPlayRemoteObjectStatus(t, o, p_FrameInsideObject, value); }, .onPlayRemoteObjectStatus = [&](const SType &t, const SObject &o, uint64_t p_FrameInsideObject, int value) { client.onPlayRemoteObjectStatus(t, o, p_FrameInsideObject, value); },
.onCheckSpitTypeVeto = [&](bool knownType, bool createdByClient) { return client.onCheckSpitTypeVeto(knownType, createdByClient); }, .onCheckSpitTypeVeto = [&](bool knownType, bool createdByClient) { return client.onCheckSpitTypeVeto(knownType, createdByClient); },
.onCheckSpitObjectVeto = [&](bool knownType) { return client.onCheckSpitObjectVeto(knownType); }}; .onCheckSpitObjectVeto = [&](bool knownType) { return client.onCheckSpitObjectVeto(knownType); }};
SProcessor sut{"sut", "sutProj", "dev", "##GUID##", callbacks}; SProcessor::InternalCallbacks intCallbacks {
.delay = [&](int ms){ return ; },
.sendMessage = [&](Message::OPPart &msg){ return 0; },
.sendTypeInternal = [&](SType &sType) { return 0; },
.sendObjectInternal = [&](SObject *sObject) { return 0; }
};
SProcessor sut{"sut", "sutProj", "dev", "##GUID##", callbacks, intCallbacks};
}; };
TEST_CASE_FIXTURE(SpitClientFix, "Spit types") { TEST_CASE_FIXTURE(SpitClientFix, "Spit types") {
components/spit/uTest/spitProcessor_complexTest.cpp
+7 -1
View File
@@ -58,7 +58,13 @@ class SpitClientCmplsFix {
.onPlayRemoteObjectStatus = [&](const SType &t, const SObject &o, uint64_t p_FrameInsideObject, int value) { client.onPlayRemoteObjectStatus(t, o, p_FrameInsideObject, value); }, .onPlayRemoteObjectStatus = [&](const SType &t, const SObject &o, uint64_t p_FrameInsideObject, int value) { client.onPlayRemoteObjectStatus(t, o, p_FrameInsideObject, value); },
.onCheckSpitTypeVeto = [&](bool knownType, bool createdByClient) { return client.onCheckSpitTypeVeto(knownType, createdByClient); }, .onCheckSpitTypeVeto = [&](bool knownType, bool createdByClient) { return client.onCheckSpitTypeVeto(knownType, createdByClient); },
.onCheckSpitObjectVeto = [&](bool knownType) { return client.onCheckSpitObjectVeto(knownType); }}; .onCheckSpitObjectVeto = [&](bool knownType) { return client.onCheckSpitObjectVeto(knownType); }};
SProcessor sut{"sut", "sutProj", "dev", "##GUID##", callbacks}; SProcessor::InternalCallbacks intCallbacks {
.delay = [&](int ms){ return ; },
.sendMessage = [&](Message::OPPart &msg){ return 0; },
.sendTypeInternal = [&](SType &sType) { return 0; },
.sendObjectInternal = [&](SObject *sObject) { return 0; }
};
SProcessor sut{"sut", "sutProj", "dev", "##GUID##", callbacks, intCallbacks};
}; };
static void spoofMsgCounter(std::vector<uint8_t> &msg, uint8_t cnt) { static void spoofMsgCounter(std::vector<uint8_t> &msg, uint8_t cnt) {