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

refactor: Tidy up SPIT

Browse Source
This commit is contained in:
Gustice
2025-11-15 20:57:22 +01:00
parent 7aec14cbb9
commit 4a97988227
10 changed files with 828 additions and 1923 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/spit_client.hpp
+28 -127
View File
@@ -1,17 +1,16 @@
#pragma once #pragma once
#include "sad_DetectedServer.hpp" #include "sad_DetectedServer.hpp"
#include "spit_message.hpp"
#include "spit_object.hpp" #include "spit_object.hpp"
#include "spit_player.hpp" #include "spit_player.hpp"
#include "spit_processor.hpp" #include "spit_processor.hpp"
#include "spit_repo.hpp"
#include "spit_socket.hpp" #include "spit_socket.hpp"
#include "spit_type.hpp" #include "spit_type.hpp"
#include "spit_message.hpp" #include <functional>
#include "spit_repo.hpp"
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <functional>
#include "syslog.hpp"
using namespace std; using namespace std;
@@ -19,53 +18,28 @@ namespace spit {
class SClient : ISadClient { class SClient : ISadClient {
public: public:
/** Maximal length of a SPITMessage*/
static const int MAXSPITMESSAGEBYTECOUNT = 512;
using Callbacks = SProcessor::Callbacks; using Callbacks = SProcessor::Callbacks;
using ProjUpdate = SProcessor::ProjUpdate; using ProjUpdate = SProcessor::ProjUpdate;
using ServerEvent = SProcessor::ServerEvent; using ServerEvent = SProcessor::ServerEvent;
using ObjectEvent = SProcessor::ObjectEvent; using ObjectEvent = SProcessor::ObjectEvent;
using Connection = SProcessor::Connection; using Connection = SProcessor::Connection;
//------ PlayerType ------ using PlayerType = SPlayer::PTypes;
public: using ValueFlags = SPlayer::VFlags;
/** continous main player, time value can be used like a timecode.<br>The time value is the position in server's project.<br>A server should use only one main player.*/
static constexpr char PLAYERTYPE_MAIN = 0x02;
/** continous player. This player plays SPIT objects sometime during the project.*/
static constexpr char PLAYERTYPE_CONTINOUS = 0x01;
/** diescrete player. This player is used to transmit single discrete values.*/
static constexpr char PLAYERTYPE_DISCRETE = 0x00;
//------ Value Flag ------
//------ used by sendRemoteObject
public:
/**Set the given value directly*/
static constexpr char VALUEFLAG_DIRECT = 0x00;
/**Increase the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
static constexpr char VALUEFLAG_INCREASE = 0x01;
/**Decrease the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
static constexpr char VALUEFLAG_DECREASE = 0x02;
static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
//----- SClient -----
public:
SClient(string name, string projName, ISocket &socket, Callbacks calls); SClient(string name, string projName, ISocket &socket, Callbacks calls);
virtual ~SClient(); virtual ~SClient();
private: private:
Callbacks mCallbacks; Callbacks mCallbacks;
fos::TaskT<SClient &> *mThreadReceive{}; fos::TaskT<SClient &> *mThreadReceive{};
fos::TaskT<SClient &> *mThreadProcess{}; fos::TaskT<SClient &> *mThreadProcess{};
bool mStopReceiveMessages{}; bool mStopReceiveMessages{};
Connection mConnectionStatus{Connection::None}; Connection mConnectionStatus{Connection::None};
bool mDisconnectedByServer{}; // flag true = when server disconnects bool mDisconnectedByServer{}; // flag true = when server disconnects
string mID;
string mName;
string mProjName;
string mComputerName;
SProcessor mProcessor; SProcessor mProcessor;
string mClientProjectName; string mClientProjectName;
@@ -80,19 +54,13 @@ 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 mProcessor.getID(); }
/** The name of the client, should be set by the user app*/ /** The name of the client, should be set by the user app*/
string getName() { return mName; } string getName() { return mProcessor.getName(); }
//----- Computer Params -----
/** The name of the client's host computer*/ /** The name of the client's host computer*/
string getComputerName() { return mComputerName; } string getComputerName() { return mProcessor.getComputerName(); }
void setClientProjectName(string clientProjectName) { mClientProjectName = clientProjectName; } void setClientProjectName(string clientProjectName) { mClientProjectName = clientProjectName; }
string getClientProjectName() { return mClientProjectName; } string getClientProjectName() { return mClientProjectName; }
@@ -117,8 +85,12 @@ class SClient : ISadClient {
*/ */
void clientProjectLoaded(); void clientProjectLoaded();
void setActionSPITType(string spitypeID, bool actionAssigned); void setActionType(string spitypeID, bool actionAssigned) {
void setActionSPITObject(string objectID, bool actionAssigned); mProcessor.setActionType(spitypeID, actionAssigned);
}
void setActionObject(string objectID, bool actionAssigned) {
mProcessor.setActionObject(objectID, actionAssigned);
}
//--------------- SPITMessage --------------- //--------------- SPITMessage ---------------
private: private:
@@ -129,7 +101,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,22 +151,13 @@ 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() { return mProcessor.getServerProjectID(); }
/** Returns the SPITServer's project name*/ /** Returns the SPITServer's project name*/
string getServerProjectName(); string getServerProjectName() { return mProcessor.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() { return mProcessor.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);
@@ -214,76 +177,17 @@ class SClient : ISadClient {
*/ */
SType *createTypeFixed(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration); SType *createTypeFixed(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration);
/** public:
* Creates a SPITType for application actions.<br> bool changeType(SType *spitType) { return mProcessor.changeType(spitType); }
* These SPITTypes will be automatically added to the SPITType-List and sended to the server. int removeType(string spitypeID) { return mProcessor.removeType(spitypeID); }
* @param p_ID an unique of the SPITType, these are always the same per client approach. Different client approaches should use different ids.
* @param p_GroupName a name which groups the actions/SPITTypes
* @param p_Name the name of the Action/SPITType
* @param p_DefaultDelay maybe there is an default delay until the action starts, this is only used for graphical representations, 0 is allowd
* @param p_DefaultDuration maybe the action has a default duration, this is only used for graphical representations, 0 is allowd
* @param p_Fixed true = the server is not allowed to change this SPITType, false = the server may change or delete this SPITType
* @param p_ProjectIndepended true = the SPITType belongs to a specific project, false = the SpitType always exists for every project
* @return the pointer to the new SPITType.
*/
SType *createType(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration, bool fixed, bool projectIndepended);
private:
// receive SPIT-Types
void parseReportType(Message::ReportType &message);
void parseRemoveSPITType(Message::RemoveType &message);
int sendSPITTypeInternal(SType &spitType);
public: 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>
* @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 --------------- bool changeObject(SObject *sObject) { return mProcessor.changeObject(sObject); }
private: void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00) {
void parseReportSPITObject(Message::ReportObject &message); mProcessor.sendRemoteObject(objectID, valuePpm, valueFlag);
void parseRemoveSPITObject(Message::RemoveObject &message); }
int sendSPITObjectInternal(SObject *ptrObject);
public:
/**
* 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:
//--------------- 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:
//--------- Remote ----------
void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00);
private: private:
static void processSocketTask(SClient &instance); static void processSocketTask(SClient &instance);
@@ -295,9 +199,6 @@ class SClient : ISadClient {
void answerWatchdog() { void answerWatchdog() {
sAnswered = true; sAnswered = true;
} }
SpitRepo<SObject> mSpitObjects;
SpitRepo<SObject> mRemoteSpitObjects;
}; };
} } // namespace spit
components/spit/include/spit_message.hpp
+3
View File
@@ -14,6 +14,9 @@ namespace spit {
class Message { class Message {
//----------- Header ----------- //----------- Header -----------
public: public:
/** Maximal length of a SPITMessage*/
static const int MAX_MESSAGE_SIZE = 512;
class Header { class Header {
public: public:
static constexpr int BYTESLENGTH = 99; static constexpr int BYTESLENGTH = 99;
components/spit/include/spit_player.hpp
+19 -1
View File
@@ -9,6 +9,24 @@ class SPlayer {
//----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------ //----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
public: public:
enum PTypes {
// diescrete player: This player is used to transmit single discrete values.
PTYPE_DISCRETE = 0x00,
// continous player: This player plays SPIT objects sometime during the project.
PTYPE_CONTINOUS = 0x01,
// continous main player: time value can be used like a timecode.<br>The time value is the position in server's project.<br>A server should use only one main player.
PTYPE_MAIN = 0x02,
};
enum VFlags {
// Set the given value directly
VFLAG_DIRECT = 0x00,
// Increase the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
VFLAG_INCREASE = 0x01,
// Decrease the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
VFLAG_DECREASE = 0x02,
};
class PlayType { class PlayType {
public: public:
PlayType(SPlayer *spitPlayer, string spitObjectID); PlayType(SPlayer *spitPlayer, string spitObjectID);
@@ -77,4 +95,4 @@ class SPlayer {
uint64_t mTimeFrames; uint64_t mTimeFrames;
}; };
} } // namespace spit
components/spit/include/spit_processor.hpp
+72 -203
View File
@@ -16,9 +16,6 @@ namespace spit {
class SProcessor { class SProcessor {
public: public:
// /** Maximal length of a SPITMessage*/
// static const int MAXSPITMESSAGEBYTECOUNT = 512;
enum class ProjUpdate { enum class ProjUpdate {
ServerLoaded, ServerLoaded,
StartTransfer, StartTransfer,
@@ -57,28 +54,11 @@ class SProcessor {
}; };
struct InternalCallbacks { struct InternalCallbacks {
function<int(SType &sType)> sendSpitTypeInternal; function<void(int ms)> delay;
function<int(Message::OPPart &msg)> sendMessage;
}; };
// //------ PlayerType ------ static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
// public:
// /** continous main player, time value can be used like a timecode.<br>The time value is the position in server's project.<br>A server should use only one main player.*/
// static constexpr char PLAYERTYPE_MAIN = 0x02;
// /** continous player. This player plays SPIT objects sometime during the project.*/
// static constexpr char PLAYERTYPE_CONTINOUS = 0x01;
// /** diescrete player. This player is used to transmit single discrete values.*/
// static constexpr char PLAYERTYPE_DISCRETE = 0x00;
// //------ Value Flag ------
// //------ used by sendRemoteObject
// public:
// /**Set the given value directly*/
// static constexpr char VALUEFLAG_DIRECT = 0x00;
// /**Increase the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
// static constexpr char VALUEFLAG_INCREASE = 0x01;
// /**Decrease the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
// static constexpr char VALUEFLAG_DECREASE = 0x02;
// static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
//----- SProcessor ----- //----- SProcessor -----
public: public:
@@ -90,155 +70,55 @@ class SProcessor {
Callbacks mCallbacks; Callbacks mCallbacks;
InternalCallbacks mInternCallbacks; InternalCallbacks mInternCallbacks;
// Connection mConnectionStatus{Connection::None};
// bool mDisconnectedByServer{}; // flag true = when server disconnects
string mGuid;
string mName; string mName;
string mGuid;
string mProjName; string mProjName;
string mComputerName; string mComputerName;
// 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*/ string getID() { return mGuid; }
// string getID() { return mGuid; } string getName() { return mName; }
// /** The name of the client, should be set by the user app*/ string getProjName() { return mProjName; }
// string getName() { return mName; } string getComputerName() { return mComputerName; }
// //----- Computer Params ----- void setActionType(string spitypeID, bool actionAssigned);
// /** The name of the client's host computer*/ void setActionObject(string objectID, bool actionAssigned);
// string getComputerName() { return mComputerName; } void checkParseMessageData(vector<char> data);
// void setClientProjectName(string clientProjectName) { mClientProjectName = clientProjectName; }
// string getClientProjectName() { return mClientProjectName; }
// // connected Server Infos unique_ptr<Message::Connect> createConnectMessage(string serverIP, string serverPort, string loginName, string loginPassword);
// /** The ID of the connected SPITServer*/
// string getServerID() { return mServerID; }
// /** The host computername of the connected SPITServer*/
// string getServerComputerName() { return mServerComputerName; }
// /** The name of the connected SPITServer*/
// string getServerName() { return mServerName; }
// /** Expected Refreah Rate of the connectd SPITServer.<br> std::vector<char> createMessage(Message::OPPart &spitMessageOPPart);
// * When the server plays objects, it will do so at discrete time steps.<br> void parseMessage(Message &message);
// * Play events will take place in these time steps.. void addOvertakingMessage(unique_ptr<Message> message);
// */ void parseReportProject(Message::ReportProject &message);
// int getServerStepTime() { return mServerStepTime; } void parseCloseProject(Message::CloseProject &message);
// /** Should be called when the client wants to close his project*/ string getServerProjectID() { return mServerProjectID; }
// void clientProjectClose(); string getServerProjectName() { return mServerProjectName; }
// /** int getServerFramesPerSecond() { return mServerFramesPerSecond; }
// * Should be called whenever the client has a project loaded
// */
// void clientProjectLoaded();
// void setActionSPITType(string spitypeID, bool actionAssigned); void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
// void setActionSPITObject(string objectID, bool actionAssigned); void parseStartProjectTransfer(Message::StartProjectTransfer &message);
void parseEndProjectTransfer(Message::EndProjectTransfer &message);
// //--------------- SPITMessage ---------------
// private:
// // Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected
// bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID
// public:
// std::vector<char> createMessage(Message::OPPart & spitMessageOPPart);
// void checkParseMessageData(vector<char> data);
// //--------------- ServerAutoDetection SAD ---------------
// public:
// /** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before.*/
// void startServerAutoDetect();
// /** Stops the autodetection of SPITServers in the local network*/
// void stopServerAutoDetect();
// /** Called every time a new SPITServer is detetced in the local network */
// void eventServerDetected(SadDetectedServer &server);
// /** Called every time a prior detected SPITServer is is no longer found.*/
// void eventServerLost(SadDetectedServer &server);
// void eventServerChanged(SadDetectedServer &server);
// //--------------- Connection ---------------
// public:
// /**
// * Tries a connection to the SPITServer
// * @param p_ServerIP ip address of the SPITServer
// * @param p_ServerPort port of the SPITServer
// * @param p_ClientIP IP of the client
// * @param p_ClientPort if "0" any free port will be used
// * @param p_LoginName maybe some SPITServer need a login - liveSHOWsoftware will not.
// * @param p_LoginPassword maybe some SPITServer need a login - liveSHOWsoftware will not
// * @return true = the connection try is ok, SPITServer will answer with COnnectAnswer and an eventConnectionStatus will occur.<br>
// * false = something is going wrong. (client could not bind)
// */
// bool connect(string serverIP, string serverPort, string clientIP, string clientPort, string loginName = "", string loginPassword = "");
// /**
// * Terminates the connection to the SPITServer.
// */
// void disconnect();
// private:
// void disconnectInternal(Connection cause);
// void resetMessageNumberReceived();
// void parseMessage(Message& message);
// void addOvertakingMessage(unique_ptr<Message> message);
// void parseConnectAnswer(Message::ConnectAnswer &message);
// void parseDisconnect(Message::Disconnect &message);
// void parseWatchdog(Message::Watchdog &message);
// void parseWatchdogAnswer(Message::WatchdogAnswer &message);
// public:
// /** Used internally*/
// void sendWatchdog();
// /** Used internally. When the connection to the SPITServer is lost an eventConnectionStatus will occur*/
// void eventWatchdogLost();
// //--------------- 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*/
// string getServerProjectID();
// /** Returns the SPITServer's project name*/
// 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.*/
// int getServerFramesPerSecond();
// private:
// void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
// void parseStartProjectTransfer(Message::StartProjectTransfer &message);
// void parseEndProjectTransfer(Message::EndProjectTransfer &message);
// public:
// // static void sendProject(SClient *p_PtrSProcessor);
// // --------------- SPIT Types --------------- // // --------------- SPIT Types ---------------
// public: // public:
// /**
// * Creates a fixed SPITType for application actions that are always present and project independent.<br>
// * Fixed SPIT types cannot be changed or deleted by the server.<br>
// * These SPITTypes will be automatically added to the SPITType-List and sended to the server.
// * @param p_ID an unique of the SPITType, these are always the same per client approach. Different client approaches should use different ids.
// * @param p_GroupName a name which groups the actions/SPITTypes
// * @param p_Name the name of the Action/SPITType
// * @param p_DefaultDelay maybe there is an default delay until the action starts, this is only used for graphical representations, 0 is allowd
// * @param p_DefaultDuration maybe the action has a default duration, this is only used for graphical representations, 0 is allowd
// * @return the pointer to the new SPITType.
// */
// SType *createTypeFixed(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration);
// /** // /**
// * Creates a SPITType for application actions.<br> // * Creates a SPITType for application actions.<br>
// * These SPITTypes will be automatically added to the SPITType-List and sended to the server. // * These SPITTypes will be automatically added to the SPITType-List and sended to the server.
@@ -251,75 +131,64 @@ class SProcessor {
// * @param p_ProjectIndepended true = the SPITType belongs to a specific project, false = the SpitType always exists for every project // * @param p_ProjectIndepended true = the SPITType belongs to a specific project, false = the SpitType always exists for every project
// * @return the pointer to the new SPITType. // * @return the pointer to the new SPITType.
// */ // */
// SType *createType(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration, bool fixed, bool projectIndepended); SType *createType(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration, bool fixed, bool projectIndepended);
private: int sendTypeInternal(SType &sType);
public: // @todo delete
void parseReportType(Message::ReportType &message);
// void parseRemoveSPITType(Message::RemoveType &message);
// int sendSPITTypeInternal(SType &sType);
// public: private:
// /** public: // @todo delete
// * If a client wants to change a SPITType, he should send it to the server.<br> void parseReportType(Message::ReportType &message);
// * 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> void parseRemoveType(Message::RemoveType &message);
// * @param spitypeID the id of the SPITType to remove.
// * @return 0 = is sended, -1 = is not sended public:
// */ /**
// bool changeSPITType(SType *spitType); * 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 a client wants to remove a SPITType, he should send it to the server.<br> * @param spitypeID the id of the SPITType to remove.
// * 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> * @return 0 = is sended, -1 = is not sended
// * @param spitypeID the id of the SPITType to remove. */
// * @return 0 = is sended, -1 = is not sended bool changeType(SType *spitType);
// */ /**
// int removeSPITType(string spitypeID); * 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 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);
// int sendSPITObjectInternal(SObject *ptrObject); void parseRemoveObject(Message::RemoveObject &message);
int sendObjectInternal(SObject *sObject);
// 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> bool changeObject(SObject *sObject);
// * 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 ----------
// void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00); void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00);
// private: void resetConfirmedFlags() {
// bool mAbortSearch{}; SType::setConfirmedFalse(mSpitTypes);
// bool sAnswered{}; SObject::setConfirmedFalse(mSpitObjects);
// void answerWatchdog() { }
// sAnswered = true;
// }
// SpitRepo<SObject> mSpitObjects; private:
// SpitRepo<SObject> mRemoteSpitObjects; SpitRepo<SObject> mSpitObjects;
public: // @todo remove
SpitRepo<SType> mSpitTypes; SpitRepo<SType> mSpitTypes;
SpitRepo<SObject> mRemoteSpitObjects;
SpitRepo<SType> mRemoteSpitTypes; SpitRepo<SType> mRemoteSpitTypes;
}; };
components/spit/src/spit_client.cpp
+48 -642
View File
@@ -16,16 +16,13 @@ static fos::Queue<vector<char>> incommingSpit(128);
SClient::SClient(string name, string projName, ISocket &socket, Callbacks calls) SClient::SClient(string name, string projName, ISocket &socket, Callbacks calls)
: ISadClient(), : ISadClient(),
mCallbacks(calls), mCallbacks(calls),
mName(name),
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); },
} }
), ),
mSocket(socket) { mSocket(socket) {
mID = createGUID();
mComputerName = getClientHostName();
} }
SClient::~SClient() { SClient::~SClient() {
@@ -36,8 +33,8 @@ SClient::~SClient() {
void SClient::clientProjectClose() { 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(mProcessor.getProjName());
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");
} }
} }
@@ -45,58 +42,23 @@ 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); mProcessor.resetConfirmedFlags();
SObject::setConfirmedFalse(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(mProcessor.getProjName(), mProcessor.getProjName());
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");
} }
} }
} }
/**
* Virtual construct - means actionAssigned for SPITTypes is is not implemented in SPITProtocol.
* This can used to setActionAssigned to all SPITObjects with this SPITType.
* This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
* This tells the server not what action is done, but it tells the server that there is an action.
* @param typeId the id of the SPITType
* @param actionAssigned
*/
void SClient::setActionSPITType(string typeId, bool actionAssigned) {
SType *spitType = mProcessor.mSpitTypes.getEntry(typeId);
if (spitType == nullptr)
return;
if (spitType->ActionAssigned.set(actionAssigned)) {
sendSPITTypeInternal(*spitType);
for (auto& [key, value] : mSpitObjects.getRepo()) {
if (value->SPITTypeID.get() == spitType->getID()) {
if (value->setActionAssignedType(actionAssigned) == true) {
sendSPITObjectInternal(value.get());
}
}
}
}
}
/** This should be called if the user wants to associate/remove an action with a SPITObject. */
void SClient::setActionSPITObject(string spitObjId, bool actionAssigned) {
SObject *spitObject = mSpitObjects.getEntry(spitObjId);
if (spitObject == nullptr)
return;
if (spitObject->setActionAssigned(actionAssigned) == true) {
sendSPITObjectInternal(spitObject);
}
}
//---------- ServerAutoDetection SAD ----------- //---------- ServerAutoDetection SAD -----------
/** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before. /** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before.
@@ -205,13 +167,13 @@ 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
mMessageNumberSend++; mMessageNumberSend++;
opPart.setMessageNumber(mMessageNumberSend); opPart.setMessageNumber(mMessageNumberSend);
opPart.setServerInfoInHeader(mID, mServerID); opPart.setServerInfoInHeader(mProcessor.getID(), mServerID);
int opFlag = opPart.getHeader()->getType(); int opFlag = opPart.getHeader()->getType();
try { try {
@@ -244,10 +206,10 @@ void SClient::stopReceiveSPITMessages() {
} }
void SClient::receiveSpitMessage(SClient &rM) { void SClient::receiveSpitMessage(SClient &rM) {
char buffer[MAXSPITMESSAGEBYTECOUNT + 1]; char buffer[Message::MAX_MESSAGE_SIZE];
int rdLen; int rdLen;
while (rM.mStopReceiveMessages == false) { while (rM.mStopReceiveMessages == false) {
rdLen = rM.mSocket.receiveMessage(buffer, MAXSPITMESSAGEBYTECOUNT, nullptr); rdLen = rM.mSocket.receiveMessage(buffer, Message::MAX_MESSAGE_SIZE, nullptr);
if (rdLen < 0) { if (rdLen < 0) {
if (rM.mStopReceiveMessages) { if (rM.mStopReceiveMessages) {
return; return;
@@ -281,14 +243,14 @@ void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
return; return;
} }
int intActualMessageNumber = (int)(p_SPITMessage->getHeader()->getMessageNumber() & 0xFF); int msgNum = (int)(p_SPITMessage->getHeader()->getMessageNumber() & 0xFF);
if (intActualMessageNumber == 0) { if (msgNum == 0) {
parseMessage(std::move(p_SPITMessage)); parseMessage(std::move(p_SPITMessage));
return; return;
} }
if (mMessageNumberReceived < 0) { if (mMessageNumberReceived < 0) {
mMessageNumberReceived = intActualMessageNumber; mMessageNumberReceived = msgNum;
parseMessage(std::move(p_SPITMessage)); parseMessage(std::move(p_SPITMessage));
return; return;
} }
@@ -297,8 +259,8 @@ void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
if (intNextMessageNumber > 255 || intNextMessageNumber < 1) if (intNextMessageNumber > 255 || intNextMessageNumber < 1)
intNextMessageNumber = 1; intNextMessageNumber = 1;
if (intActualMessageNumber == intNextMessageNumber) { if (msgNum == intNextMessageNumber) {
mMessageNumberReceived = intActualMessageNumber; mMessageNumberReceived = msgNum;
parseMessage(std::move(p_SPITMessage)); parseMessage(std::move(p_SPITMessage));
// check overtaking messages // check overtaking messages
@@ -310,10 +272,10 @@ void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
intNextMessageNumber = 1; intNextMessageNumber = 1;
auto &ptrOvertakingSPIT_Message = *it; auto &ptrOvertakingSPIT_Message = *it;
intActualMessageNumber = (int)(ptrOvertakingSPIT_Message->getHeader()->getMessageNumber() & 0xFF); msgNum = (int)(ptrOvertakingSPIT_Message->getHeader()->getMessageNumber() & 0xFF);
if (intActualMessageNumber == intNextMessageNumber) { if (msgNum == intNextMessageNumber) {
mMessageNumberReceived = intActualMessageNumber; mMessageNumberReceived = msgNum;
parseMessage(move(ptrOvertakingSPIT_Message)); parseMessage(move(ptrOvertakingSPIT_Message));
mOvertakingMessages.erase(it); mOvertakingMessages.erase(it);
@@ -333,7 +295,7 @@ void SClient::addOvertakingMessage(unique_ptr<Message> message) {
if (!message) { if (!message) {
return; return;
} }
if (mOvertakingMessages.size() > MAX_OVERTAKING_SPIT_MESSAGES) { if (mOvertakingMessages.size() > mProcessor.MAX_OVERTAKING_SPIT_MESSAGES) {
ESP_LOGD(TAG, "Client receiveing: perhaps message lost !!!!!"); ESP_LOGD(TAG, "Client receiveing: perhaps message lost !!!!!");
} }
@@ -365,7 +327,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 +337,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");
@@ -436,15 +398,8 @@ bool SClient::connect(string serverIP, string serverPort, string clientIP, strin
mStopReceiveMessages = true; mStopReceiveMessages = true;
return false; return false;
} }
Message::Connect sMConnect(mComputerName, mName);
sMConnect.setLoginName(loginName); auto connMsg = mProcessor.createConnectMessage(serverIP, serverPort, loginName, loginPassword);
sMConnect.setLoginPassword(loginPassword);
sMConnect.setServerIP(serverIP);
if (serverPort.length() <= 0) {
serverPort = "0";
}
int intServerPort = stoi(serverPort);
sMConnect.setServerPort(intServerPort);
if (startReceiveSPITMessages() == false) { if (startReceiveSPITMessages() == false) {
mStopReceiveMessages = true; mStopReceiveMessages = true;
@@ -459,7 +414,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(*connMsg) < 0) {
mConnectionStatus = Connection::None; mConnectionStatus = Connection::None;
mStopReceiveMessages = true; mStopReceiveMessages = true;
return false; return false;
@@ -483,7 +438,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 +460,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;
@@ -525,7 +480,7 @@ void SClient::disconnectInternal(Connection cause) {
} }
void SClient::parseConnectAnswer(Message::ConnectAnswer &message) { void SClient::parseConnectAnswer(Message::ConnectAnswer &message) {
if (message.getClientID() != mID) if (message.getClientID() != mProcessor.getID())
return; return;
mServerID = message.getServerID(); mServerID = message.getServerID();
@@ -574,7 +529,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 +543,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 +556,6 @@ void SClient::eventWatchdogLost() {
} }
} }
//----- SPIT Project ------
void SClient::parseReportProject(Message::ReportProject &message) {
ESP_LOGD(TAG, "parse ReportProject");
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 +570,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 +584,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 +598,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 +607,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,433 +618,8 @@ void SClient::sendProject(SClient *p_PtrSPIT_Client) {
// //Send act // //Send act
} }
void SClient::parseStartProjectTransfer(Message::StartProjectTransfer &message) { SType *SClient::createTypeFixed(string iD, string group, string name, uint64_t delay, uint64_t duration) {
mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID); return mProcessor.createType(iD, group, name, delay, duration, true, true);
}
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 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
* @return 0 = is sended, -1 = is not sended
*/
int SClient::sendSPITTypeInternal(SType &p_SPITType) {
Message::ReportType sMReportSPITType;
p_SPITType.fillMessageOP(sMReportSPITType);
return sendSPITMessage(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) {
return createType(iD, p_GroupName, p_Name, p_DefaultDelay, p_DefaultDuration, true, true);
}
SType *SClient::createType(string p_ID, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration, bool p_FIxed, bool p_ProjectIndepended) {
bool boolNew;
SType *ptrSPITType = mProcessor.mSpitTypes.getEntry(p_ID);
if (ptrSPITType == nullptr) {
auto spitType = make_unique<SType>(p_ID, p_GroupName, p_Name, p_FIxed, p_ProjectIndepended, p_DefaultDelay, p_DefaultDuration);
ptrSPITType = spitType.get();
mProcessor.mSpitTypes.addEntry(move(spitType));
ptrSPITType->setCreatedByClient(true);
boolNew = true;
} else {
ptrSPITType->GroupName.set(p_GroupName);
ptrSPITType->Name.set(p_Name);
ptrSPITType->Fixed.set(p_FIxed);
ptrSPITType->ProjectIndepended.set(p_ProjectIndepended);
ptrSPITType->DefaultDelay.set(p_DefaultDelay);
ptrSPITType->DefaultDuration.set(p_DefaultDuration);
boolNew = false;
}
auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
mCallbacks.onSpitType(eventType, false, *ptrSPITType);
sendSPITTypeInternal(*ptrSPITType);
return ptrSPITType;
}
//----- SPIT Objects ------
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)
return -1;
Message::ReportObject sMReportSPITObject;
ptrSPITObject->fillMessageOP(sMReportSPITObject);
return sendSPITMessage(sMReportSPITObject);
}
/**
* When the client changes an existing SPITObject (normally the client should not do this), then he should send the changes to the SPITServer.
* An eventSPITObject occurs.
* The SPITServer may discard the changes and a second eventSPITObject occurs to correct the changes.
* @param obj the pointer to the changed SPITObject.
* CAUTION: The SPITObject must already exist.
* @return true = SPITObject is changed, false = not changed, maybe obj is NULL or the SPITObject doesn't exists
*/
bool SClient::changeSPITObject(SObject *obj) {
if (obj == nullptr)
return false;
SObject *ptrSPITObject;
SType *ptrSPITType;
{
ptrSPITObject = mSpitObjects.getEntry(obj->getID());
if (ptrSPITObject == nullptr)
return false;
ptrSPITType = mProcessor.mSpitTypes.getEntry(obj->getID());
if (ptrSPITObject == nullptr)
return false;
ptrSPITObject->setActionAssigned(obj->getActionAssigned());
;
ptrSPITObject->Delay.set(obj->Delay.get());
ptrSPITObject->Duration.set(obj->Delay.get());
ptrSPITObject->Fixed.set(obj->Fixed.get());
ptrSPITObject->FrameFadeInLength.set(obj->FrameFadeInLength.get());
ptrSPITObject->FrameFadeOutLength.set(obj->FrameFadeOutLength.get());
ptrSPITObject->FrameLength.set(obj->FrameLength.get());
ptrSPITObject->FrameStart.set(obj->FrameStart.get());
ptrSPITObject->Name.set(obj->Name.get());
ptrSPITObject->Remark.set(obj->Remark.get());
ptrSPITObject->SPITTypeID.set(obj->SPITTypeID.get());
ptrSPITObject->ServerParams.set(obj->ServerParams.get());
ptrSPITObject->Track.set(obj->Track.get());
ptrSPITObject->ValueFactor.set(obj->ValueFactor.get());
ptrSPITObject->ValueUse.set(obj->ValueUse.get());
mCallbacks.onSpitObject(ObjectEvent::Changed, false, *ptrSPITType, *ptrSPITObject);
sendSPITObjectInternal(ptrSPITObject);
}
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 ----------
/**
* Send a remote control command to the SPITServer.
* There may be different command types:
* a) Some don't use value e.g. go to next scene, olay a jingle
* b) Some use values e.g. the main sound fader
* @param p_SPITObjectID the id of the remote SPITObject (this represents the remote control command)
* @param valuePpm the value in ppm
* in case a) the value is ignored
* in case b) the value is used
* @param valueFlag indicates how the server should use valuePpm:
* VALUEFLAG_DIRECT (0x00) The server overwrites its existing value with p_Value
* VALUEFLAG_INCREASE (0x01) The server increases 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) {
SObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID);
if (ptrRemoteSPITObject == nullptr) {
ESP_LOGD(TAG, "Unknown ID %s", p_SPITObjectID.c_str());
return;
}
Message::PlayStart playSPITStart(mID, mProjName, PLAYERTYPE_DISCRETE);
playSPITStart.setPlayerIsRunning(false);
playSPITStart.setTime(0);
sendSPITMessage(playSPITStart);
Message::PlayObject playSPITObject;
playSPITObject.setID(ptrRemoteSPITObject->getID());
playSPITObject.setPlayPrePosition(false);
playSPITObject.setPlayerID(mID);
playSPITObject.setValue(valuePpm);
playSPITObject.setValueFlag(valueFlag);
sendSPITMessage(playSPITObject);
Message::PlayEnd playSPITEnd(mID);
sendSPITMessage(playSPITEnd);
} }
fos::Semaphore SClient::sStartSad; fos::Semaphore SClient::sStartSad;
@@ -1304,7 +710,7 @@ void SClient::processSocketTask(SClient &instance) {
ESP_LOGW(TAG, "Finished searching"); ESP_LOGW(TAG, "Finished searching");
ESP_LOGW(TAG, "Start working"); ESP_LOGW(TAG, "Start working");
auto nextWdTrigger = fos::Timing::getMilliSec() + WATCHDOGTIME; auto nextWdTrigger = fos::Timing::getMilliSec() + WATCHDOGTIME;
auto nextWdCheck = nextWdTrigger + WATCHDOGTIME; // auto nextWdCheck = nextWdTrigger + WATCHDOGTIME;
while (true) { while (true) {
// auto time = fos::Timing::getMilliSec(); // auto time = fos::Timing::getMilliSec();
// if (time > nextWdTrigger) { // if (time > nextWdTrigger) {
components/spit/src/spit_processor.cpp
+632 -936
View File
File diff suppressed because it is too large Load Diff
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) {
core
+1 -1
Submodule core updated: acdd1ee930...14491fb9c7
main/watchMain.cpp
+4 -4
View File
@@ -854,14 +854,14 @@ void onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_Pl
ESP_LOGD(TAG, "eventPlay Player: %s Runs: %d Time: %lld", p_PlayerName.data(), p_PlayerIsRunning, p_TimeFrames); ESP_LOGD(TAG, "eventPlay Player: %s Runs: %d Time: %lld", p_PlayerName.data(), p_PlayerIsRunning, p_TimeFrames);
switch (p_PlayerType) { switch (p_PlayerType) {
case SClient::PLAYERTYPE_MAIN: case SClient::PlayerType::PTYPE_MAIN:
// p_FrameTimes contains the position inside the server's project, we can use it like a timecode // p_FrameTimes contains the position inside the server's project, we can use it like a timecode
// int intMilliseconds = (int)(((double)p_TimeFrames / (double)m_ServerFramesPerSecond) * 1000); // int intMilliseconds = (int)(((double)p_TimeFrames / (double)m_ServerFramesPerSecond) * 1000);
break; break;
case SClient::PLAYERTYPE_CONTINOUS: case SClient::PlayerType::PTYPE_CONTINOUS:
// The olayer is playing only single Object sequences sometime during the project // The olayer is playing only single Object sequences sometime during the project
break; break;
case SClient::PLAYERTYPE_DISCRETE: case SClient::PlayerType::PTYPE_DISCRETE:
// Only discrete values where submitted, e.g the fader position of remote faders. // Only discrete values where submitted, e.g the fader position of remote faders.
break; break;
} }
@@ -934,7 +934,7 @@ void SpitClientApp() {
for (auto &obj : ProvidedObj) { for (auto &obj : ProvidedObj) {
SType *ptrSPITType1Fix = spitClient.createTypeFixed(obj.iD, obj.groupName, obj.name, 0, 0); SType *ptrSPITType1Fix = spitClient.createTypeFixed(obj.iD, obj.groupName, obj.name, 0, 0);
spitClient.setActionSPITType(ptrSPITType1Fix->getID(), true); // should be executed whenever a SPITObject with this SPITType is played spitClient.setActionType(ptrSPITType1Fix->getID(), true); // should be executed whenever a SPITObject with this SPITType is played
} }
spitClient.clientProjectLoaded(); spitClient.clientProjectLoaded();
spitClient.startServerAutoDetect(); spitClient.startServerAutoDetect();