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

refactor: Tidy up SPIT 2

Browse Source
This commit is contained in:
Gustice
2025-11-15 22:04:54 +01:00
parent 4a97988227
commit 118291f8ab
10 changed files with 165 additions and 462 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/spit_client.hpp
+1 -2
View File
@@ -46,7 +46,6 @@ class SClient : ISadClient {
uint8_t mMessageNumberSend{1};
int mMessageNumberReceived{-1}; // set to -1 because the first received message will set the number (1..255)
vector<unique_ptr<Message>> mOvertakingMessages;
// Server's info filled by parseConnectAnswer
string mServerID{};
@@ -137,7 +136,7 @@ class SClient : ISadClient {
private:
void disconnectInternal(Connection cause);
void resetMessageNumberReceived();
void parseMessage(unique_ptr<Message> message);
void parseMessage(Message& message);
void checkParseMessage(unique_ptr<Message> message);
void addOvertakingMessage(unique_ptr<Message> message);
void parseConnectAnswer(Message::ConnectAnswer &message);
components/spit/include/spit_processor.hpp
+21 -47
View File
@@ -56,6 +56,7 @@ class SProcessor {
struct InternalCallbacks {
function<void(int ms)> delay;
function<int(Message::OPPart &msg)> sendMessage;
function<void(Message &msg)> parseMessage;
};
static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
@@ -75,19 +76,11 @@ class SProcessor {
string mProjName;
string mComputerName;
// string mClientProjectName;
uint8_t mMessageNumberSend{1};
int mMessageNumberReceived{-1}; // set to -1 because the first received message will set the number (1..255)
vector<unique_ptr<Message>> mOvertakingMessages;
// // Server's info filled by parseConnectAnswer
string mServerID{};
// string mServerName{};
// string mServerComputerName{};
// int mServerStepTime{-1};
// //--- Server Project ---
string mServerProjectID;
string mServerProjectName;
int mServerFramesPerSecond;
@@ -100,25 +93,19 @@ class SProcessor {
void setActionType(string spitypeID, bool actionAssigned);
void setActionObject(string objectID, bool actionAssigned);
void checkParseMessageData(vector<char> data);
unique_ptr<Message::Connect> createConnectMessage(string serverIP, string serverPort, string loginName, string loginPassword);
std::vector<char> createMessage(Message::OPPart &spitMessageOPPart);
void parseMessage(Message &message);
void addOvertakingMessage(unique_ptr<Message> message);
void parseReportProject(Message::ReportProject &message);
void parseCloseProject(Message::CloseProject &message);
int sendOvertakingMessage(int msgNumRec);
void resetMessageNumberReceived();
string getServerProjectID() { return mServerProjectID; }
string getServerProjectName() { return mServerProjectName; }
int getServerFramesPerSecond() { return mServerFramesPerSecond; }
void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
void parseStartProjectTransfer(Message::StartProjectTransfer &message);
void parseEndProjectTransfer(Message::EndProjectTransfer &message);
// // --------------- SPIT Types ---------------
// public:
// /**
// * Creates a SPITType for application actions.<br>
// * These SPITTypes will be automatically added to the SPITType-List and sended to the server.
@@ -134,12 +121,6 @@ class SProcessor {
SType *createType(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration, bool fixed, bool projectIndepended);
int sendTypeInternal(SType &sType);
private:
public: // @todo delete
void parseReportType(Message::ReportType &message);
void parseRemoveType(Message::RemoveType &message);
public:
/**
* 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>
@@ -155,37 +136,30 @@ class SProcessor {
*/
int removeType(string spitypeID);
// public:
// //--------------- SPIT Objects ---------------
// private:
public:
void parseReportObject(Message::ReportObject &message);
void parseRemoveObject(Message::RemoveObject &message);
int sendObjectInternal(SObject *sObject);
// public:
int removeObject(string objectID);
bool changeObject(SObject *sObject);
// public:
// //--------------- Play SPIT Objects ---------------
// private:
public:
void parsePlayStart(Message::PlayStart &message);
void parsePlayObject(Message::PlayObject &message);
void parsePlayEnd(Message::PlayEnd &message);
void parseReportPlayStatus(Message::ReportPlayStatus &message);
// public:
// //--------- Remote ----------
void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00);
void resetConfirmedFlags() {
SType::setConfirmedFalse(mSpitTypes);
SObject::setConfirmedFalse(mSpitObjects);
}
private:
void parseReportProject(Message::ReportProject &message);
void parseCloseProject(Message::CloseProject &message);
void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
void parseStartProjectTransfer(Message::StartProjectTransfer &message);
void parseEndProjectTransfer(Message::EndProjectTransfer &message);
void parseReportType(Message::ReportType &message);
void parseRemoveType(Message::RemoveType &message);
void parseReportObject(Message::ReportObject &message);
void parseRemoveObject(Message::RemoveObject &message);
void parsePlayStart(Message::PlayStart &message);
void parsePlayObject(Message::PlayObject &message);
void parsePlayEnd(Message::PlayEnd &message);
void parseReportPlayStatus(Message::ReportPlayStatus &message);
int sendObjectInternal(SObject *sObject);
SpitRepo<SObject> mSpitObjects;
SpitRepo<SType> mSpitTypes;
SpitRepo<SObject> mRemoteSpitObjects;
components/spit/src/spit_client.cpp
+18 -105
View File
@@ -20,6 +20,7 @@ SClient::SClient(string name, string projName, ISocket &socket, Callbacks calls)
{
.delay = [&](int ms){ return fos::Task::delayMs(ms); },
.sendMessage = [&](Message::OPPart &msg){ return sendMessage(msg); },
.parseMessage = [&](Message& msg) { parseMessage(msg); }
}
),
mSocket(socket) {
@@ -226,14 +227,14 @@ void SClient::processSpitMessage(SClient &rM) {
while (true) {
auto data = *incommingSpit.dequeue();
auto spitMsg = make_unique<Message>(data);
rM.parseMessage(move(spitMsg));
rM.checkParseMessage(move(spitMsg));
}
}
void SClient::resetMessageNumberReceived() {
mMessageNumberReceived = -1;
mOvertakingMessages.clear();
mProcessor.resetMessageNumberReceived();
}
void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
@@ -246,12 +247,12 @@ void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
int msgNum = (int)(p_SPITMessage->getHeader()->getMessageNumber() & 0xFF);
if (msgNum == 0) {
parseMessage(std::move(p_SPITMessage));
parseMessage(*p_SPITMessage);
return;
}
if (mMessageNumberReceived < 0) {
mMessageNumberReceived = msgNum;
parseMessage(std::move(p_SPITMessage));
parseMessage(*p_SPITMessage);
return;
}
@@ -261,122 +262,39 @@ void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
if (msgNum == intNextMessageNumber) {
mMessageNumberReceived = msgNum;
parseMessage(std::move(p_SPITMessage));
// check overtaking messages
auto it = mOvertakingMessages.begin();
while (mOvertakingMessages.size() > 0) {
intNextMessageNumber = mMessageNumberReceived + 1;
if (intNextMessageNumber > 255 || intNextMessageNumber < 1)
intNextMessageNumber = 1;
auto &ptrOvertakingSPIT_Message = *it;
msgNum = (int)(ptrOvertakingSPIT_Message->getHeader()->getMessageNumber() & 0xFF);
if (msgNum == intNextMessageNumber) {
mMessageNumberReceived = msgNum;
parseMessage(move(ptrOvertakingSPIT_Message));
mOvertakingMessages.erase(it);
it = mOvertakingMessages.begin();
} else {
break;
}
}
parseMessage(*p_SPITMessage);
mMessageNumberReceived = mProcessor.sendOvertakingMessage(mMessageNumberReceived);
} else {
// p_SPITMessage has overtaken another message
addOvertakingMessage(move(p_SPITMessage));
mProcessor.addOvertakingMessage(move(p_SPITMessage));
}
}
void SClient::addOvertakingMessage(unique_ptr<Message> message) {
if (!message) {
return;
}
if (mOvertakingMessages.size() > mProcessor.MAX_OVERTAKING_SPIT_MESSAGES) {
ESP_LOGD(TAG, "Client receiveing: perhaps message lost !!!!!");
}
int intMessageNumber = (int)(message->getHeader()->getMessageNumber() & 0xFF);
for (auto it = mOvertakingMessages.begin(); it != mOvertakingMessages.end(); ++it) {
const auto &overtaking = *it;
int intOvertakingMessageNumber = (int)(overtaking->getHeader()->getMessageNumber() & 0xFF);
if (intMessageNumber < intOvertakingMessageNumber) {
mOvertakingMessages.insert(it, move(message));
return;
}
}
mOvertakingMessages.push_back(move(message));
}
void SClient::parseMessage(unique_ptr<Message> message) {
void SClient::parseMessage(Message& message) {
answerWatchdog();
if (!message || !message->getHeader() || !message->getOPPart()) {
if (!message.getHeader() || !message.getOPPart()) {
ESP_LOGD(TAG, "Client::parseMessage incomplete message");
return;
}
switch (message->getType()) {
switch (message.getType()) {
//----- Connection -----
case Message::ConnectAnswer::OPFLAG:
parseConnectAnswer(message->getAs<Message::ConnectAnswer>());
parseConnectAnswer(message.getAs<Message::ConnectAnswer>());
break;
case Message::Disconnect::OPFLAG:
parseDisconnect(message->getAs<Message::Disconnect>());
break;
case Message::ReportProject::OPFLAG:
mProcessor.parseReportProject(message->getAs<Message::ReportProject>());
parseDisconnect(message.getAs<Message::Disconnect>());
break;
case Message::Watchdog::OPFLAG:
parseWatchdog(message->getAs<Message::Watchdog>());
parseWatchdog(message.getAs<Message::Watchdog>());
break;
case Message::WatchdogAnswer::OPFLAG:
parseWatchdogAnswer(message->getAs<Message::WatchdogAnswer>());
break;
//----- SPIT Project -----
case Message::StartProjectTransfer::OPFLAG:
mProcessor.parseStartProjectTransfer(message->getAs<Message::StartProjectTransfer>());
break;
case Message::CloseProject::OPFLAG:
mProcessor.parseCloseProject(message->getAs<Message::CloseProject>());
break;
case Message::RequestProjectTransfer::OPFLAG:
mProcessor.parseRequestProjectTransfer(message->getAs<Message::RequestProjectTransfer>());
break;
case Message::EndProjectTransfer::OPFLAG:
mProcessor.parseEndProjectTransfer(message->getAs<Message::EndProjectTransfer>());
break;
//----- SPIT Types ------
case Message::ReportType::OPFLAG:
mProcessor.parseReportType(message->getAs<Message::ReportType>());
break;
case Message::RemoveType::OPFLAG:
mProcessor. parseRemoveType(message->getAs<Message::RemoveType>());
//----- SPIT Objects ------
break;
case Message::ReportObject::OPFLAG:
mProcessor.parseReportObject(message->getAs<Message::ReportObject>());
break;
case Message::RemoveObject::OPFLAG:
mProcessor.parseRemoveObject(message->getAs<Message::RemoveObject>());
break;
//----- Play SPIT Objects ------
case Message::PlayStart::OPFLAG:
mProcessor.parsePlayStart(message->getAs<Message::PlayStart>());
break;
case Message::PlayObject::OPFLAG:
mProcessor.parsePlayObject(message->getAs<Message::PlayObject>());
break;
case Message::PlayEnd::OPFLAG:
mProcessor.parsePlayEnd(message->getAs<Message::PlayEnd>());
break;
case Message::ReportPlayStatus::OPFLAG:
mProcessor.parseReportPlayStatus(message->getAs<Message::ReportPlayStatus>());
parseWatchdogAnswer(message.getAs<Message::WatchdogAnswer>());
break;
default:
ESP_LOGD(TAG, "Client::parseMessage: Unknown Message");
// pass object to SubProcessor
mProcessor.parseMessage(message);
}
}
@@ -491,7 +409,6 @@ void SClient::parseConnectAnswer(Message::ConnectAnswer &message) {
if (message.getConnected() == false) {
disconnectInternal(Connection::NoneServer);
} else {
message.getStepTime();
mConnectionStatus = Connection::Ok;
mDisconnectedByServer = false;
ESP_LOGD(TAG, "connection established");
@@ -511,10 +428,7 @@ void SClient::parseConnectAnswer(Message::ConnectAnswer &message) {
*/
void SClient::parseDisconnect(Message::Disconnect &message) {
Connection intCauseDisconnect = Connection::NoneServer;
/*
function<void()> o_Callable = bind(&SClient::disconnectInternal, this, intCauseDisconnect);
SPIT_Handler::addCallable(o_Callable);
*/
mDisconnectedByServer = true;
SClient::disconnectInternal(intCauseDisconnect);
}
@@ -527,7 +441,6 @@ void SClient::parseDisconnect(Message::Disconnect &message) {
* @param message
*/
void SClient::parseWatchdog(Message::Watchdog &message) {
// ESP_LOGD(TAG, "parse Watchdog ");
Message::WatchdogAnswer o_WatchdogAnswer;
sendMessage(o_WatchdogAnswer);
}
components/spit/src/spit_processor.cpp
+125 -308
View File
@@ -12,7 +12,7 @@ static const char *TAG = "SPIT";
SProcessor::SProcessor(string name, string projName, string hostName, string guid, Callbacks calls, InternalCallbacks intern)
: mCallbacks(calls),
mInternCallbacks(intern),
mName(name),
mName(name),
mGuid(guid),
mProjName(projName),
mComputerName(hostName) {
@@ -84,29 +84,11 @@ std::vector<char> SProcessor::createMessage(Message::OPPart &opPart) {
}
return {};
}
// todo Delete SProcessor::mInternCallbacks.sendMessage(Message::OPPart &opPart
// // void SProcessor::receiveSPITMessage(SClient &rM) {
// // char buffer[MAXSPITMESSAGEBYTECOUNT + 1];
// // int rdLen;
// // while (rM.mStopReceiveMessages == false) {
// // rdLen = rM.mSocket.receiveMessage(buffer, MAXSPITMESSAGEBYTECOUNT, nullptr);
// // if (rdLen < 0) {
// // if (rM.mStopReceiveMessages) {
// // return;
// // }
// // continue;
// // }
// // auto vec = vector<char>(buffer, buffer + rdLen);
// // rM.checkParseMessageData(move(spitMsg));
// // // rM.checkParseMessage(move(spitMsg));
// // }
// // }
// void SProcessor::resetMessageNumberReceived() {
// mMessageNumberReceived = -1;
// mOvertakingMessages.clear();
// }
void SProcessor::resetMessageNumberReceived() {
mMessageNumberReceived = -1;
mOvertakingMessages.clear();
}
void SProcessor::checkParseMessageData(vector<char> data) {
auto message = make_unique<Message>(data);
@@ -136,28 +118,7 @@ void SProcessor::checkParseMessageData(vector<char> data) {
mMessageNumberReceived = msgNum;
parseMessage(*message);
// check overtaking messages
auto it = mOvertakingMessages.begin();
while (mOvertakingMessages.size() > 0) {
msgNumNext = mMessageNumberReceived + 1;
if (msgNumNext > 255 || msgNumNext < 1)
msgNumNext = 1;
auto &overtakingMessage = *it;
msgNum = (int)(overtakingMessage->getHeader()->getMessageNumber() & 0xFF);
if (msgNum == msgNumNext) {
mMessageNumberReceived = msgNum;
parseMessage(*overtakingMessage);
mOvertakingMessages.erase(it);
it = mOvertakingMessages.begin();
} else {
break;
}
}
mMessageNumberReceived = sendOvertakingMessage(mMessageNumberReceived);
} else {
// message has overtaken another message
addOvertakingMessage(move(message));
@@ -184,6 +145,30 @@ void SProcessor::addOvertakingMessage(unique_ptr<Message> message) {
mOvertakingMessages.push_back(move(message));
}
int SProcessor::sendOvertakingMessage(int msgNumRec) {
// check overtaking messages
auto it = mOvertakingMessages.begin();
while (mOvertakingMessages.size() > 0) {
int msgNumNext = msgNumRec + 1;
if (msgNumNext > 255 || msgNumNext < 1)
msgNumNext = 1;
auto &overtakingMessage = *it;
int msgNum = (int)(overtakingMessage->getHeader()->getMessageNumber() & 0xFF);
if (msgNum == msgNumNext) {
msgNumRec = msgNum;
mInternCallbacks.parseMessage(*overtakingMessage);
mOvertakingMessages.erase(it);
it = mOvertakingMessages.begin();
} else {
break;
}
}
return msgNumRec;
}
void SProcessor::parseMessage(Message &message) {
// answerWatchdog();
if (!message.getHeader() || !message.getOPPart()) {
@@ -193,21 +178,9 @@ void SProcessor::parseMessage(Message &message) {
switch (message.getType()) {
//----- Connection -----
case Message::ConnectAnswer::OPFLAG:
// parseConnectAnswer(message.getAs<Message::ConnectAnswer>());
break;
case Message::Disconnect::OPFLAG:
// parseDisconnect(message.getAs<Message::Disconnect>());
break;
case Message::ReportProject::OPFLAG:
parseReportProject(message.getAs<Message::ReportProject>());
break;
case Message::Watchdog::OPFLAG:
// parseWatchdog(message.getAs<Message::Watchdog>());
break;
case Message::WatchdogAnswer::OPFLAG:
// parseWatchdogAnswer(message.getAs<Message::WatchdogAnswer>());
break;
//----- SPIT Project -----
case Message::StartProjectTransfer::OPFLAG:
parseStartProjectTransfer(message.getAs<Message::StartProjectTransfer>());
@@ -253,83 +226,6 @@ void SProcessor::parseMessage(Message &message) {
}
}
// void SProcessor::parseConnectAnswer(Message::ConnectAnswer &message) {
// if (message.getClientID() != mGuid)
// return;
// mServerID = message.getServerID();
// mServerComputerName = message.getServerComputerName();
// mServerName = message.getServerName();
// mServerStepTime = message.getStepTime();
// if (message.getConnected() == false) {
// disconnectInternal(Connection::NoneServer);
// } else {
// message.getStepTime();
// mConnectionStatus = Connection::Ok;
// mDisconnectedByServer = false;
// ESP_LOGD(TAG, "connection established");
// stopServerAutoDetect(); // normally you should stop the autodetection before you try a connection
// // This is redundand
// // mStopReceiveMessages = false;
// // Maybe you want to reconnect, see eventServerDetected(...)
// // Here the connection is established -> don't reconnect at eventServerDetected(...)
// // _doReconnect = false;
// }
// }
// /**
// * The SPIT server was closed
// * @param message
// */
// void SProcessor::parseDisconnect(Message::Disconnect &message) {
// Connection intCauseDisconnect = Connection::NoneServer;
// /*
// function<void()> o_Callable = bind(&SProcessor::disconnectInternal, this, intCauseDisconnect);
// SPIT_Handler::addCallable(o_Callable);
// */
// mDisconnectedByServer = true;
// SProcessor::disconnectInternal(intCauseDisconnect);
// }
// //----- Watchdog ------
// /**
// * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
// * Conversely, the client also sends a watchdog message at regular intervals and waits for a WatchdogAnswer message.
// * This is used to check if the other side is still present.
// * @param message
// */
// void SProcessor::parseWatchdog(Message::Watchdog &message) {
// // ESP_LOGD(TAG, "parse Watchdog ");
// Message::WatchdogAnswer o_WatchdogAnswer;
// // mInternCallbacks.sendMessage(o_WatchdogAnswer);
// }
// /**
// * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
// * Conversely, the client also sends a watchdog message at regular intervals and waits for a WatchdogAnswer message.
// * This is used to check if the other side is still present.
// * @param message
// */
// void SProcessor::parseWatchdogAnswer(Message::WatchdogAnswer &message) {
// answerWatchdog(); // is also done by parseMessage
// }
// void SProcessor::sendWatchdog() {
// int intResult{};
// Message::Watchdog message;
// // intResult = mInternCallbacks.sendMessage(message);
// if (intResult < 0) {
// ESP_LOGW("WDT", "Failed to send Watchdog msg");
// }
// }
// void SProcessor::eventWatchdogLost() {
// if (mConnectionStatus == Connection::TryConnection) {
// disconnectInternal(Connection::NoneServer);
// } else {
// disconnectInternal(Connection::Lost);
// }
// }
//----- SPIT Project ------
void SProcessor::parseReportProject(Message::ReportProject &message) {
ESP_LOGD(TAG, "parse ReportProject");
@@ -387,70 +283,6 @@ void SProcessor::parseRequestProjectTransfer(Message::RequestProjectTransfer &me
mInternCallbacks.sendMessage(sMEndProjectTransfer);
}
// /* NEW IMPLEMENTATION
// void SProcessor::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 = mInternCallbacks.sendMessage(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 = sendTypeInternal(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 = mInternCallbacks.sendMessage(ptrSMEndProjectTransfer);
// // if (intResult < 0) {
// // return;
// // }
// // mWatchdog->answerWatchdog();
// // NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(mSPITClientInterface);
// // SPIT_Handler::addRunnable(o_RunnableEnd);
// // //Send act
// }
// */
void SProcessor::parseStartProjectTransfer(Message::StartProjectTransfer &message) {
mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID);
}
@@ -472,48 +304,46 @@ void SProcessor::parseReportType(Message::ReportType &message) {
SType *sType;
bool isNew = false;
bool isChanged = false;
{
if (message.getServerRemote() == false) {
sType = mSpitTypes.getEntry(message.getID());
if (sType == nullptr) {
// The user's app may veto the SPITType
bool createdByClient = false;
if (sType) {
createdByClient = sType->getCreatedByClient();
}
if (message.getServerRemote() == false) {
sType = mSpitTypes.getEntry(message.getID());
if (sType == nullptr) {
// The user's app may veto the SPITType
bool createdByClient = false;
if (sType) {
createdByClient = sType->getCreatedByClient();
}
if (mCallbacks.onCheckSpitTypeVeto(false, createdByClient) == false) {
ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
return;
}
auto spitType = make_unique<SType>(message.getID());
sType = spitType.get();
mSpitTypes.addEntry(move(spitType));
isNew = true;
}
} else {
sType = mRemoteSpitTypes.getEntry(message.getID());
if (sType == nullptr) {
auto spitType = make_unique<SType>(message.getID());
sType = spitType.get();
mRemoteSpitTypes.addEntry(move(spitType));
isNew = true;
if (mCallbacks.onCheckSpitTypeVeto(false, createdByClient) == false) {
ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
return;
}
auto spitType = make_unique<SType>(message.getID());
sType = spitType.get();
mSpitTypes.addEntry(move(spitType));
isNew = true;
}
if (!sType->setMessageOP(message)) {
// SPITType is not changable -> send back to the server
} else {
sType = mRemoteSpitTypes.getEntry(message.getID());
if (sType == nullptr) {
auto spitType = make_unique<SType>(message.getID());
sType = spitType.get();
mRemoteSpitTypes.addEntry(move(spitType));
isNew = true;
}
}
if (!sType->setMessageOP(message)) {
// SPITType is not changable -> send back to the server
sendTypeInternal(*sType);
return;
}
auto eventType = isNew ? ObjectEvent::Created : ObjectEvent::Changed;
// add or change SPITType
mCallbacks.onSpitType(eventType, sType->ServerRemote.get(), *sType);
if (sType != nullptr) {
if (sType->setConfirmed(true) == true || isChanged == true) {
sendTypeInternal(*sType);
return;
}
auto eventType = isNew ? ObjectEvent::Created : ObjectEvent::Changed;
// add or change SPITType
mCallbacks.onSpitType(eventType, sType->ServerRemote.get(), *sType);
if (sType != nullptr) {
if (sType->setConfirmed(true) == true || isChanged == true) {
sendTypeInternal(*sType);
}
}
}
}
@@ -555,23 +385,22 @@ void SProcessor::parseRemoveType(Message::RemoveType &message) {
* @param p_SPITType the SPITType vont
* @return true = changed, false = not changed maybe p_SPITType is NULL or the SPITType doesn't exists
*/
bool SProcessor::changeType(SType *p_SPITType) {
if (p_SPITType == nullptr)
bool SProcessor::changeType(SType *sType) {
if (sType == nullptr)
return false;
SType *ptrSPITType = mSpitTypes.getEntry(p_SPITType->getID());
if (ptrSPITType == nullptr)
SType *mod = mSpitTypes.getEntry(sType->getID());
if (mod == 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);
sendTypeInternal(*ptrSPITType);
mod->DefaultDelay.set(sType->DefaultDelay.get());
mod->DefaultDuration.set(sType->DefaultDuration.get());
mod->Fixed.set(sType->Fixed.get());
mod->GroupName.set(sType->GroupName.get());
mod->Name.set(sType->Name.get());
mod->ProjectIndepended.set(sType->ProjectIndepended.get());
mCallbacks.onSpitType(ObjectEvent::Changed, false, *mod);
sendTypeInternal(*mod);
return true;
}
@@ -584,21 +413,17 @@ bool SProcessor::changeType(SType *p_SPITType) {
* @param p_SPITType the id of the SPITType ro remove
* @return 0 = is sended, -1 = is not sended
*/
int SProcessor::removeType(string p_SPITTypeID) {
if (p_SPITTypeID.length() <= 0)
int SProcessor::removeType(string sType) {
if (sType.length() <= 0)
return -1;
SType *ptrSPITType;
{
ptrSPITType = mSpitTypes.getEntry(p_SPITTypeID);
if (ptrSPITType == nullptr)
return -1;
Message::RemoveType sMRemoveSPITType;
ptrSPITType->fillMessageOP(sMRemoveSPITType);
mCallbacks.onSpitType(ObjectEvent::Deleted, false, *ptrSPITType);
mSpitTypes.removeEntry(*ptrSPITType);
return mInternCallbacks.sendMessage(sMRemoveSPITType);
}
return -1;
SType *mod = mSpitTypes.getEntry(sType);
if (mod == nullptr)
return -1;
Message::RemoveType sMRemoveSPITType;
mod->fillMessageOP(sMRemoveSPITType);
mCallbacks.onSpitType(ObjectEvent::Deleted, false, *mod);
mSpitTypes.removeEntry(*mod);
return mInternCallbacks.sendMessage(sMRemoveSPITType);
}
SType *SProcessor::createType(string id, string groupName, string name, uint64_t delay, uint64_t duration, bool fixed, bool projIndipendent) {
@@ -750,38 +575,34 @@ int SProcessor::sendObjectInternal(SObject *sObject) {
* @param obj the pointer to the changed SPITObject.
* @return 0 = sended, -1 = not sended
*/
bool SProcessor::changeObject(SObject *obj) {
if (obj == nullptr)
bool SProcessor::changeObject(SObject *sObject) {
if (sObject == nullptr)
return false;
SObject *mod = mSpitObjects.getEntry(sObject->getID());
if (mod == nullptr)
return false;
SType *sType = mSpitTypes.getEntry(sObject->getID());
if (mod == nullptr)
return false;
SObject *sObject;
SType *sType;
{
sObject = mSpitObjects.getEntry(obj->getID());
if (sObject == nullptr)
return false;
sType = mSpitTypes.getEntry(obj->getID());
if (sObject == nullptr)
return false;
sObject->setActionAssigned(obj->getActionAssigned());
sObject->Delay.set(obj->Delay.get());
sObject->Duration.set(obj->Delay.get());
sObject->Fixed.set(obj->Fixed.get());
sObject->FrameFadeInLength.set(obj->FrameFadeInLength.get());
sObject->FrameFadeOutLength.set(obj->FrameFadeOutLength.get());
sObject->FrameLength.set(obj->FrameLength.get());
sObject->FrameStart.set(obj->FrameStart.get());
sObject->Name.set(obj->Name.get());
sObject->Remark.set(obj->Remark.get());
sObject->SPITTypeID.set(obj->SPITTypeID.get());
sObject->ServerParams.set(obj->ServerParams.get());
sObject->Track.set(obj->Track.get());
sObject->ValueFactor.set(obj->ValueFactor.get());
sObject->ValueUse.set(obj->ValueUse.get());
mod->setActionAssigned(sObject->getActionAssigned());
mod->Delay.set(sObject->Delay.get());
mod->Duration.set(sObject->Delay.get());
mod->Fixed.set(sObject->Fixed.get());
mod->FrameFadeInLength.set(sObject->FrameFadeInLength.get());
mod->FrameFadeOutLength.set(sObject->FrameFadeOutLength.get());
mod->FrameLength.set(sObject->FrameLength.get());
mod->FrameStart.set(sObject->FrameStart.get());
mod->Name.set(sObject->Name.get());
mod->Remark.set(sObject->Remark.get());
mod->SPITTypeID.set(sObject->SPITTypeID.get());
mod->ServerParams.set(sObject->ServerParams.get());
mod->Track.set(sObject->Track.get());
mod->ValueFactor.set(sObject->ValueFactor.get());
mod->ValueUse.set(sObject->ValueUse.get());
mCallbacks.onSpitObject(ObjectEvent::Changed, false, *sType, *sObject);
sendObjectInternal(sObject);
}
mCallbacks.onSpitObject(ObjectEvent::Changed, false, *sType, *mod);
sendObjectInternal(mod);
return true;
}
@@ -797,23 +618,19 @@ bool SProcessor::changeObject(SObject *obj) {
int SProcessor::removeObject(string objId) {
if (objId.length() <= 0)
return -1;
SType *sType;
SObject *sObject;
{
Message::RemoveObject remObj;
Message::RemoveObject remObj;
sObject = mSpitObjects.getEntry(objId);
if (sObject == nullptr)
return -1;
sType = mSpitTypes.getEntry(sObject->SPITTypeID.get());
if (sType == nullptr)
return -1;
sObject->fillMessageOP(remObj);
mCallbacks.onSpitObject(ObjectEvent::Deleted, false, *sType, *sObject);
mSpitObjects.removeEntry(*sObject);
mInternCallbacks.sendMessage(remObj);
}
return -1;
SObject *sObject = mSpitObjects.getEntry(objId);
if (sObject == nullptr)
return -1;
SType *sType = mSpitTypes.getEntry(sObject->SPITTypeID.get());
if (sType == nullptr)
return -1;
sObject->fillMessageOP(remObj);
mCallbacks.onSpitObject(ObjectEvent::Deleted, false, *sType, *sObject);
mSpitObjects.removeEntry(*sObject);
return mInternCallbacks.sendMessage(remObj);
}
// //----- Play SPIT Objects ------