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

refactor: moving SPIT-App parts to main app

Browse Source
This commit is contained in:
Jakob Gegeniger
2025-03-29 14:57:01 +01:00
parent 810264aa71
commit 2f5497c432
19 changed files with 6245 additions and 6516 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/I_SAD_Client.hpp
+6 -4
View File
@@ -3,8 +3,9 @@
#include <string> #include <string>
using namespace std; using namespace std;
class SAD_DetectedServer;
class I_SAD_Client { class I_SAD_Client {
public: public:
/** /**
* If a new server was found by the ServerAutoDetect mechanism, this function is called.<br> * If a new server was found by the ServerAutoDetect mechanism, this function is called.<br>
* To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.<br> * To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.<br>
@@ -20,7 +21,7 @@ public:
* @param p_Addition sometimes server may have additional informations * @param p_Addition sometimes server may have additional informations
* @param p_IsIP4 the server ip is a ip4 address * @param p_IsIP4 the server ip is a ip4 address
*/ */
virtual void eventServerDetected(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4) = 0; virtual void eventServerDetected(SAD_DetectedServer &server) = 0;
/** /**
* If a SPITServer is not more found, this function is called. * If a SPITServer is not more found, this function is called.
* To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.<br> * To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.<br>
@@ -32,6 +33,7 @@ public:
* @param p_Addition sometimes server may have additional informations * @param p_Addition sometimes server may have additional informations
* @param p_IsIP4 the server ip is a ip4 address * @param p_IsIP4 the server ip is a ip4 address
*/ */
virtual void eventServerLost(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4) = 0; virtual void eventServerChanged(SAD_DetectedServer &server) = 0;
virtual void eventServerChanged(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4) = 0;
virtual void eventServerLost(SAD_DetectedServer &server) = 0;
}; };
components/spit/include/MyApp.h
-85
View File
@@ -1,85 +0,0 @@
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: MySPITApp.h
* Author: Hagi
*
* Created on 17. April 2019, 18:24
*/
#ifndef MYSPITAPP_H
#define MYSPITAPP_H
#include "SPIT_Client.h"
#include <chrono>
#include <string>
#include "SPITType.h"
#include "SPITObject.h"
#include "SPITPlayer.h"
#include "SAD_DetectedServer.hpp"
using namespace std;
class MyApp {
public:
MyApp();
// Client's infos is set by the client
static string s_ClientName;
static string s_ProjectName;
void init();
private:
SPIT_Client _SpitClient; // pointer to an instance of the SPIT_Client, which do the main work for you
// Server's project infos filled by eventProjectReport
static string m_ServerProjectID;
static string m_ServerProjectName;
static int m_ServerFramesPerSecond; // set when the server reports his project, see eventProjectReport
// liveSHOWsoftware will use 44100 frames per second as time resolution
// All times are given in frames,
public:
static void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_DetectedServer);
static void onConnectionStatus(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, int p_ConnectionStatus, int p_OldConnectionStatus);
//----- Project -----
static void onStartProjectTransfer();
static void onEndProjectTransfer();
static void onProjectReport(string p_ProjectID, string p_ProjectName, int p_FramesPerSeoond);
static void onProjectClosed(string p_ProjectID);
//----- SPITType -----
static bool onCheckSpitTypeVeto(SPIT_Message::ReportSPITType* p_ReportSPITType);
static void onSpitType(bool p_New, const SPITType &p_SPITType);
static void onSpitTypeRemote(bool p_New, const SPITType &p_SPITType);
static void onSpitTypeRemoved(const SPITType &p_SPITType);
static void onSpitTypeRemoteRemoved(const SPITType &p_SPITType);
//----- SPITObject -----
static bool onCheckSpitObjectVeto(SPIT_Message::ReportSPITObject* p_ReportSPITObject);
static void onSpitObject(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject);
static void onSpitObjectRemote(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject);
static void onSpitObjectRemoved(const SPITType &p_SPITType, const SPITObject &p_SPITObject);
static void onSpitObjectRemoteRemoved(const SPITType &p_SPITType, const SPITObject &p_SPITObject);
//----- Play SPITObjects -----
static void onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames);
static void onPlaySpitType(string p_PlayerID, string p_SPITTypeID, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value);
//----- Server changes status of one of his REMOTE SPITObjects -----
// REMOTE only Server->Client RemoteObject's play status
static void onPlayRemoteObjectStatus(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value);
void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00);
//-----
void testLiveShowRemote();
//------ User's options normally should not be used, the server is master of things ------
public:
};
#endif /* MYSPITAPP_H */
components/spit/include/SAD_DetectedServer.hpp
+17 -36
View File
@@ -1,22 +1,21 @@
#pragma once #pragma once
#include "I_SAD_Client.hpp" #include "I_SAD_Client.hpp"
#include <list>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <list>
using namespace std; using namespace std;
class SAD_DetectedServer { class SAD_DetectedServer {
public: public:
SAD_DetectedServer(); SAD_DetectedServer();
SAD_DetectedServer(const SAD_DetectedServer& orig) { SAD_DetectedServer(const SAD_DetectedServer &orig) {
m_ID = orig.getID(); m_ID = orig.getID();
m_Name = orig.getName(); m_Name = orig.getName();
m_ComputerName = orig.getComputerName(); m_ComputerName = orig.getComputerName();
m_IP = orig.getIP(); m_IP = orig.getIP();
m_IPIsIP4 = orig.getIpIsIP4();
m_ClientIP = orig.getClientIP(); m_ClientIP = orig.getClientIP();
m_Port = orig.getPort(); m_Port = orig.getPort();
m_Additions = orig.getAdditions(); m_Additions = orig.getAdditions();
@@ -28,7 +27,6 @@ public:
string m_Name; string m_Name;
string m_ComputerName; string m_ComputerName;
string m_IP; string m_IP;
bool m_IPIsIP4;
string m_ClientIP; string m_ClientIP;
string m_Port; string m_Port;
string m_Additions; string m_Additions;
@@ -42,22 +40,21 @@ public:
string getName() const { return m_Name; } string getName() const { return m_Name; }
string getComputerName() const { return m_ComputerName; } string getComputerName() const { return m_ComputerName; }
string getIP() const { return m_IP; } string getIP() const { return m_IP; }
bool getIpIsIP4() const { return m_IPIsIP4; }
string getPort() const { return m_Port; } string getPort() const { return m_Port; }
string getClientIP() const { return m_ClientIP; } string getClientIP() const { return m_ClientIP; }
string getAdditions() const { return m_Additions; } string getAdditions() const { return m_Additions; }
string getProjectName() const {return m_ServerProjectName;} string getProjectName() const { return m_ServerProjectName; }
private:
private:
void setID(string p_ID) { m_ID = p_ID; } void setID(string p_ID) { m_ID = p_ID; }
void setName(string p_Name) { m_Name = p_Name; } void setName(string p_Name) { m_Name = p_Name; }
void setComputerName(string p_ComputerName) { m_ComputerName = p_ComputerName; } void setComputerName(string p_ComputerName) { m_ComputerName = p_ComputerName; }
void setIP(string p_IP) { m_IP = p_IP; } void setIP(string p_IP) { m_IP = p_IP; }
void setClientIP(string p_IP) { m_ClientIP = p_IP; } void setClientIP(string p_IP) { m_ClientIP = p_IP; }
void setPort(string p_Port) { m_Port = p_Port; } void setPort(string p_Port) { m_Port = p_Port; }
void setAdditions(string p_Additions) { m_Additions = p_Additions;} void setAdditions(string p_Additions) { m_Additions = p_Additions; }
void setProjectName(string p_ServerProjectName); void setProjectName(string p_ServerProjectName);
void setIPIsIP4(bool p_IsIP4) { m_IPIsIP4 = p_IsIP4; }
bool getNew() const { return m_New; } bool getNew() const { return m_New; }
bool getChanged() const { return m_Changed; } bool getChanged() const { return m_Changed; }
bool getFoundAgain() const { return m_FoundAgain; } bool getFoundAgain() const { return m_FoundAgain; }
@@ -65,18 +62,17 @@ private:
void setNew(bool p_New) { m_New = p_New; } void setNew(bool p_New) { m_New = p_New; }
void setFoundAgain() { m_FoundAgain = true; } void setFoundAgain() { m_FoundAgain = true; }
//SAD_Client m_ThreadSend will send to Multicast addresses // SAD_Client m_ThreadSend will send to Multicast addresses
void startCycleSAD() { void startCycleSAD() {
m_IPIsIP4 = false;
m_Changed = false; m_Changed = false;
m_FoundAgain = false; m_FoundAgain = false;
m_New = false; m_New = false;
} }
//SAD_Client m_Thread_Send has paused in the meantime m_ThreadReceive may received messages from servers
void endCycleSAD() { } private:
private: static unordered_map<string, SAD_DetectedServer *> s_DetectedServers;
static unordered_map<string, SAD_DetectedServer*> s_DetectedServers;
public: public:
static const int PARAMINDEX_PRECODE = 0; static const int PARAMINDEX_PRECODE = 0;
static const int PARAMINDEX_SPITTASKID = 1; static const int PARAMINDEX_SPITTASKID = 1;
static const int PARAMINDEX_NAME = 2; static const int PARAMINDEX_NAME = 2;
@@ -93,12 +89,12 @@ public:
* @param p_ServerID the id of the server, every instance of a SPITServer has an own id * @param p_ServerID the id of the server, every instance of a SPITServer has an own id
* @param p_ServerParams the server's parameter * @param p_ServerParams the server's parameter
*/ */
static void addDetectedServer(bool p_IsIP4, string p_ServerID, string p_ServerParams[]); static void addDetectedServer(string p_ServerID, string p_ServerParams[]);
/** /**
* Used by SAD_Client to remove a SPITServer - don't use this manually * Used by SAD_Client to remove a SPITServer - don't use this manually
* @param p_DetectedServer * @param p_DetectedServer
*/ */
static void removeDetectedServer(SAD_DetectedServer* p_DetectedServer); static void removeDetectedServer(SAD_DetectedServer &server);
/** /**
* Used by SAD_Client to clear all found SPITServers - don't use this manually * Used by SAD_Client to clear all found SPITServers - don't use this manually
*/ */
@@ -111,7 +107,7 @@ public:
* Used by SAD_Client internally -don't use this manually * Used by SAD_Client internally -don't use this manually
* @param p_SADClientInterface * @param p_SADClientInterface
*/ */
static void cycleEnd(I_SAD_Client& p_SADClientInterface); static void cycleEnd(I_SAD_Client &p_SADClientInterface);
/** /**
* Returns a reference of the DetectedServer with the id p_ServerID.<br> * Returns a reference of the DetectedServer with the id p_ServerID.<br>
@@ -119,20 +115,5 @@ public:
* @param p_ServerID the id of the SPITServer * @param p_ServerID the id of the SPITServer
* @return the reference of the SAD_DetectedServer instance with getID() == p_ServerID * @return the reference of the SAD_DetectedServer instance with getID() == p_ServerID
*/ */
static const SAD_DetectedServer& getRefDetectedServer(string p_ServerID) { static const SAD_DetectedServer &getRefDetectedServer(string p_ServerID);
SAD_DetectedServer* ptrDetectedServer = NULL;
{
auto i = s_DetectedServers.find(p_ServerID);
if (i != s_DetectedServers.end()) {
ptrDetectedServer = i->second;
}
if (ptrDetectedServer != NULL) {
return *ptrDetectedServer;
}
throw new exception();
}
}
}; };
components/spit/include/SPITObject.h
+32 -32
View File
@@ -14,8 +14,8 @@
#ifndef SPITOBJECT_H #ifndef SPITOBJECT_H
#define SPITOBJECT_H #define SPITOBJECT_H
#include "SPIT_Message.h"
#include "SPITType.h" #include "SPITType.h"
#include "SPIT_Message.h"
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
@@ -24,39 +24,40 @@ using namespace std;
class SPITObjectListener; class SPITObjectListener;
class SPITObject { class SPITObject {
private: private:
static unordered_map<string, SPITObject *> s_SPITObjects;
static unordered_map<string, SPITObject *> s_SPITObjectsRemote;
static unordered_map<string, SPITObject*> s_SPITObjects; public:
static unordered_map<string, SPITObject*> s_SPITObjectsRemote; static SPITObject *getSPITObject(string p_ID);
public: static const SPITObject &getSPITObjectRef(string p_ID);
static SPITObject* getSPITObject(string p_ID); static bool addSPITObject(SPITObject *p_ptrSpitObject);
static const SPITObject& getSPITObjectRef(string p_ID); static bool removeSPITObject(SPITObject *p_ptrSpitObject);
static bool addSPITObject(SPITObject* p_ptrSpitObject);
static bool removeSPITObject(SPITObject* p_ptrSpitObject);
static bool removeSPITObject(string p_SpitObjectID); static bool removeSPITObject(string p_SpitObjectID);
static int getSPITObjectCount(); static int getSPITObjectCount();
static SPITObject* getSPITObject(int p_Index); static SPITObject *getSPITObject(int p_Index);
static const SPITObject& getSPITObjectRef(int p_Index); static const SPITObject &getSPITObjectRef(int p_Index);
static void clearSPITObjects(); static void clearSPITObjects();
static void clearUnconfirmedSPITObjects(); static void clearUnconfirmedSPITObjects();
static void setConfirmedFalse(); static void setConfirmedFalse();
static SPITObject* getSPITObjectRemote(string p_ID); static SPITObject *getSPITObjectRemote(string p_ID);
static const SPITObject& getSPITObjectRemoteRef(string p_ID); static const SPITObject &getSPITObjectRemoteRef(string p_ID);
static bool addSPITObjectRemote(SPITObject* p_ptrSpitObject); static bool addSPITObjectRemote(SPITObject *p_ptrSpitObject);
static bool removeSPITObjectRemote(SPITObject* p_ptrSpitObject); static bool removeSPITObjectRemote(SPITObject *p_ptrSpitObject);
static bool removeSPITObjectRemote(string p_SpitObjectID); static bool removeSPITObjectRemote(string p_SpitObjectID);
static int getSPITObjectRemoteCount(); static int getSPITObjectRemoteCount();
static SPITObject* getSPITObjectRemote(int p_Index); static SPITObject *getSPITObjectRemote(int p_Index);
static const SPITObject& getSPITObjectRemoteRef(int p_Index); static const SPITObject &getSPITObjectRemoteRef(int p_Index);
static void clearSPITObjectsRemote(); static void clearSPITObjectsRemote();
static void eventProjectClosed(); static void eventProjectClosed();
SPITObject(); SPITObject();
// SPITObject(const SPITObject& orig); // SPITObject(const SPITObject& orig);
~SPITObject(); ~SPITObject();
private:
private:
string m_ID; string m_ID;
string m_Name; string m_Name;
string m_SPITTypeID; string m_SPITTypeID;
@@ -67,7 +68,7 @@ private:
bool m_CreatedByClient; bool m_CreatedByClient;
bool m_ServerRemote; bool m_ServerRemote;
bool m_ActionAssigned; bool m_ActionAssigned;
bool m_ActionAssignedType; //Virtual construct bool m_ActionAssignedType; // Virtual construct
long long m_FrameStart; long long m_FrameStart;
long long m_FrameLength; long long m_FrameLength;
long long m_FrameFadeInLength; long long m_FrameFadeInLength;
@@ -83,9 +84,9 @@ private:
int m_PlayValue; int m_PlayValue;
char m_PlayValueFlag; char m_PlayValueFlag;
void initMembers(); void initMembers();
public:
public:
string getID() const { return m_ID; } string getID() const { return m_ID; }
string getName() const { return m_Name; } string getName() const { return m_Name; }
string getRemark() const { return m_Remark; } string getRemark() const { return m_Remark; }
@@ -132,15 +133,16 @@ public:
long long getDuration() const { return m_Duration; } long long getDuration() const { return m_Duration; }
bool getProjectIndepended() const { bool getProjectIndepended() const {
SPITType* ptrSPITType; SPITType *ptrSPITType;
if (m_ServerRemote == false) { if (m_ServerRemote == false) {
ptrSPITType = SPITType::getSPITType(m_SPITTypeID); ptrSPITType = SPITType::getSPITType(m_SPITTypeID);
if (ptrSPITType == NULL) return true; if (ptrSPITType == NULL)
return true;
return ptrSPITType->getProjectIndepended(); return ptrSPITType->getProjectIndepended();
} } else {
else {
ptrSPITType = SPITType::getSPITTypeRemote(m_SPITTypeID); ptrSPITType = SPITType::getSPITTypeRemote(m_SPITTypeID);
if (ptrSPITType == NULL) return true; if (ptrSPITType == NULL)
return true;
return ptrSPITType->getProjectIndepended(); return ptrSPITType->getProjectIndepended();
} }
}; };
@@ -166,11 +168,9 @@ public:
bool setDelay(long long p_Delay); bool setDelay(long long p_Delay);
bool setDuration(long long p_Duration); bool setDuration(long long p_Duration);
bool setMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject); bool setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject); void fillMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void fillMessageOP(SPIT_Message::RemoveSPITObject* p_RemoveSPITObject); void fillMessageOP(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject);
}; };
#endif /* SPITOBJECT_H */ #endif /* SPITOBJECT_H */
components/spit/include/SPITPlayer.h
+15 -17
View File
@@ -19,13 +19,13 @@
class SPITPlayer { class SPITPlayer {
//----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------ //----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
public: public:
class PlaySPITType { class PlaySPITType {
public: public:
PlaySPITType(); PlaySPITType();
PlaySPITType(SPITPlayer* p_SPITPlayer, string p_SPITObjectID); PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
PlaySPITType(const PlaySPITType& orig); PlaySPITType(const PlaySPITType &orig);
string getSPITTypeID() const { string getSPITTypeID() const {
return m_SPITTypeID; return m_SPITTypeID;
@@ -54,26 +54,25 @@ public:
double m_Value; double m_Value;
}; };
//----- SPITPlayer ------ //----- SPITPlayer ------
public: public:
//list the SPITPlayers // list the SPITPlayers
static unordered_map<string, SPITPlayer*> s_SPITPlayers; //all actual played objects static unordered_map<string, SPITPlayer *> s_SPITPlayers; // all actual played objects
static SPITPlayer* getSPITPlayer(string p_PlayerID); //if a player does not exist creates a new one static SPITPlayer *getSPITPlayer(string p_PlayerID); // if a player does not exist creates a new one
static void clearPlayers(); static void clearPlayers();
SPITPlayer(string p_PlayerID); SPITPlayer(string p_PlayerID);
virtual ~SPITPlayer(); virtual ~SPITPlayer();
void startPlaySequence(); // called by SPIT_Client::parsePlaySPITStart
void startPlaySequence(); //called by SPIT_Client::parsePlaySPITStart PlaySPITType *addSPITType_Playing(string p_SPITTypeID); // called by SPIT_Client::parsePlaySPITStart
PlaySPITType* addSPITType_Playing (string p_SPITTypeID); //called by SPIT_Client::parsePlaySPITStart void endPlaySequence(); // called by SPIT_Client::parsePlaySPITEnd
void endPlaySequence(); //called by SPIT_Client::parsePlaySPITEnd
string getID() { string getID() {
return m_ID; return m_ID;
} }
unordered_map<string, PlaySPITType*>* getPlaySPITTypes(); unordered_map<string, PlaySPITType *> *getPlaySPITTypes();
void setIsRunning(bool p_IsRunning); void setIsRunning(bool p_IsRunning);
bool getIsRunning() { return m_IsRunning; } bool getIsRunning() { return m_IsRunning; }
void setName(string p_Name); void setName(string p_Name);
@@ -83,14 +82,13 @@ public:
void setTime(long long p_Frames); void setTime(long long p_Frames);
long long getTime() { return m_TimeFrames; } long long getTime() { return m_TimeFrames; }
private: private:
string m_ID; string m_ID;
string m_Name; string m_Name;
char m_Type; char m_Type;
unordered_map<string, PlaySPITType*> m_PlaySPITTypes; unordered_map<string, PlaySPITType *> m_PlaySPITTypes;
bool m_IsRunning; bool m_IsRunning;
long long m_TimeFrames; long long m_TimeFrames;
}; };
#endif /* SPITPLAYER_H */ #endif /* SPITPLAYER_H */
components/spit/include/SPITSocket.h
+23 -24
View File
@@ -16,17 +16,17 @@
#ifndef SPITSOCKET_H #ifndef SPITSOCKET_H
#define SPITSOCKET_H #define SPITSOCKET_H
#include <string>
#include "esp_netif.h"
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include "Task.hpp" #include "Task.hpp"
#include "esp_log.h" #include "esp_log.h"
#include "esp_netif.h"
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <sys/socket.h>
#include <unistd.h>
using namespace std; using namespace std;
@@ -35,7 +35,7 @@ string createGUID();
/** Returns the name of the client's host computer*/ /** Returns the name of the client's host computer*/
string getClientHostName(); string getClientHostName();
class SPITSocket{ class SPITSocket {
public: public:
static const int FAMILY_IP4 = AF_INET; static const int FAMILY_IP4 = AF_INET;
@@ -45,8 +45,8 @@ class SPITSocket{
*/ */
struct IPAddress { struct IPAddress {
public: public:
IPAddress(const string& p_IPAddress, const string& p_SubnetMask) IPAddress(const string &p_IPAddress, const string &p_SubnetMask)
: m_IPAddress(p_IPAddress), m_SubnetMask(p_SubnetMask) { } : m_IPAddress(p_IPAddress), m_SubnetMask(p_SubnetMask) {}
const string m_IPAddress; const string m_IPAddress;
const string m_SubnetMask; const string m_SubnetMask;
@@ -72,10 +72,10 @@ class SPITSocket{
bool createSocket_UDP(); bool createSocket_UDP();
static const int INVALID_SOCKET = -1; static const int INVALID_SOCKET = -1;
private: private:
int m_UDPSocketIP4; int m_UDPSocketIP4;
public: public:
//-------- class -------------- //-------- class --------------
SPITSocket(IPAddress ip) : mOwnIp(ip) { SPITSocket(IPAddress ip) : mOwnIp(ip) {
m_UDPSocketIP4 = INVALID_SOCKET; m_UDPSocketIP4 = INVALID_SOCKET;
@@ -88,7 +88,6 @@ public:
m_BoundClientFamily = 0; m_BoundClientFamily = 0;
m_IsBound = false; m_IsBound = false;
createSocket_UDP(); createSocket_UDP();
} }
virtual ~SPITSocket() { virtual ~SPITSocket() {
ESP_LOGD("UDP", "Shutting down ..."); ESP_LOGD("UDP", "Shutting down ...");
@@ -101,16 +100,17 @@ public:
fos::Task::delayMs(100); fos::Task::delayMs(100);
m_IsBound = false; m_IsBound = false;
} }
private:
private:
string m_ServerIP; string m_ServerIP;
string m_ServerPort; string m_ServerPort;
string m_ClientIP; string m_ClientIP;
string m_ClientPort; //port given by the user maybe "0" string m_ClientPort; // port given by the user maybe "0"
string m_BoundClientPort; //port set after bind string m_BoundClientPort; // port set after bind
int m_BoundClientFamily; int m_BoundClientFamily;
bool m_IsBound; bool m_IsBound;
public: public:
/** /**
* Sets the ip address and port for server and client. * Sets the ip address and port for server and client.
* @param p_ServerIP * @param p_ServerIP
@@ -131,7 +131,7 @@ public:
* @param p_MessageLength length of the messaeg * @param p_MessageLength length of the messaeg
* @return * @return
*/ */
int sendMessage(const char* p_MessageBytes, int p_MessageLength) { int sendMessage(const char *p_MessageBytes, int p_MessageLength) {
if (m_ServerPort.length() <= 0) if (m_ServerPort.length() <= 0)
return -1; return -1;
int intResult; int intResult;
@@ -143,16 +143,16 @@ public:
return intResult; return intResult;
} }
int receiveMessage(int p_InetFamily, char* p_Buffer, int p_BufferLength, string* p_ServerIP); int receiveMessage(int p_InetFamily, char *p_Buffer, int p_BufferLength, string *p_ServerIP);
int setBroadcast(bool p_Broadcast); int setBroadcast(bool p_Broadcast);
int bindSocket(string p_ServerIP, string p_ClientIP, string p_ClientPort); int bindSocket(string p_ServerIP, string p_ClientIP, string p_ClientPort);
// * Internal usage - don't use this manually // * Internal usage - don't use this manually
// * Use sendMessage instead // * Use sendMessage instead
int sendMessageTo(int p_InetFamily, string p_ServerIP, string p_Port, const char* p_MessageBytes, int p_MessageLength); int sendMessageTo(int p_InetFamily, string p_ServerIP, string p_Port, const char *p_MessageBytes, int p_MessageLength);
string getServerIP() { return m_ServerIP; } string getServerIP() { return m_ServerIP; }
string getServerPort(){ return m_ServerPort; } string getServerPort() { return m_ServerPort; }
string getClientIP() { return m_ClientIP; } string getClientIP() { return m_ClientIP; }
string getClientPort() { return m_ClientPort; } string getClientPort() { return m_ClientPort; }
string getBoundClientPort() { return m_BoundClientPort; } string getBoundClientPort() { return m_BoundClientPort; }
@@ -164,4 +164,3 @@ public:
}; };
#endif /* SPITSOCKET_H */ #endif /* SPITSOCKET_H */
components/spit/include/SPITType.h
+30 -32
View File
@@ -24,38 +24,38 @@ using namespace std;
class SPITTypeListener; class SPITTypeListener;
class SPITType { class SPITType {
private: private:
static unordered_map<string, SPITType*> s_SPITTypes; static unordered_map<string, SPITType *> s_SPITTypes;
static unordered_map<string, SPITType*> s_SPITTypesRemote; static unordered_map<string, SPITType *> s_SPITTypesRemote;
public: public:
static SPITType* getSPITType(string p_ID); static SPITType *getSPITType(string p_ID);
static const SPITType& getSPITTypeRef(string p_ID); static const SPITType &getSPITTypeRef(string p_ID);
static bool addSPITType(SPITType* p_ptrSpitType); static bool addSPITType(SPITType *p_ptrSpitType);
static bool removeSPITType(SPITType* p_ptrSpitType); static bool removeSPITType(SPITType *p_ptrSpitType);
static int getSPITTypeCount(); static int getSPITTypeCount();
static SPITType* getSPITType(int p_Index); static SPITType *getSPITType(int p_Index);
static const SPITType& getSPITTypeRef(int p_Index); static const SPITType &getSPITTypeRef(int p_Index);
static void clearSPITTypes(); static void clearSPITTypes();
static void setConfirmedFalse(); static void setConfirmedFalse();
static SPITType* getSPITTypeRemote(string p_ID); static SPITType *getSPITTypeRemote(string p_ID);
static const SPITType& getSPITTypeRemoteRef(string p_ID); static const SPITType &getSPITTypeRemoteRef(string p_ID);
static bool addSPITTypeRemote(SPITType* p_ptrSpitType); static bool addSPITTypeRemote(SPITType *p_ptrSpitType);
static bool removeSPITTypeRemote(SPITType* p_ptrSpitType); static bool removeSPITTypeRemote(SPITType *p_ptrSpitType);
static int getSPITTypeRemoteCount(); static int getSPITTypeRemoteCount();
static SPITType* getSPITTypeRemote(int p_Index); static SPITType *getSPITTypeRemote(int p_Index);
static const SPITType& getSPITTypeRemoteRef(int p_Index); static const SPITType &getSPITTypeRemoteRef(int p_Index);
static void clearSPITTypesRemote(); static void clearSPITTypesRemote();
static void eventProjectClosed(); static void eventProjectClosed();
SPITType(); SPITType();
SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended,long long p_DefaultDelay, long long p_DefaultDuration); SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended, long long p_DefaultDelay, long long p_DefaultDuration);
// SPITType(const SPITType& orig); // SPITType(const SPITType& orig);
~SPITType(); ~SPITType();
private:
private:
bool m_Confirmed; bool m_Confirmed;
string m_ID; string m_ID;
bool m_Fixed; bool m_Fixed;
@@ -66,16 +66,16 @@ private:
long long m_DefaultDelay; long long m_DefaultDelay;
long long m_DefaultDuration; long long m_DefaultDuration;
bool m_CreatedByClient; //flag true = the SPITTyype is created by the client bool m_CreatedByClient; // flag true = the SPITTyype is created by the client
//false = the SPITType is received from the server // false = the SPITType is received from the server
bool m_ActionAssigned; //This is a virtual flag if user associates an action with a SPITType. bool m_ActionAssigned; // This is a virtual flag if user associates an action with a SPITType.
//Can be used to setActionAssigned for all SPITObjects with this SPITType // Can be used to setActionAssigned for all SPITObjects with this SPITType
void initMembers(); void initMembers();
public: public:
string getID() const{ return m_ID; } string getID() const { return m_ID; }
string getGroupName() const { return m_GroupName; } string getGroupName() const { return m_GroupName; }
string getName() const { return m_Name; } string getName() const { return m_Name; }
/** /**
@@ -110,8 +110,7 @@ public:
return m_ActionAssigned; return m_ActionAssigned;
} }
public:
public:
void setID(string p_ID); void setID(string p_ID);
bool setGroupName(string p_GroupName); bool setGroupName(string p_GroupName);
bool setName(string p_Name); bool setName(string p_Name);
@@ -132,11 +131,10 @@ public:
*/ */
bool setActionAssigned(bool p_ActionAssigned); bool setActionAssigned(bool p_ActionAssigned);
bool setMessageOP(SPIT_Message::ReportSPITType* p_ReportSPITType); bool setMessageOP(SPIT_Message::ReportSPITType *p_ReportSPITType);
void fillMessageOP(SPIT_Message::ReportSPITType* p_ReportSPITType); void fillMessageOP(SPIT_Message::ReportSPITType *p_ReportSPITType);
void fillMessageOP(SPIT_Message::RemoveSPITType* p_RemoveSPITType); void fillMessageOP(SPIT_Message::RemoveSPITType *p_RemoveSPITType);
// static char* stringCopy(const char* p_String); // static char* stringCopy(const char* p_String);
}; };
#endif /* SPITTYPE_H */ #endif /* SPITTYPE_H */
components/spit/include/SPIT_Client.h
+115 -104
View File
@@ -14,12 +14,12 @@
#ifndef SPIT_CLIENT_H #ifndef SPIT_CLIENT_H
#define SPIT_CLIENT_H #define SPIT_CLIENT_H
#include "SPITSocket.h"
#include "SAD_DetectedServer.hpp" #include "SAD_DetectedServer.hpp"
#include "SPIT_Message.h"
#include "SPITType.h"
#include "SPITObject.h" #include "SPITObject.h"
#include "SPITPlayer.h" #include "SPITPlayer.h"
#include "SPITSocket.h"
#include "SPITType.h"
#include "SPIT_Message.h"
#include <memory> #include <memory>
#include <vector> #include <vector>
@@ -27,40 +27,46 @@ using namespace std;
class SPIT_Client : I_SAD_Client { class SPIT_Client : I_SAD_Client {
public: public:
/** Maximal length of a SPITMessage*/ /** Maximal length of a SPITMessage*/
static const int MAXSPITMESSAGEBYTECOUNT = 512; static const int MAXSPITMESSAGEBYTECOUNT = 512;
enum ServerEvent { enum class ProjUpdate {
ServerLoaded,
StartTransfer,
EndTransfer,
ServerClosed,
};
enum class ServerEvent {
Detect, Detect,
Lost, Lost,
Changed, Changed,
}; };
enum class ObjectEvent {
struct Callbacks { Created,
void(*onServerEvent)(ServerEvent event, const SAD_DetectedServer &p_DetectedServer); Changed,
void(*onConnectionStatus)(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, int p_ConnectionStatus, int p_OldConnectionStatus); Deleted
void(*onStartProjectTransfer)();
void(*onEndProjectTransfer)();
void(*onProjectClosed)(string);
void(*onProjectReport)(string p_ProjectID, string p_ProjectName, int p_FramesPerSeoond);
void(*onSpitType)(bool p_New, const SPITType &p_SPITType);
void(*onSpitTypeRemote)(bool p_New, const SPITType &p_SPITType);
void(*onSpitObject)(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject);
void(*onSpitObjectRemote)(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject);
void(*onSpitTypeRemoved)(const SPITType &p_SPITType);
void(*onSpitTypeRemoteRemoved)(const SPITType &p_SPITType);
void(*onSpitObjectRemoved)(const SPITType &p_SPITType, const SPITObject &p_SPITObject);
void(*onSpitObjectRemoteRemoved)(const SPITType &p_SPITType, const SPITObject &p_SPITObject);
void(*onPlay)(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames);
void(*onPlaySpitType)(string p_PlayerID, string p_SPITTypeID, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value);
void(*onPlayRemoteObjectStatus)(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value);
bool(*onCheckSpitTypeVeto)(SPIT_Message::ReportSPITType* p_ReportSPITType);
bool(*onCheckSpitObjectVeto)(SPIT_Message::ReportSPITObject* p_ReportSPITObject);
}; };
//----- Connection Status ----- struct Callbacks {
public: void (*onServerEvent)(ServerEvent event, const SAD_DetectedServer &p_DetectedServer){};
void (*onConnectionStatus)(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, int p_ConnectionStatus, int p_OldConnectionStatus){};
void (*onProjectUpdate)(ProjUpdate state, string projectId){};
void (*onSpitType)(ObjectEvent event, const SPITType &p_SPITType){};
void (*onSpitTypeRemote)(ObjectEvent event, const SPITType &p_SPITType){};
void (*onSpitObject)(ObjectEvent event, const SPITType &p_SPITType, const SPITObject &p_SPITObject){};
void (*onSpitObjectRemote)(ObjectEvent event, const SPITType &p_SPITType, const SPITObject &p_SPITObject){};
void (*onPlay)(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames){};
void (*onPlaySpitType)(string p_PlayerID, string p_SPITTypeID, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value){};
void (*onPlayRemoteObjectStatus)(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value){};
bool (*onCheckSpitTypeVeto)(SPIT_Message::ReportSPITType *p_ReportSPITType){};
bool (*onCheckSpitObjectVeto)(SPIT_Message::ReportSPITObject *p_ReportSPITObject){};
};
//----- Connection Status -----
public:
/** No Connection established.<br>Either no connect tried or disconnected*/ /** No Connection established.<br>Either no connect tried or disconnected*/
static const int CONNECTION_NONE = 0; static const int CONNECTION_NONE = 0;
/** Server has disconnected*/ /** Server has disconnected*/
@@ -72,8 +78,8 @@ public:
/** A connection to the server is tried.*/ /** A connection to the server is tried.*/
static const int CONNECTION_TRYCONNECTION = 4; static const int CONNECTION_TRYCONNECTION = 4;
//------ PlayerType ------ //------ PlayerType ------
public: 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.*/ /** 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 const char PLAYERTYPE_MAIN = 0x02; static const char PLAYERTYPE_MAIN = 0x02;
/** continous player. This player plays SPIT objects sometime during the project.*/ /** continous player. This player plays SPIT objects sometime during the project.*/
@@ -81,9 +87,9 @@ public:
/** diescrete player. This player is used to transmit single discrete values.*/ /** diescrete player. This player is used to transmit single discrete values.*/
static const char PLAYERTYPE_DISCRETE = 0x00; static const char PLAYERTYPE_DISCRETE = 0x00;
//------ Value Flag ------ //------ Value Flag ------
//------ used by sendRemoteObject //------ used by sendRemoteObject
public: public:
/**Set the given value directly*/ /**Set the given value directly*/
static const char VALUEFLAG_DIRECT = 0x00; static const 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*/ /**Increase the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
@@ -91,19 +97,20 @@ public:
/**Decrease the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/ /**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 const char VALUEFLAG_DECREASE = 0x02; static const char VALUEFLAG_DECREASE = 0x02;
//----- SPIT_Client ----- //----- SPIT_Client -----
public: public:
SPIT_Client(string name, string projName, Callbacks calls); SPIT_Client(string name, string projName, Callbacks calls);
virtual ~SPIT_Client(); virtual ~SPIT_Client();
static int s_MAX_OVERTAKING_SPIT_MESSAGES; static int s_MAX_OVERTAKING_SPIT_MESSAGES;
private:
private:
Callbacks mCallbacks; Callbacks mCallbacks;
fos::TaskT<SPIT_Client&> * m_ThreadReceive{}; fos::TaskT<SPIT_Client &> *m_ThreadReceive{};
bool m_StopReceiveSPITMessages; bool m_StopReceiveSPITMessages;
int m_ConnectionStatus; int m_ConnectionStatus;
bool m_DisconnectedByServer{}; //flag true = when server disconnects bool m_DisconnectedByServer{}; // flag true = when server disconnects
string m_ID; string m_ID;
string m_Name; string m_Name;
string m_ProjName; string m_ProjName;
@@ -113,9 +120,9 @@ private:
unsigned char m_MessageNumber_Send; unsigned char m_MessageNumber_Send;
int m_MessageNumber_Received; int m_MessageNumber_Received;
vector<SPIT_Message*> m_OvertakingSPIT_Messages; vector<SPIT_Message *> m_OvertakingSPIT_Messages;
//Server's info filled by parseConnectAnswer // Server's info filled by parseConnectAnswer
string m_ServerID{}; string m_ServerID{};
string m_ServerName{}; string m_ServerName{};
string m_ServerComputerName{}; string m_ServerComputerName{};
@@ -126,7 +133,7 @@ private:
string m_ServerProjectName; string m_ServerProjectName;
int m_ServerFramesPerSecond; int m_ServerFramesPerSecond;
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 m_ID; } string getID() { return m_ID; }
/** The name of the client, should be set by the user app*/ /** The name of the client, should be set by the user app*/
@@ -137,7 +144,7 @@ public:
void setClientProjectName(string p_ClientProjectName) { m_ClientProjectName = p_ClientProjectName; } void setClientProjectName(string p_ClientProjectName) { m_ClientProjectName = p_ClientProjectName; }
string getClientProjectName() { return m_ClientProjectName; } string getClientProjectName() { return m_ClientProjectName; }
//connected Server Infos // connected Server Infos
/** The ID of the connected SPITServer*/ /** The ID of the connected SPITServer*/
string getServerID() { return m_ServerID; } string getServerID() { return m_ServerID; }
/** The host computername of the connected SPITServer*/ /** The host computername of the connected SPITServer*/
@@ -166,31 +173,31 @@ public:
void setActionSPITType(string p_SPITTypeID, bool p_ActionAssigned); void setActionSPITType(string p_SPITTypeID, bool p_ActionAssigned);
void setActionSPITObject(string p_SPITObjectID, bool p_ActionAssigned); void setActionSPITObject(string p_SPITObjectID, bool p_ActionAssigned);
//--------------- SPITMessage --------------- //--------------- SPITMessage ---------------
private: private:
bool startReceiveSPITMessages(); bool startReceiveSPITMessages();
void stopReceiveSPITMessages(); void stopReceiveSPITMessages();
static void receiveSPITMessage(SPIT_Client& rM); static void receiveSPITMessage(SPIT_Client &rM);
// 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 m_ServerID bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by m_ServerID
public: public:
void fillHeader(SPIT_Message::Header* p_Header); void fillHeader(SPIT_Message::Header *p_Header);
int sendSPITMessage(SPIT_Message::OPPart& p_SPITMessageOPPart); int sendSPITMessage(SPIT_Message::OPPart &p_SPITMessageOPPart);
//--------------- ServerAutoDetection SAD --------------- //--------------- ServerAutoDetection SAD ---------------
public: public:
/** 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.*/
void startServerAutoDetect(); void startServerAutoDetect();
/** Stops the autodetection of SPITServers in the local network*/ /** Stops the autodetection of SPITServers in the local network*/
void stopServerAutoDetect(); void stopServerAutoDetect();
/** Called every time a new SPITServer is detetced in the local network */ /** Called every time a new SPITServer is detetced in the local network */
void eventServerDetected(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4); void eventServerDetected(SAD_DetectedServer &server);
/** Called every time a prior detected SPITServer is is no longer found.*/ /** Called every time a prior detected SPITServer is is no longer found.*/
void eventServerLost(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4); void eventServerLost(SAD_DetectedServer &server);
void eventServerChanged(string p_ID, string p_Name, string p_ComputerName, string p_IP, string p_Port, string p_Addition, string p_ProjectName, string p_ClientIP, bool p_IsIP4); void eventServerChanged(SAD_DetectedServer &server);
//--------------- Connection --------------- //--------------- Connection ---------------
public: public:
/** /**
* Tries a connection to the SPITServer * Tries a connection to the SPITServer
* @param p_ServerIP ip address of the SPITServer * @param p_ServerIP ip address of the SPITServer
@@ -208,26 +215,28 @@ public:
*/ */
void disconnect(); void disconnect();
private: private:
void disconnectInternal(int p_Cause); void disconnectInternal(int p_Cause);
void resetMessageNumberReceived(); void resetMessageNumberReceived();
void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage); void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage); void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void addOvertakingSPIT_Message(SPIT_Message* p_SPIT_Message); void addOvertakingSPIT_Message(SPIT_Message *p_SPIT_Message);
void parseConnectAnswer(SPIT_Message::ConnectAnswer* p_ConnectAnswer); void parseConnectAnswer(SPIT_Message::ConnectAnswer *p_ConnectAnswer);
void parseDisconnect(SPIT_Message::Disconnect* p_Disconnect); void parseDisconnect(SPIT_Message::Disconnect *p_Disconnect);
void parseWatchdog(SPIT_Message::Watchdog* p_Watchdog); void parseWatchdog(SPIT_Message::Watchdog *p_Watchdog);
void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer* p_WatchdogAnswer); void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer *p_WatchdogAnswer);
public:
public:
/** Used internally*/ /** Used internally*/
void sendWatchdog(); void sendWatchdog();
/** 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: private:
void parseReportSPITProject(SPIT_Message::ReportSPITProject* p_ReportSPITProject); void parseReportSPITProject(SPIT_Message::ReportSPITProject *p_ReportSPITProject);
void parseCloseSPITProject(SPIT_Message::CloseSPITProject* p_CloseSPITProject); void parseCloseSPITProject(SPIT_Message::CloseSPITProject *p_CloseSPITProject);
public:
public:
/** Returns the SPITServer's project ID - may be the same as the project's name*/ /** Returns the SPITServer's project ID - may be the same as the project's name*/
string getServerProjectID(); string getServerProjectID();
/** Returns the SPITServer's project name*/ /** Returns the SPITServer's project name*/
@@ -235,15 +244,16 @@ public:
/** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/ /** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/
int getServerFramesPerSecond(); int getServerFramesPerSecond();
private: private:
void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer* p_RequestProjectTransfer); void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer *p_RequestProjectTransfer);
void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer* p_StartProjectTransfer); void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer *p_StartProjectTransfer);
void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer* p_EndProjectTransfer); void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer *p_EndProjectTransfer);
public:
static void sendProject(SPIT_Client* p_PtrSPIT_Client);
// --------------- SPIT Types --------------- public:
public: static void sendProject(SPIT_Client *p_PtrSPIT_Client);
// --------------- SPIT Types ---------------
public:
/** /**
* Creates a fixed SPITType for application actions that are always present and project independent.<br> * 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> * Fixed SPIT types cannot be changed or deleted by the server.<br>
@@ -255,7 +265,7 @@ public:
* @param p_DefaultDuration maybe the action has a default duration, 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. * @return the pointer to the new SPITType.
*/ */
SPITType* createSPITTypeFixed(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration); SPITType *createSPITTypeFixed(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration);
/** /**
* Creates a SPITType for application actions.<br> * Creates a SPITType for application actions.<br>
@@ -269,20 +279,22 @@ public:
* @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.
*/ */
SPITType* createSPITType(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration, bool p_Fixed, bool p_ProjectIndepended); SPITType *createSPITType(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration, bool p_Fixed, bool p_ProjectIndepended);
private:
//receive SPITTypes private:
void parseReportSPITType(SPIT_Message::ReportSPITType* p_ReportSPITType); // receive SPITTypes
void parseRemoveSPITType(SPIT_Message::RemoveSPITType* p_RemoveSPITType); void parseReportSPITType(SPIT_Message::ReportSPITType *p_ReportSPITType);
int sendSPITTypeInternal(SPITType* p_SPITType); void parseRemoveSPITType(SPIT_Message::RemoveSPITType *p_RemoveSPITType);
public: int sendSPITTypeInternal(SPITType *p_SPITType);
public:
/** /**
* If a client wants to change a SPITType, he should send it to the server.<br> * If a client wants to change a SPITType, he should send it to the server.<br>
* If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br> * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br>
* @param p_SPITTypeID the id of the SPITType to remove. * @param p_SPITTypeID the id of the SPITType to remove.
* @return 0 = is sended, -1 = is not sended * @return 0 = is sended, -1 = is not sended
*/ */
bool changeSPITType(SPITType* p_SPITType); bool changeSPITType(SPITType *p_SPITType);
/** /**
* If a client wants to remove a SPITType, he should send it to the server.<br> * If a client wants to remove a SPITType, he should send it to the server.<br>
* If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br> * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br>
@@ -290,21 +302,22 @@ public:
* @return 0 = is sended, -1 = is not sended * @return 0 = is sended, -1 = is not sended
*/ */
int removeSPITType(string p_SPITTypeID); int removeSPITType(string p_SPITTypeID);
public:
//--------------- SPIT Objects --------------- public:
private: //--------------- SPIT Objects ---------------
void parseReportSPITObject(SPIT_Message::ReportSPITObject* p_ReportSPITObject); private:
void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject* p_RemoveSPITObject); void parseReportSPITObject(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
int sendSPITObjectInternal(SPITObject* ptrSPITObject); void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject);
public: int sendSPITObjectInternal(SPITObject *ptrSPITObject);
public:
/** /**
* When the client changes a SPITObject (normally the client should not do this), then it should send the changes to the SPITServer.<br> * 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> * The SPITServer may discard the changes and an eventSPITObject occurs.<br>
* @param p_SPITObject the pointer to the changed SPITObject. * @param p_SPITObject the pointer to the changed SPITObject.
* @return 0 = sended, -1 = not sended * @return 0 = sended, -1 = not sended
*/ */
bool changeSPITObject(SPITObject* p_SPITObject); bool changeSPITObject(SPITObject *p_SPITObject);
/** /**
* When the client removes a SPITObject (normally the client should not do this), then he should send it to the SPITServer.<br> * 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> * The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
@@ -312,31 +325,29 @@ public:
* @return 0 = sended, -1 = not sended * @return 0 = sended, -1 = not sended
*/ */
int removeSPITObject(string p_SPITObjectID); int removeSPITObject(string p_SPITObjectID);
public:
//--------------- Play SPIT Objects --------------- public:
private: //--------------- Play SPIT Objects ---------------
void parsePlaySPITStart(SPIT_Message::PlaySPITStart* p_PlaySPITStart); private:
void parsePlaySPITObject(SPIT_Message::PlaySPITObject* p_PlaySPITObject); void parsePlaySPITStart(SPIT_Message::PlaySPITStart *p_PlaySPITStart);
void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd* p_PlaySPITEnd); void parsePlaySPITObject(SPIT_Message::PlaySPITObject *p_PlaySPITObject);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus* p_ReportPlayStatus); void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd *p_PlaySPITEnd);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_ReportPlayStatus);
public: public:
//--------- Remote ---------- //--------- Remote ----------
void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00); void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00);
private: private:
static void processSocketTask(SPIT_Client & instance); static void processSocketTask(SPIT_Client &instance);
fos::TaskT<SPIT_Client &>* sThread{}; fos::TaskT<SPIT_Client &> *sThread{};
bool abortSearch{}; bool abortSearch{};
bool sAnswered{}; bool sAnswered{};
static fos::Semaphore sStartSad; static fos::Semaphore sStartSad;
SPITSocket * mSPITSocket; SPITSocket *mSPITSocket;
void answerWatchdog() { void answerWatchdog() {
sAnswered = true; sAnswered = true;
} }
}; };
#endif /* SPIT_CLIENT_H */ #endif /* SPIT_CLIENT_H */
components/spit/include/SPIT_Message.h
+278 -367
View File
File diff suppressed because it is too large Load Diff
components/spit/src/MyApp.cpp
-452
View File
@@ -1,452 +0,0 @@
#include "MyApp.h"
#include "Task.hpp"
#include "esp_log.h"
#include "Semaphore.hpp"
#include "Queue.hpp"
#include <list>
const char *TAG = "SPIT";
MyApp::MyApp() :
_SpitClient (
s_ClientName, s_ProjectName,
{
.onServerEvent = onServerEvent,
.onConnectionStatus = onConnectionStatus,
.onStartProjectTransfer = onStartProjectTransfer,
.onEndProjectTransfer = onEndProjectTransfer,
.onProjectClosed = onProjectClosed,
.onProjectReport = onProjectReport,
.onSpitType = onSpitType,
.onSpitTypeRemote = onSpitTypeRemote,
.onSpitObject = onSpitObject,
.onSpitObjectRemote = onSpitObjectRemote,
.onSpitTypeRemoved = onSpitTypeRemoved,
.onSpitTypeRemoteRemoved = onSpitTypeRemoteRemoved,
.onSpitObjectRemoved = onSpitObjectRemoved,
.onSpitObjectRemoteRemoved = onSpitObjectRemoteRemoved,
.onPlay = onPlay,
.onPlaySpitType = onPlaySpitType,
.onPlayRemoteObjectStatus = onPlayRemoteObjectStatus,
.onCheckSpitTypeVeto = onCheckSpitTypeVeto,
.onCheckSpitObjectVeto = onCheckSpitObjectVeto,
}) {
}
string MyApp::m_ServerProjectID{};
string MyApp::m_ServerProjectName{};
int MyApp::m_ServerFramesPerSecond{44100}; // set when the server reports his project, see eventProjectReport
void MyApp::init() {
SPITType *ptrSPITType1Fix = _SpitClient.createSPITTypeFixed("MySPITAPP_Action1ID", "ActionGroupName", "Action1Name", 0, 0);
SPITType *ptrSPITType2Fix = _SpitClient.createSPITTypeFixed("MySPITAPP_Action2ID", "ActionGroupName", "Action2Name", 0, 0);
// When an action exist which should be done whenever a SPITObject with this SPITType is played,
// then you should 'setAssignedActionType' to true
_SpitClient.setActionSPITType(ptrSPITType1Fix->getID(), true);
_SpitClient.setActionSPITType(ptrSPITType2Fix->getID(), true);
_SpitClient.clientProjectLoaded();
_SpitClient.startServerAutoDetect();
}
void MyApp::onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_DetectedServer) {
switch (event)
{
case SPIT_Client::ServerEvent::Detect:
ESP_LOGI(TAG, "SERVER DETECTED");
ESP_LOGI(TAG, " Name: %s", p_DetectedServer.getName().data());
ESP_LOGI(TAG, " ID: %s", p_DetectedServer.getID().data());
ESP_LOGI(TAG, " Computer: %s", p_DetectedServer.getComputerName().data());
ESP_LOGI(TAG, " IP: %s", p_DetectedServer.getIP().data());
ESP_LOGI(TAG, " Port: %s", p_DetectedServer.getPort().data());
ESP_LOGI(TAG, " Addition: %s", p_DetectedServer.getAdditions().data());
ESP_LOGI(TAG, " ClientIP: %s", p_DetectedServer.getClientIP().data());
break;
case SPIT_Client::ServerEvent::Lost:
ESP_LOGW(TAG, "Server lost Name: %s IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
break;
case SPIT_Client::ServerEvent::Changed:
ESP_LOGW(TAG, "Server lost Name: %s IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
break;
default:
break;
}
}
//---------------------------------------
//---------- Connecting event ----------
void MyApp::onConnectionStatus(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, int p_ConnectionStatus, int p_OldConnectionStatus) {
ESP_LOGI(TAG, "MySPITApp: eventConnectionStatus %d ", p_ConnectionStatus);
}
//-----------------------------------------------------------
//---------- Server's Project events ------------------------
/**
* The Server reports his loaded project
* Called when
* a) the connection to the server is established.
* b) server load a new project
* c) server saves the project under a new name
* @param p_ProjectID the server project's id (maybe the filename of the project or a part o it or the same as p_ProjectName)
* @param p_ProjectName the server project's name
* @param p_FramesPerSeoond All times in SPIT are given in frames. FramesPerSecond can be used to convert frames to seconds....
*/
void MyApp::onProjectReport(string p_ProjectID, string p_ProjectName, int p_FramesPerSeoond) {
ESP_LOGI(TAG, "eventProjectReport ID: %s Name: %s FramesPerSecond: %d", p_ProjectID.data(), p_ProjectName.data(), p_FramesPerSeoond);
m_ServerProjectID = p_ProjectID;
m_ServerProjectName = p_ProjectName;
m_ServerFramesPerSecond = p_FramesPerSeoond;
// set the frames per second as the server - perhaps the client's time values have to be recalculated.
}
/**
* Called when the server closes his project.
* @param p_ProjectID the id of the project
* The server loads only one project at time-> the ID is not actually necessary
*/
void MyApp::onProjectClosed(string p_ProjectID) {
ESP_LOGI(TAG, "eventProjectClosed ID: %s", p_ProjectID.data());
// If we don't save SPITServer's project specific information
// perhaps close all SPITObjects and RemoteSPITObjects to avoid conflicts, when the SPITServer loads a new project
// SPITObject::clearSPITObjects();
// SPITObject::clearSPITObjectsRemote();
}
// The server starts the transfer of its project, that means
// All SPITTypes and SPITObjects available on the server are transferred in the following.
void MyApp::onStartProjectTransfer() {
ESP_LOGI(TAG, "eventStartProjectTransfer");
}
// The transfer of the server's SPITTypes and SPITObjects is finished.
void MyApp::onEndProjectTransfer() {
ESP_LOGI(TAG, "eventEndProjectTransfer");
}
//----------------------------------------------------
//--------- SPITType events ----------
/**
* The SPITCLientInterface (implemented by this) will be asked to veto the SPITType while SPIT_Client.parseReportSPITType.<br>
* @param p_ReportSPITType
* @return false = the SPITType is denied, true = the SPITType is accepted
*/
bool MyApp::onCheckSpitTypeVeto(SPIT_Message::ReportSPITType* p_ReportSPITType) {
if (p_ReportSPITType == NULL) return true;
SPITType* ptrSPITType;
ptrSPITType = SPITType::getSPITType(p_ReportSPITType->getID());
//Don't allow foreign SPITTypes
if (ptrSPITType == NULL) return false;
if (ptrSPITType->getCreatedByClient() == false) return false;
return true;
}
bool MyApp::onCheckSpitObjectVeto(SPIT_Message::ReportSPITObject* p_ReportSPITObject) {
if (p_ReportSPITObject == NULL) return true;
SPITType* ptrSPITType;
ptrSPITType = SPITType::getSPITType(p_ReportSPITObject->getSPITTypeID());
if (ptrSPITType == NULL) return false;
//Don't allow SPITObjects which refers to a SPITType which is not created by this client - other SPITTypes cannot be handled here
//if (ptrSPITType->getCreatedByClient() == false) return false;
// SPITObject* ptrSPITObject;
// ptrSPITObject = SPITObject::getSPITObject(p_ReportSPITOnject->getID());
//Don't allow foreign SPITTypes
// if (ptrSPITObject == NULL) return false;
return true;
}
/**
* Called when the server has created, loaded or changed a SPITType.
* May also occur when the server confirms a SPITType created or changed by the client.
* @param p_New true = server created a new SPITType
* false = server changed a existing SPITType
* @param p_SPITType a reference to a copy of the SPITType instance.
*/
void MyApp::onSpitType(bool p_New, const SPITType &p_SPITType) {
// fetch information of the SPITType
if (p_New) {
ESP_LOGD(TAG, "eventSPITType NEW");
} else {
ESP_LOGD(TAG, "eventSPITType CHANGED");
}
ESP_LOGI(TAG, " ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
// Check your actions
// Whenever you provide an action for this SPITType take this over in your code.
// call _SpitClient.setActionSPITType(p_SPITType.getID(), true);
// for our little excample as described in loadClientProject we do following
// This may be redundand, because we defined the SPITTypes as fixed, so the server can't change them
// But foe all SPITTypes which are not fixed we need to setActionSPITType
// if ("MySPITAPP_Action1ID" == p_SPITType.getID()) {
// _SpitClient.setActionSPITType(p_SPITType.getID(), true);
// }
// if ("MySPITAPP_Action2ID" == p_SPITType.getID()) {
// _SpitClient.setActionSPITType(p_SPITType.getID(), true);
// }
}
/**
* Called when the server has created or changed a Remote SPITType.
* Remote SPITType are used in Remote SPITObjects. A Remote SPITObject is used to remote control the SPITServer.
* @param p_New true = server created a new SPITType / false = server changed a existing SPITType
*/
void MyApp::onSpitTypeRemote(bool p_New, const SPITType &p_SPITType) {
if (p_New) {
ESP_LOGD(TAG, "eventSPITTypeRemote NEW");
} else {
// we had to inform all Remote SPITObjects using the p_SPITType
// perhaps the SPITObject uses information from the SPITType
SPITObject *ptrSPITObject;
int intSPITObjectCount;
intSPITObjectCount = SPITObject::getSPITObjectRemoteCount();
for (int intObject = 0; intObject < intSPITObjectCount; intObject++) {
ptrSPITObject = SPITObject::getSPITObjectRemote(intObject);
if (ptrSPITObject == NULL)
continue;
if (ptrSPITObject->getSPITTypeID() == p_SPITType.getID()) {
// call ecentSPITObjectRemote
onSpitObjectRemote(false, p_SPITType, *ptrSPITObject);
}
}
ESP_LOGD(TAG, "eventSPITTypeRemote CHANGED");
}
ESP_LOGD(TAG, "ID: %s GroupName: %s Name: %s confirmed: %d",
p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
// this is a remote SPITType, if you want you can list this for later remote use.
}
/**
* Called when the server has removed a SPITType.
* After this function has been exited the SPITType is emeoved from the SPITType-List and the pointer is deleted.
* So use the pointer immediately or use the copyconstructor to make a copy for extended use.
* You have to release the copy yourself later (delete ptr...)
*/
void MyApp::onSpitTypeRemoved(const SPITType &p_SPITType) {
ESP_LOGD(TAG, "eventSPITType Removed");
ESP_LOGD(TAG, " ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
// Check your actions
// take the removal of the SPITType over in your code
// CAUTION: Deleted SPIT types can be added later again (perhaps per UNDO on the SPITServer)
//-> don't remove your assigned action immediately - keep it to reassign it later
}
/**
* Called when the server has removed a Remote SPITType.
* Remote SPITType are used in Remote SPITObjects. A Remote SPITObject is used to remote control the SPITServer.
* After this function has been exited the SPITType is emeoved from the Remote SPITType-List and the pointer is deleted.
* So use the pointer immediately or use the copyconstructor to make a copy for extended use.
* You have to release the copy yourself later (delete ptr...)
* @param p_SPITType a reference to a copy of the SPITType instance.
*/
void MyApp::onSpitTypeRemoteRemoved(const SPITType &p_SPITType) {
ESP_LOGD(TAG, "eventSPITTypeRemote Removed");
ESP_LOGD(TAG, " ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
// This is a remote SPITType
// If you have listet this prior you should remove it from the list
}
/**
* Called when the server has created, loaded or changed a SPITObject.
* May also occur when the server confirms a SPITObject created by the client, what the client should never do!!.
* @param p_New true = server created a new SPITObject
* false = server changed a existing SPITObject
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void MyApp::onSpitObject(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
if (p_New) {
ESP_LOGI(TAG, "eventSPITObject NEW");
} else {
ESP_LOGD(TAG, "eventSPITObject CHANGED");
}
ESP_LOGI(TAG, " ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
// check your actions
// Whenever you provide an action for this SPITObject take this over in your code.
// call _SpitClient.setActionSPITObject(p_SPITObject.getID(), true);
// for our little excample as described in loadClientProject:
// We have only actions for SPITTypes - means every SPITObject with the associated "Actionx"-SPITTypes will trigger the action when it is played
//-> no need to do something here, because setActionSPITType has been set prior and the SPITObject will automatically inherits this
// SPITObjects with other SPITTypes asscciated will trigger no actions
}
/**
* Called when the server has created or changed a Remote SPITObject.
* A Remote SPITObject is used to remote control the SPITServer.
* @param p_New true = server created a new remote SPITObject
* false = server changed a existing remote SPITObject
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void MyApp::onSpitObjectRemote(bool p_New, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
if (p_New) {
ESP_LOGI(TAG, "eventSPITObjectRemote NEW");
} else {
ESP_LOGD(TAG, "eventSPITObjectRemote CHANGED");
}
ESP_LOGI(TAG, " ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
// This is a remote SPITObject which can be used to remote control the server.
// If you want you can list this for later use
}
/**
* Called when the server has removed a SPITObject.
* After this function has been exited the SPITObject is emeoved from the SPITObject-List and the pointer is deleted.
* So use the pointer immediately or use the copyconstructor to make a copy for extended use.
* You have to release the copy yourself later (delete ptr...)
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void MyApp::onSpitObjectRemoved(const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
ESP_LOGD(TAG, "eventSPITObject Removed");
ESP_LOGD(TAG, " ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
// Check your actions
// take the removal of the SPITObject over in your code
// CAUTION: Deleted SPITObjects can be added later again (perhaps per UNDO on the SPITServer)
//-> don't remove your assigned action immediately - keep it to reassign it later
}
/**
* Called when the server has removed a Remote SPITObject.
* A Remote SPITObject is used to remote control the SPITServer.
* After this function has been exited the SPITObject is emeoved from the SPITObject-List and the pointer is deleted.
* So use the pointer immediately or use the copyconstructor to make a copy for extended use.
* You have to release the copy yourself later (delete ptr...)
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void MyApp::onSpitObjectRemoteRemoved(const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
ESP_LOGD(TAG, "eventSPITObjectRemote Removed");
ESP_LOGD(TAG, " ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
// This is a remote SPITObject
// If you have listet this prior you should remove it from the list
}
//--------------------------------------------------------------
//---------------- Playing SPITObjects ----------------
// Following is called when the SPITServer play SPITObjects.
// For every step the server does following sequence occurs:
// a) eventPlay
// b) several eventPlayObject for each actual played SPITObjectin this step
// NEXT STAP of the server
// a) eventPlay
// b) several eventPlayObject for each actual played SPITObject in this step
// ...
// SPITServer may use several methods for playing SPITObjects.
// e.g. liveSHOWsoftware has the timeline and jingles which plays objects, where the timeline the main player is.
// SPIT distinguishes between the different players. All eventPlay... functions contain the information which player plays the SPIT object.
void MyApp::onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames) {
ESP_LOGD(TAG, "eventPlay Player: %s Runs: %d Time: %lld", p_PlayerName.data(), p_PlayerIsRunning, p_TimeFrames);
switch (p_PlayerType) {
case SPIT_Client::PLAYERTYPE_MAIN:
// p_FrameTimes contains the position inside the server's project, we can use it like a timecode
int intMilliseconds;
intMilliseconds = (int)(((double)p_TimeFrames / (double)m_ServerFramesPerSecond) * 1000);
break;
case SPIT_Client::PLAYERTYPE_CONTINOUS:
// The olayer is playing only single Object sequences sometime during the project
break;
case SPIT_Client::PLAYERTYPE_DISCRETE:
// Only discrete values where submitted, e.g the fader position of remote faders.
break;
}
}
/**
* Called when the SPITServer plays a SPITObject. For every played SPITObject one eventPlayObject is called.
* You can decide here which action should be done or not.
*
* @param p_Started true = The SPITObject is newly played (e.g. in liveSHOWsoftware the cursor enters the SPITObject)
* @param p_Ended Das true = Playback of SPITObject finished (e.g. in liveSHOWsoftware the cursor has exited the SPIT object)
* @param p_SPITType the associated SPITType of p_SPITObject
* @param p_SPITObject the actual played or stopped SPITObject
* @param p_PlayObject contains information about the play status:
* frame where the cursor is inside the SPITObject
* whether the player is running or not
* the actual value of the SPITObject (in liveSHOWsoftware objects ma faded in or out or the main value is decreased, ..
*/
void MyApp::onPlaySpitType(string p_PlayerID, string p_SPITTypeID, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value) {
// double doubleValue = ((double)p_PlayObject.getValue() / 1000000) * ((double)p_PlayObject.getValueFactor() / 1000000);
ESP_LOGD(TAG, "eventPlayObject Player: %s is running: %d Object Started: %d Stopped: %d", p_PlayerID.data(), p_PlayerIsRunning, p_Started, p_Ended);
// ESP_LOGD(TAG, " SPITType: %s SPITObject: %s Position: %lld Value: %f\n", p_SPITTypeID.data(), p_SPITObject.getName().data(), p_PlayObject.getFrameInside(), doubleValue);
ESP_LOGD(TAG, " SPITType: %s Value: %f\n", p_SPITTypeID.data(), p_Value);
if (p_SPITTypeID == "MySPITAPP_Action1ID") { // do Action 1
// we can get some information about the play status
if (p_Started == true) {
ESP_LOGI(TAG, "MyApp AKTION 1 started Value: %f and running: %d", p_Value, p_PlayerIsRunning);
} else if (p_Ended == true) {
ESP_LOGI(TAG, "MyApp AKTION 1 ended"); // p_PlayObject.getFrameInside() is -1
} else {
ESP_LOGD(TAG, "MyApp AKTION 1 is played Value: %f and running: %d", p_Value, p_PlayerIsRunning);
}
} else if (p_SPITTypeID == "MySPITAPP_Action2ID") { // do Action 2
if (p_Started == true) {
ESP_LOGI(TAG, "AKTION 2 started Value: %f and running: %d", p_Value, p_PlayerIsRunning);
} else if (p_Ended == true) {
ESP_LOGI(TAG, "AKTION 2 ended"); // p_PlayObject.getFrameInside() is -1
} else {
ESP_LOGD(TAG, "AKTION 2 is played Value: %f and running: %d", p_Value, p_PlayerIsRunning);
}
}
}
//--------------------------------------------------------------
//---------------- Remote Control SPITServer ----------------
// The SPITServer has sent all possibilities to control it remotely - remote SPITObjects - see eventSPITObjectRemote
// Some of them may control functionality with values (fader psotions for loudness of sound, ...).
// When the server changes one of these value objects, it sends an eventPlayRemoteObjectStatus.
/**
* Called when a remote SpitObject which value function is changed by the server.
* This allows the Client to adjust its display for the remote command.
* @param p_SPITType the assigned remote SPITType of p_SPITObject
* @param p_SPITObject the remote SPITObject which is changed
* @param p_FrameInsideObject can be discarded
* @param p_Value the new value
*/
void MyApp::onPlayRemoteObjectStatus(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value) {
ESP_LOGD(TAG, "eventPlayRemoteObjectStatus RemoteSPITType: %s RemoteSPITObject: %s Position: %lld Value: %d", p_SPITType.getName().data(), p_SPITObject.getName().data(), p_FrameInsideObject, p_Value);
}
/**
* 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 p_Valueppm the value in ppm
* in case a) the value is ignored
* in case b) the value is used
* @param p_ValueFlag indicates how the server should use p_Valueppm:
* VALUEFLAG_DIRECT (0x00) The server will overwrite his existing value with p_Value
* VALUEFLAG_INCREASE (0x01) The server increases his existing value by p_Valueppm
* VALUEFLAG_DECREASE (0x01) The server decreases his existing value by p_Valueppm
*/
void MyApp::sendRemoteObject(string p_SPITObjectID, int p_Valueppm, char p_ValueFlag) {
_SpitClient.sendRemoteObject(p_SPITObjectID, p_Valueppm, p_ValueFlag);
}
void MyApp::testLiveShowRemote() {
// We jump to the next Scenebridge - no Value is needed
_SpitClient.sendRemoteObject("playControlStart");
}
components/spit/src/SAD_DetectedServer.cpp
+38 -82
View File
@@ -15,9 +15,9 @@
#include "SAD_DetectedServer.hpp" #include "SAD_DetectedServer.hpp"
#include "esp_log.h" #include "esp_log.h"
static const char * TAG = "SpitSrv"; static const char *TAG = "SpitSrv";
unordered_map<string, SAD_DetectedServer*> SAD_DetectedServer::s_DetectedServers; unordered_map<string, SAD_DetectedServer *> SAD_DetectedServer::s_DetectedServers;
SAD_DetectedServer::~SAD_DetectedServer() { SAD_DetectedServer::~SAD_DetectedServer() {
} }
@@ -29,7 +29,6 @@ SAD_DetectedServer::SAD_DetectedServer() {
m_ClientIP = ""; m_ClientIP = "";
m_Port = ""; m_Port = "";
m_Additions = ""; m_Additions = "";
m_IPIsIP4 = false;
} }
void SAD_DetectedServer::setProjectName(string p_ServerProjectName) { void SAD_DetectedServer::setProjectName(string p_ServerProjectName) {
@@ -46,94 +45,43 @@ void SAD_DetectedServer::cycleStart() {
i->second->startCycleSAD(); i->second->startCycleSAD();
} }
} }
void SAD_DetectedServer::cycleEnd(I_SAD_Client& sadClient) { void SAD_DetectedServer::cycleEnd(I_SAD_Client &sadClient) {
list<SAD_DetectedServer*> o_LostServers; for (auto &srv : s_DetectedServers) {
list<SAD_DetectedServer*> o_NewServers; SAD_DetectedServer *ptrDetectedServer = srv.second;
list<SAD_DetectedServer*> o_ChangedServers;
SAD_DetectedServer* ptrDetectedServer;
{
for (auto i = s_DetectedServers.begin(); i != s_DetectedServers.end(); i++) {
ptrDetectedServer = i->second;
if (ptrDetectedServer->getFoundAgain() == false) { if (ptrDetectedServer->getFoundAgain() == false) {
o_LostServers.push_back(ptrDetectedServer); sadClient.eventServerLost(*ptrDetectedServer);
ptrDetectedServer->endCycleSAD(); removeDetectedServer(*ptrDetectedServer);
} } else if (ptrDetectedServer->getNew()) {
else if (ptrDetectedServer->getNew()) {
o_NewServers.push_back(ptrDetectedServer);
ptrDetectedServer->setNew(false); ptrDetectedServer->setNew(false);
ptrDetectedServer->endCycleSAD(); sadClient.eventServerDetected(*ptrDetectedServer);
} } else if (ptrDetectedServer->getChanged()) {
else if (ptrDetectedServer->getChanged()) { sadClient.eventServerChanged(*ptrDetectedServer);
o_ChangedServers.push_back(ptrDetectedServer);
ptrDetectedServer->endCycleSAD();
}
else {
ptrDetectedServer->endCycleSAD();
} }
} }
}
//Notify client interface about lost servers
for (auto i = o_LostServers.begin(); i != o_LostServers.end(); i++) {
ptrDetectedServer = *i;
sadClient.eventServerLost(ptrDetectedServer->getID(), ptrDetectedServer->getName(),
ptrDetectedServer->getComputerName(), ptrDetectedServer->getIP(), ptrDetectedServer->getPort(), ptrDetectedServer->getAdditions(),ptrDetectedServer->getProjectName(),
ptrDetectedServer->getClientIP(),
ptrDetectedServer->getIpIsIP4());
}
//Remove lost servers
for (auto i = o_LostServers.begin(); i != o_LostServers.end(); i++) {
ptrDetectedServer = *i;
removeDetectedServer(ptrDetectedServer);
}
o_LostServers.clear();
for (auto i = o_NewServers.begin(); i != o_NewServers.end(); i++) {
ptrDetectedServer = *i;
sadClient.eventServerDetected(ptrDetectedServer->getID(), ptrDetectedServer->getName(),
ptrDetectedServer->getComputerName(), ptrDetectedServer->getIP(), ptrDetectedServer->getPort(), ptrDetectedServer->getAdditions(),ptrDetectedServer->getProjectName(),
ptrDetectedServer->getClientIP(),
ptrDetectedServer->getIpIsIP4());
}
o_NewServers.clear();
for (auto i = o_ChangedServers.begin(); i != o_ChangedServers.end(); i++) {
ptrDetectedServer = *i;
sadClient.eventServerChanged(ptrDetectedServer->getID(), ptrDetectedServer->getName(),
ptrDetectedServer->getComputerName(), ptrDetectedServer->getIP(), ptrDetectedServer->getPort(), ptrDetectedServer->getAdditions(),ptrDetectedServer->getProjectName(),
ptrDetectedServer->getClientIP(),
ptrDetectedServer->getIpIsIP4());
}
o_ChangedServers.clear();
} }
/**
/**
* Used by SAD_Client to add a found SPITServer - don't use this manually * Used by SAD_Client to add a found SPITServer - don't use this manually
* @param p_IsIP4 true = the server is reached via a IP4 address<br>false = the server is reahed via a IP6 address * @param p_IsIP4 true = the server is reached via a IP4 address<br>false = the server is reahed via a IP6 address
* @param p_ServerID the id of the server, every instance of a SPITServer has an own id * @param p_ServerID the id of the server, every instance of a SPITServer has an own id
* @param p_ServerParams the server's parameter * @param p_ServerParams the server's parameter
*/ */
void SAD_DetectedServer::addDetectedServer(bool p_IsIP4, string p_ServerID, string p_ServerParams[]) { void SAD_DetectedServer::addDetectedServer(string p_ServerID, string p_ServerParams[]) {
SAD_DetectedServer* ptrDetectedServer; SAD_DetectedServer *ptrDetectedServer;
{ {
auto i = s_DetectedServers.find(p_ServerID); auto i = s_DetectedServers.find(p_ServerID);
if (i != s_DetectedServers.end()) { if (i != s_DetectedServers.end()) {
ptrDetectedServer = i->second; ptrDetectedServer = i->second;
} } else {
else {
ptrDetectedServer = new SAD_DetectedServer(); ptrDetectedServer = new SAD_DetectedServer();
ptrDetectedServer->setID(p_ServerParams[PARAMINDEX_ID]); ptrDetectedServer->setID(p_ServerParams[PARAMINDEX_ID]);
ptrDetectedServer->setNew(true); ptrDetectedServer->setNew(true);
} }
ptrDetectedServer->setFoundAgain(); ptrDetectedServer->setFoundAgain();
//second prefer IP4 // second prefer IP4
if (p_IsIP4 == true) {
ptrDetectedServer->setIP(p_ServerParams[PARAMINDEX_IP]);
ptrDetectedServer->setIPIsIP4(true);
ptrDetectedServer->setClientIP(p_ServerParams[PARAMINDEX_CLIENTIP]);
}
else if (ptrDetectedServer->getIpIsIP4() == false){
ptrDetectedServer->setIP(p_ServerParams[PARAMINDEX_IP]); ptrDetectedServer->setIP(p_ServerParams[PARAMINDEX_IP]);
ptrDetectedServer->setClientIP(p_ServerParams[PARAMINDEX_CLIENTIP]); ptrDetectedServer->setClientIP(p_ServerParams[PARAMINDEX_CLIENTIP]);
}
ptrDetectedServer->setName(p_ServerParams[PARAMINDEX_NAME]); ptrDetectedServer->setName(p_ServerParams[PARAMINDEX_NAME]);
ptrDetectedServer->setComputerName(p_ServerParams[PARAMINDEX_COMPUTERNAME]); ptrDetectedServer->setComputerName(p_ServerParams[PARAMINDEX_COMPUTERNAME]);
ptrDetectedServer->setPort(p_ServerParams[PARAMINDEX_PORT]); ptrDetectedServer->setPort(p_ServerParams[PARAMINDEX_PORT]);
@@ -142,36 +90,44 @@ void SAD_DetectedServer::addDetectedServer(bool p_IsIP4, string p_ServerID, stri
s_DetectedServers[ptrDetectedServer->getID()] = ptrDetectedServer; s_DetectedServers[ptrDetectedServer->getID()] = ptrDetectedServer;
} }
} }
/** /**
* Used by SAD_Client to remove a SPITServer - don't use this manually * Used by SAD_Client to remove a SPITServer - don't use this manually
* @param p_DetectedServer * @param p_DetectedServer
*/ */
void SAD_DetectedServer::removeDetectedServer(SAD_DetectedServer* p_DetectedServer) { void SAD_DetectedServer::removeDetectedServer(SAD_DetectedServer &server) {
SAD_DetectedServer* o_DetectedServer; auto i = s_DetectedServers.find(server.getID());
{
auto i = s_DetectedServers.find(p_DetectedServer->getID());
if (i != s_DetectedServers.end()) { if (i != s_DetectedServers.end()) {
o_DetectedServer = i->second; SAD_DetectedServer *o_DetectedServer = i->second;
i = s_DetectedServers.erase(i); i = s_DetectedServers.erase(i);
delete o_DetectedServer; delete o_DetectedServer;
} }
} }
}
/** /**
* Used by SAD_Client to clear all found SPITServers - don't use this manually * Used by SAD_Client to clear all found SPITServers - don't use this manually
*/ */
void SAD_DetectedServer::clearDetectedServers() { void SAD_DetectedServer::clearDetectedServers() {
SAD_DetectedServer* ptrDetectedServer;
{
for (auto i = s_DetectedServers.begin(); i != s_DetectedServers.end(); i++) { for (auto i = s_DetectedServers.begin(); i != s_DetectedServers.end(); i++) {
ptrDetectedServer = i->second; SAD_DetectedServer *ptrDetectedServer = i->second;
i = s_DetectedServers.erase(i); i = s_DetectedServers.erase(i);
delete ptrDetectedServer; delete ptrDetectedServer;
if (i == s_DetectedServers.end()) { if (i == s_DetectedServers.end()) {
break; break;
} }
} }
}
const SAD_DetectedServer &SAD_DetectedServer::getRefDetectedServer(string p_ServerID) {
SAD_DetectedServer *ptrDetectedServer = nullptr;
auto i = s_DetectedServers.find(p_ServerID);
if (i != s_DetectedServers.end()) {
ptrDetectedServer = i->second;
} }
if (ptrDetectedServer != NULL) {
return *ptrDetectedServer;
} }
throw new exception();
}
components/spit/src/SPITObject.cpp
+162 -131
View File
@@ -15,10 +15,10 @@
#include "SPITObject.h" #include "SPITObject.h"
#include "SPITSocket.h" #include "SPITSocket.h"
unordered_map<string, SPITObject*> SPITObject::s_SPITObjects; unordered_map<string, SPITObject *> SPITObject::s_SPITObjects;
unordered_map<string, SPITObject*> SPITObject::s_SPITObjectsRemote; unordered_map<string, SPITObject *> SPITObject::s_SPITObjectsRemote;
SPITObject* SPITObject::getSPITObject(string p_ID) { SPITObject *SPITObject::getSPITObject(string p_ID) {
{ {
auto i = s_SPITObjects.find(p_ID); auto i = s_SPITObjects.find(p_ID);
if (i == s_SPITObjects.end()) { if (i == s_SPITObjects.end()) {
@@ -26,14 +26,14 @@
} }
return i->second; return i->second;
} }
} }
/** /**
* Returns the reference of the SPITObject with ID == p_ID.<br> * Returns the reference of the SPITObject with ID == p_ID.<br>
* Throws an exception if no SPITObject is not found.<br> * Throws an exception if no SPITObject is not found.<br>
* @param p_ID the ID * @param p_ID the ID
* @return reference of the SPITType with ID == p_ID * @return reference of the SPITType with ID == p_ID
*/ */
const SPITObject& SPITObject::getSPITObjectRef(string p_ID) { const SPITObject &SPITObject::getSPITObjectRef(string p_ID) {
{ {
auto i = s_SPITObjects.find(p_ID); auto i = s_SPITObjects.find(p_ID);
if (i == s_SPITObjects.end()) { if (i == s_SPITObjects.end()) {
@@ -41,9 +41,9 @@
} }
return *(i->second); return *(i->second);
} }
} }
SPITObject* SPITObject::getSPITObjectRemote(string p_ID) { SPITObject *SPITObject::getSPITObjectRemote(string p_ID) {
{ {
auto i = s_SPITObjectsRemote.find(p_ID); auto i = s_SPITObjectsRemote.find(p_ID);
if (i == s_SPITObjectsRemote.end()) { if (i == s_SPITObjectsRemote.end()) {
@@ -51,14 +51,14 @@
} }
return i->second; return i->second;
} }
} }
/** /**
* Returns the reference of the remote SPITObject with ID == p_ID.<br> * Returns the reference of the remote SPITObject with ID == p_ID.<br>
* Throws an exception if no SPITObject is not found.<br> * Throws an exception if no SPITObject is not found.<br>
* @param p_ID the ID * @param p_ID the ID
* @return reference of the SPITType with ID == p_ID * @return reference of the SPITType with ID == p_ID
*/ */
const SPITObject& SPITObject::getSPITObjectRemoteRef(string p_ID) { const SPITObject &SPITObject::getSPITObjectRemoteRef(string p_ID) {
{ {
auto i = s_SPITObjectsRemote.find(p_ID); auto i = s_SPITObjectsRemote.find(p_ID);
if (i == s_SPITObjectsRemote.end()) { if (i == s_SPITObjectsRemote.end()) {
@@ -66,27 +66,30 @@
} }
return *(i->second); return *(i->second);
} }
} }
bool SPITObject::addSPITObject(SPITObject* p_ptrSPITObject) { bool SPITObject::addSPITObject(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false; if (p_ptrSPITObject == NULL)
return false;
{ {
s_SPITObjects[p_ptrSPITObject->getID()] = p_ptrSPITObject; s_SPITObjects[p_ptrSPITObject->getID()] = p_ptrSPITObject;
return true; return true;
} }
} }
bool SPITObject::addSPITObjectRemote(SPITObject* p_ptrSPITObject) { bool SPITObject::addSPITObjectRemote(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false; if (p_ptrSPITObject == NULL)
return false;
{ {
s_SPITObjectsRemote[p_ptrSPITObject->getID()] = p_ptrSPITObject; s_SPITObjectsRemote[p_ptrSPITObject->getID()] = p_ptrSPITObject;
return true; return true;
} }
} }
bool SPITObject::removeSPITObject(SPITObject* p_ptrSPITObject) { bool SPITObject::removeSPITObject(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false; if (p_ptrSPITObject == NULL)
return false;
return removeSPITObject(p_ptrSPITObject->getID()); return removeSPITObject(p_ptrSPITObject->getID());
} }
bool SPITObject::removeSPITObject(string p_SPITObjectID) { bool SPITObject::removeSPITObject(string p_SPITObjectID) {
{ {
auto i = s_SPITObjects.find(p_SPITObjectID); auto i = s_SPITObjects.find(p_SPITObjectID);
if (i == s_SPITObjects.end()) { if (i == s_SPITObjects.end()) {
@@ -95,12 +98,13 @@
i = s_SPITObjects.erase(i); i = s_SPITObjects.erase(i);
return true; return true;
} }
} }
bool SPITObject::removeSPITObjectRemote(SPITObject* p_ptrSPITObject) { bool SPITObject::removeSPITObjectRemote(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false; if (p_ptrSPITObject == NULL)
return false;
return removeSPITObjectRemote(p_ptrSPITObject->getID()); return removeSPITObjectRemote(p_ptrSPITObject->getID());
} }
bool SPITObject::removeSPITObjectRemote(string p_ptrSPITObject) { bool SPITObject::removeSPITObjectRemote(string p_ptrSPITObject) {
{ {
auto i = s_SPITObjectsRemote.find(p_ptrSPITObject); auto i = s_SPITObjectsRemote.find(p_ptrSPITObject);
if (i == s_SPITObjectsRemote.end()) { if (i == s_SPITObjectsRemote.end()) {
@@ -109,81 +113,77 @@
i = s_SPITObjectsRemote.erase(i); i = s_SPITObjectsRemote.erase(i);
return true; return true;
} }
} }
int SPITObject::getSPITObjectCount() { int SPITObject::getSPITObjectCount() {
return s_SPITObjects.size(); return s_SPITObjects.size();
} }
int SPITObject::getSPITObjectRemoteCount() { int SPITObject::getSPITObjectRemoteCount() {
return s_SPITObjectsRemote.size(); return s_SPITObjectsRemote.size();
} }
SPITObject* SPITObject::getSPITObject(int p_Index) { SPITObject *SPITObject::getSPITObject(int p_Index) {
SPITObject* ptrSPITObject = NULL; SPITObject *ptrSPITObject = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITObjects.size()) { if (p_Index >= 0 && p_Index < s_SPITObjects.size()) {
unordered_map<string, SPITObject*>::iterator i = next(s_SPITObjects.begin(), p_Index); unordered_map<string, SPITObject *>::iterator i = next(s_SPITObjects.begin(), p_Index);
ptrSPITObject = i->second; ptrSPITObject = i->second;
return ptrSPITObject; return ptrSPITObject;
} } else {
else {
return NULL; return NULL;
} }
} }
} }
/** /**
* Returns a reference to the SPITObject at position p_Index.<br> * Returns a reference to the SPITObject at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br> * Throws an exception if p_Index is out of range.<br>
* @param p_Index position * @param p_Index position
* @return the reference of the SPITObject at position. * @return the reference of the SPITObject at position.
*/ */
const SPITObject& SPITObject::getSPITObjectRef(int p_Index) { const SPITObject &SPITObject::getSPITObjectRef(int p_Index) {
SPITObject* ptrSPITObject = NULL; SPITObject *ptrSPITObject = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITObjects.size()) { if (p_Index >= 0 && p_Index < s_SPITObjects.size()) {
unordered_map<string, SPITObject*>::iterator i = next(s_SPITObjects.begin(), p_Index); unordered_map<string, SPITObject *>::iterator i = next(s_SPITObjects.begin(), p_Index);
ptrSPITObject = i->second; ptrSPITObject = i->second;
return *ptrSPITObject; return *ptrSPITObject;
} } else {
else {
throw "SPITObject index out of range"; throw "SPITObject index out of range";
} }
} }
} }
SPITObject* SPITObject::getSPITObjectRemote(int p_Index) { SPITObject *SPITObject::getSPITObjectRemote(int p_Index) {
SPITObject* ptrSPITObject = NULL; SPITObject *ptrSPITObject = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITObjectsRemote.size()) { if (p_Index >= 0 && p_Index < s_SPITObjectsRemote.size()) {
unordered_map<string, SPITObject*>::iterator i = next(s_SPITObjectsRemote.begin(), p_Index); unordered_map<string, SPITObject *>::iterator i = next(s_SPITObjectsRemote.begin(), p_Index);
ptrSPITObject = i->second; ptrSPITObject = i->second;
return ptrSPITObject; return ptrSPITObject;
} } else {
else {
return NULL; return NULL;
} }
} }
} }
/** /**
* Returns a reference to the remote SPITObject at position p_Index.<br> * Returns a reference to the remote SPITObject at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br> * Throws an exception if p_Index is out of range.<br>
* @param p_Index position * @param p_Index position
* @return the reference of the SPITObject at position. * @return the reference of the SPITObject at position.
*/ */
const SPITObject& SPITObject::getSPITObjectRemoteRef(int p_Index) { const SPITObject &SPITObject::getSPITObjectRemoteRef(int p_Index) {
SPITObject* ptrSPITObject = NULL; SPITObject *ptrSPITObject = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITObjectsRemote.size()) { if (p_Index >= 0 && p_Index < s_SPITObjectsRemote.size()) {
unordered_map<string, SPITObject*>::iterator i = next(s_SPITObjectsRemote.begin(), p_Index); unordered_map<string, SPITObject *>::iterator i = next(s_SPITObjectsRemote.begin(), p_Index);
ptrSPITObject = i->second; ptrSPITObject = i->second;
return *ptrSPITObject; return *ptrSPITObject;
} } else {
else {
throw "Remote SPITObject index out of range"; throw "Remote SPITObject index out of range";
} }
} }
} }
void SPITObject::clearSPITObjects() { void SPITObject::clearSPITObjects() {
SPITObject* ptrSPITObject; SPITObject *ptrSPITObject;
{ {
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) { for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
ptrSPITObject = i->second; ptrSPITObject = i->second;
@@ -194,9 +194,9 @@
} }
} }
} }
} }
void SPITObject::clearSPITObjectsRemote() { void SPITObject::clearSPITObjectsRemote() {
SPITObject* ptrSPITObject; SPITObject *ptrSPITObject;
{ {
for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) { for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) {
ptrSPITObject = i->second; ptrSPITObject = i->second;
@@ -207,14 +207,14 @@
} }
} }
} }
} }
/** /**
* clears all unconfirmed SPITObjects not created by this SPIT_Client. * clears all unconfirmed SPITObjects not created by this SPIT_Client.
*/ */
void SPITObject::clearUnconfirmedSPITObjects() { void SPITObject::clearUnconfirmedSPITObjects() {
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) { for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
SPITObject* ptrSPITObject = i->second; SPITObject *ptrSPITObject = i->second;
if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) { if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) {
i = s_SPITObjects.erase(i); i = s_SPITObjects.erase(i);
delete ptrSPITObject; delete ptrSPITObject;
@@ -223,11 +223,11 @@
break; break;
} }
} }
} }
void SPITObject::eventProjectClosed() { void SPITObject::eventProjectClosed() {
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) { for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
SPITObject* ptrSPITObject = i->second; SPITObject *ptrSPITObject = i->second;
if (ptrSPITObject->getCreatedByClient() == true) { if (ptrSPITObject->getCreatedByClient() == true) {
continue; continue;
} }
@@ -237,31 +237,29 @@
break; break;
} }
} }
//Remote // Remote
for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) { for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) {
SPITObject* ptrSPITObject = i->second; SPITObject *ptrSPITObject = i->second;
i = s_SPITObjectsRemote.erase(i); i = s_SPITObjectsRemote.erase(i);
delete ptrSPITObject; delete ptrSPITObject;
if (i == s_SPITObjectsRemote.end()) { if (i == s_SPITObjectsRemote.end()) {
break; break;
} }
} }
} }
/** /**
* sets confirmed = false for all SPITObjects.<br> * sets confirmed = false for all SPITObjects.<br>
* This should be called when the client has loaded a project.<br> * This should be called when the client has loaded a project.<br>
*/ */
void SPITObject::setConfirmedFalse() { void SPITObject::setConfirmedFalse() {
SPITObject* ptrSPITObject; SPITObject *ptrSPITObject;
{ {
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) { for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
ptrSPITObject = i->second; ptrSPITObject = i->second;
ptrSPITObject->setConfirmed(false); ptrSPITObject->setConfirmed(false);
} }
} }
} }
SPITObject::SPITObject() { SPITObject::SPITObject() {
initMembers(); initMembers();
@@ -285,119 +283,132 @@ void SPITObject::initMembers() {
m_ServerParams = ""; m_ServerParams = "";
m_ServerRemote = false; m_ServerRemote = false;
m_Track = 0; m_Track = 0;
m_ValueFactor = 1000000; //Values are given in ppm -> 1000000 = 1/1; m_ValueFactor = 1000000; // Values are given in ppm -> 1000000 = 1/1;
m_ValueUse = 0x01; m_ValueUse = 0x01;
} }
SPITObject::~SPITObject() { } SPITObject::~SPITObject() {}
bool SPITObject::setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
bool SPITObject::setMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject) {
bool boolChangeAllowed; bool boolChangeAllowed;
bool boolChanged = false; bool boolChanged = false;
if (m_CreatedByClient == true && m_Fixed == true) { if (m_CreatedByClient == true && m_Fixed == true) {
boolChangeAllowed = false; boolChangeAllowed = false;
} } else {
else {
boolChangeAllowed = true; boolChangeAllowed = true;
} }
//Confirmation should be changable // Confirmation should be changable
if (m_CreatedByClient) { if (m_CreatedByClient) {
//Server reports a client created SPITType -> the type is confirmed // Server reports a client created SPITType -> the type is confirmed
m_Confirmed = true; m_Confirmed = true;
} } else {
else { // type is NOT client created -> the client has to confirm the SPITtype
//type is NOT client created -> the client has to confirm the SPITtype
m_Confirmed = p_ReportSPITObject->getConfirmed(); m_Confirmed = p_ReportSPITObject->getConfirmed();
} }
if (m_Delay != p_ReportSPITObject->getDelay()) { if (m_Delay != p_ReportSPITObject->getDelay()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Delay = p_ReportSPITObject->getDelay(); m_Delay = p_ReportSPITObject->getDelay();
boolChanged = true; boolChanged = true;
} }
if (m_Duration != p_ReportSPITObject->getDuration()) { if (m_Duration != p_ReportSPITObject->getDuration()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Duration = p_ReportSPITObject->getDuration(); m_Duration = p_ReportSPITObject->getDuration();
boolChanged = true; boolChanged = true;
} }
if (m_Fixed != p_ReportSPITObject->getFixed()) { if (m_Fixed != p_ReportSPITObject->getFixed()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Fixed = p_ReportSPITObject->getFixed(); m_Fixed = p_ReportSPITObject->getFixed();
boolChanged = true; boolChanged = true;
} }
if (m_FrameFadeInLength != p_ReportSPITObject->getFrameFadeInLength()) { if (m_FrameFadeInLength != p_ReportSPITObject->getFrameFadeInLength()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_FrameFadeInLength = p_ReportSPITObject->getFrameFadeInLength(); m_FrameFadeInLength = p_ReportSPITObject->getFrameFadeInLength();
boolChanged= true; boolChanged = true;
} }
if (m_FrameFadeOutLength != p_ReportSPITObject->getFrameFadeOutLength()) { if (m_FrameFadeOutLength != p_ReportSPITObject->getFrameFadeOutLength()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_FrameFadeOutLength = p_ReportSPITObject->getFrameFadeOutLength(); m_FrameFadeOutLength = p_ReportSPITObject->getFrameFadeOutLength();
boolChanged = true; boolChanged = true;
} }
if (m_FrameLength != p_ReportSPITObject->getFrameLength()) { if (m_FrameLength != p_ReportSPITObject->getFrameLength()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_FrameLength = p_ReportSPITObject->getFrameLength(); m_FrameLength = p_ReportSPITObject->getFrameLength();
boolChanged = true; boolChanged = true;
} }
if (m_FrameStart != p_ReportSPITObject->getFrameStart()) { if (m_FrameStart != p_ReportSPITObject->getFrameStart()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_FrameStart = p_ReportSPITObject->getFrameStart(); m_FrameStart = p_ReportSPITObject->getFrameStart();
boolChanged = true; boolChanged = true;
} }
if (m_Remark != p_ReportSPITObject->getRemark()) { if (m_Remark != p_ReportSPITObject->getRemark()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Remark = p_ReportSPITObject->getRemark(); m_Remark = p_ReportSPITObject->getRemark();
boolChanged = true; boolChanged = true;
} }
if (m_ID != p_ReportSPITObject->getID()) { if (m_ID != p_ReportSPITObject->getID()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ID = p_ReportSPITObject->getID(); m_ID = p_ReportSPITObject->getID();
boolChanged = true; boolChanged = true;
} }
if (m_Name != p_ReportSPITObject->getName()) { if (m_Name != p_ReportSPITObject->getName()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Name = p_ReportSPITObject->getName(); m_Name = p_ReportSPITObject->getName();
boolChanged = true; boolChanged = true;
} }
if (m_SPITTypeID != p_ReportSPITObject->getSPITTypeID()) { if (m_SPITTypeID != p_ReportSPITObject->getSPITTypeID()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_SPITTypeID = p_ReportSPITObject->getSPITTypeID(); m_SPITTypeID = p_ReportSPITObject->getSPITTypeID();
boolChanged = true; boolChanged = true;
} }
if (m_ServerParams != p_ReportSPITObject->getServerParams()) { if (m_ServerParams != p_ReportSPITObject->getServerParams()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ServerParams = p_ReportSPITObject->getServerParams(); m_ServerParams = p_ReportSPITObject->getServerParams();
boolChanged = true; boolChanged = true;
} }
if (m_ServerRemote != p_ReportSPITObject->getServerRemote()) { if (m_ServerRemote != p_ReportSPITObject->getServerRemote()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ServerRemote = p_ReportSPITObject->getServerRemote(); m_ServerRemote = p_ReportSPITObject->getServerRemote();
boolChanged = true; boolChanged = true;
} }
if (m_Track != p_ReportSPITObject->getTrack()) { if (m_Track != p_ReportSPITObject->getTrack()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Track = p_ReportSPITObject->getTrack(); m_Track = p_ReportSPITObject->getTrack();
boolChanged = true; boolChanged = true;
} }
if (m_ValueFactor != p_ReportSPITObject->getValueFactor()) { if (m_ValueFactor != p_ReportSPITObject->getValueFactor()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ValueFactor = p_ReportSPITObject->getValueFactor(); m_ValueFactor = p_ReportSPITObject->getValueFactor();
boolChanged = true; boolChanged = true;
} }
if (m_ValueUse != p_ReportSPITObject->getValueUse()) { if (m_ValueUse != p_ReportSPITObject->getValueUse()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ValueUse = p_ReportSPITObject->getValueUse(); m_ValueUse = p_ReportSPITObject->getValueUse();
boolChanged = true; boolChanged = true;
} }
return boolChanged; return boolChanged;
} }
void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject) { void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
p_ReportSPITObject->setActionAssigned(getActionAssigned()); //Action can be assigned to type or to this object p_ReportSPITObject->setActionAssigned(getActionAssigned()); // Action can be assigned to type or to this object
p_ReportSPITObject->setConfirmed(m_Confirmed); p_ReportSPITObject->setConfirmed(m_Confirmed);
p_ReportSPITObject->setDelay(m_Delay); p_ReportSPITObject->setDelay(m_Delay);
p_ReportSPITObject->setDuration(m_Duration); p_ReportSPITObject->setDuration(m_Duration);
@@ -416,7 +427,7 @@ void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObjec
p_ReportSPITObject->setValueFactor(m_ValueFactor); p_ReportSPITObject->setValueFactor(m_ValueFactor);
p_ReportSPITObject->setValueUse(m_ValueUse); p_ReportSPITObject->setValueUse(m_ValueUse);
} }
void SPITObject::fillMessageOP(SPIT_Message::RemoveSPITObject* p_RemoveSPITObject) { void SPITObject::fillMessageOP(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject) {
p_RemoveSPITObject->setID(m_ID); p_RemoveSPITObject->setID(m_ID);
} }
@@ -433,121 +444,141 @@ void SPITObject::setCreatedByClient(bool p_CreatedByClient) {
* @return if m_Confirmed has changed * @return if m_Confirmed has changed
*/ */
bool SPITObject::setConfirmed(bool p_Confirmed) { bool SPITObject::setConfirmed(bool p_Confirmed) {
if (m_Confirmed == p_Confirmed) return false; if (m_Confirmed == p_Confirmed)
return false;
m_Confirmed = p_Confirmed; m_Confirmed = p_Confirmed;
return true; return true;
} }
bool SPITObject::setName(string p_Name) { bool SPITObject::setName(string p_Name) {
if (m_Name == p_Name) return false; if (m_Name == p_Name)
return false;
m_Name = p_Name; m_Name = p_Name;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setRemark(string p_Remark) { bool SPITObject::setRemark(string p_Remark) {
if (m_Remark == p_Remark) return false; if (m_Remark == p_Remark)
return false;
m_Remark = p_Remark; m_Remark = p_Remark;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setServerParams(string p_ServerParams) { bool SPITObject::setServerParams(string p_ServerParams) {
if (m_ServerParams == p_ServerParams) return false; if (m_ServerParams == p_ServerParams)
return false;
m_ServerParams = p_ServerParams; m_ServerParams = p_ServerParams;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setSPITTypeID(string p_SPITTypeID) { bool SPITObject::setSPITTypeID(string p_SPITTypeID) {
if (m_SPITTypeID == p_SPITTypeID) return false; if (m_SPITTypeID == p_SPITTypeID)
return false;
m_SPITTypeID = p_SPITTypeID; m_SPITTypeID = p_SPITTypeID;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setServerRemote(bool p_BelongstoServer) { bool SPITObject::setServerRemote(bool p_BelongstoServer) {
if (m_ServerRemote == p_BelongstoServer) return false; if (m_ServerRemote == p_BelongstoServer)
return false;
m_ServerRemote = p_BelongstoServer; m_ServerRemote = p_BelongstoServer;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
/** /**
* This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.<br> * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.<br>
* This is used when an action is associated with a SPITType. <br> * This is used when an action is associated with a SPITType. <br>
* Then this action is done for every SPITObject with the SPITType. * Then this action is done for every SPITObject with the SPITType.
* @return true = an action is assigned for the SPITType. * @return true = an action is assigned for the SPITType.
*/ */
bool SPITObject::setActionAssignedType(bool p_ActionAssigned) { bool SPITObject::setActionAssignedType(bool p_ActionAssigned) {
if (m_ActionAssignedType == p_ActionAssigned) return false; if (m_ActionAssignedType == p_ActionAssigned)
return false;
bool boolOldActionAssigend; bool boolOldActionAssigend;
boolOldActionAssigend = getActionAssigned(); boolOldActionAssigend = getActionAssigned();
m_ActionAssignedType = p_ActionAssigned; m_ActionAssignedType = p_ActionAssigned;
if (getActionAssigned() == boolOldActionAssigend) return false; if (getActionAssigned() == boolOldActionAssigend)
return false;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setActionAssigned(bool p_ActionAssigned) { bool SPITObject::setActionAssigned(bool p_ActionAssigned) {
if (m_ActionAssigned == p_ActionAssigned) return false; if (m_ActionAssigned == p_ActionAssigned)
return false;
bool boolOldActionAssigend; bool boolOldActionAssigend;
boolOldActionAssigend = getActionAssigned(); boolOldActionAssigend = getActionAssigned();
m_ActionAssigned = p_ActionAssigned; m_ActionAssigned = p_ActionAssigned;
if (getActionAssigned() == boolOldActionAssigend) return false; if (getActionAssigned() == boolOldActionAssigend)
return false;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setFixed(bool p_Fixed) { bool SPITObject::setFixed(bool p_Fixed) {
if (m_Fixed == p_Fixed) return false; if (m_Fixed == p_Fixed)
return false;
m_Fixed = p_Fixed; m_Fixed = p_Fixed;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setFrameStart(long long p_FrameStart) { bool SPITObject::setFrameStart(long long p_FrameStart) {
if (m_FrameStart == p_FrameStart) return false; if (m_FrameStart == p_FrameStart)
return false;
m_FrameStart = p_FrameStart; m_FrameStart = p_FrameStart;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setFrameLength(long long p_FrameLength) { bool SPITObject::setFrameLength(long long p_FrameLength) {
if (m_FrameLength == p_FrameLength) return false; if (m_FrameLength == p_FrameLength)
return false;
m_FrameLength = p_FrameLength; m_FrameLength = p_FrameLength;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setFrameFadeInLength(long long p_FrameFadeInLength) { bool SPITObject::setFrameFadeInLength(long long p_FrameFadeInLength) {
if (m_FrameFadeInLength == p_FrameFadeInLength) return false; if (m_FrameFadeInLength == p_FrameFadeInLength)
return false;
m_FrameFadeInLength = p_FrameFadeInLength; m_FrameFadeInLength = p_FrameFadeInLength;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setFrameFadeOutLength(long long p_FrameFadeOutLength) { bool SPITObject::setFrameFadeOutLength(long long p_FrameFadeOutLength) {
if (m_FrameFadeOutLength == p_FrameFadeOutLength) return false; if (m_FrameFadeOutLength == p_FrameFadeOutLength)
return false;
m_FrameFadeOutLength = p_FrameFadeOutLength; m_FrameFadeOutLength = p_FrameFadeOutLength;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setValueUse(char p_ValueUse) { bool SPITObject::setValueUse(char p_ValueUse) {
if (m_ValueUse == p_ValueUse) return false; if (m_ValueUse == p_ValueUse)
return false;
m_ValueUse = p_ValueUse; m_ValueUse = p_ValueUse;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setValueFactor(int p_ValueFactor) { bool SPITObject::setValueFactor(int p_ValueFactor) {
if (m_ValueFactor == p_ValueFactor) return false; if (m_ValueFactor == p_ValueFactor)
return false;
m_ValueFactor = p_ValueFactor; m_ValueFactor = p_ValueFactor;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setTrack(int p_Track) { bool SPITObject::setTrack(int p_Track) {
if (m_Track == p_Track) return false; if (m_Track == p_Track)
return false;
m_Track = p_Track; m_Track = p_Track;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setDelay(long long p_Delay) { bool SPITObject::setDelay(long long p_Delay) {
if (m_Delay == p_Delay) return false; if (m_Delay == p_Delay)
return false;
m_Delay = p_Delay; m_Delay = p_Delay;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITObject::setDuration(long long p_Duration) { bool SPITObject::setDuration(long long p_Duration) {
if (m_Duration == p_Duration) return false; if (m_Duration == p_Duration)
return false;
m_Duration = p_Duration; m_Duration = p_Duration;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
components/spit/src/SPITPlayer.cpp
+16 -19
View File
@@ -15,29 +15,30 @@
#include "SPITPlayer.h" #include "SPITPlayer.h"
#include <vector> #include <vector>
unordered_map<string, SPITPlayer*> SPITPlayer::s_SPITPlayers; unordered_map<string, SPITPlayer *> SPITPlayer::s_SPITPlayers;
SPITPlayer* SPITPlayer::getSPITPlayer(string p_PlayerID) { SPITPlayer *SPITPlayer::getSPITPlayer(string p_PlayerID) {
{ {
auto i = s_SPITPlayers.find(p_PlayerID); auto i = s_SPITPlayers.find(p_PlayerID);
if (i == s_SPITPlayers.end()) { if (i == s_SPITPlayers.end()) {
s_SPITPlayers[p_PlayerID] = new SPITPlayer(p_PlayerID); s_SPITPlayers[p_PlayerID] = new SPITPlayer(p_PlayerID);
} }
i = s_SPITPlayers.find(p_PlayerID); i = s_SPITPlayers.find(p_PlayerID);
if (i == s_SPITPlayers.end()) return NULL; if (i == s_SPITPlayers.end())
return NULL;
return i->second; return i->second;
} }
} }
void SPITPlayer::clearPlayers() { void SPITPlayer::clearPlayers() {
; ;
vector<SPITPlayer*> o_SPITPlayers; vector<SPITPlayer *> o_SPITPlayers;
for (auto i = s_SPITPlayers.begin(); i != s_SPITPlayers.end(); i++) { for (auto i = s_SPITPlayers.begin(); i != s_SPITPlayers.end(); i++) {
SPITPlayer* ptrSPITPlayer = i->second; SPITPlayer *ptrSPITPlayer = i->second;
o_SPITPlayers.push_back(ptrSPITPlayer); o_SPITPlayers.push_back(ptrSPITPlayer);
} }
for (auto i = o_SPITPlayers.begin(); i != o_SPITPlayers.end(); i++) { for (auto i = o_SPITPlayers.begin(); i != o_SPITPlayers.end(); i++) {
SPITPlayer* ptrSPITPlayer = *i; SPITPlayer *ptrSPITPlayer = *i;
delete ptrSPITPlayer; delete ptrSPITPlayer;
} }
o_SPITPlayers.clear(); o_SPITPlayers.clear();
@@ -49,7 +50,7 @@ SPITPlayer::SPITPlayer(string p_PlayerID) {
} }
SPITPlayer::~SPITPlayer() { SPITPlayer::~SPITPlayer() {
PlaySPITType* ptrPlaySPITType; PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) { for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second; ptrPlaySPITType = i->second;
i = m_PlaySPITTypes.erase(i); i = m_PlaySPITTypes.erase(i);
@@ -58,7 +59,6 @@ SPITPlayer::~SPITPlayer() {
break; break;
} }
} }
} }
void SPITPlayer::setIsRunning(bool p_IsRunning) { void SPITPlayer::setIsRunning(bool p_IsRunning) {
@@ -74,7 +74,7 @@ void SPITPlayer::setTime(long long p_Frames) {
m_TimeFrames = p_Frames; m_TimeFrames = p_Frames;
} }
unordered_map<string, SPITPlayer::PlaySPITType*>* SPITPlayer::getPlaySPITTypes() { unordered_map<string, SPITPlayer::PlaySPITType *> *SPITPlayer::getPlaySPITTypes() {
return &m_PlaySPITTypes; return &m_PlaySPITTypes;
} }
/** /**
@@ -83,8 +83,8 @@ unordered_map<string, SPITPlayer::PlaySPITType*>* SPITPlayer::getPlaySPITTypes()
* @return true = new PlayObject added<br> * @return true = new PlayObject added<br>
* false = PlayObject exists * false = PlayObject exists
*/ */
SPITPlayer::PlaySPITType* SPITPlayer::addSPITType_Playing (string p_SPITTypeID) { SPITPlayer::PlaySPITType *SPITPlayer::addSPITType_Playing(string p_SPITTypeID) {
PlaySPITType* ptrPlaySPITType; PlaySPITType *ptrPlaySPITType;
auto i = m_PlaySPITTypes.find(p_SPITTypeID); auto i = m_PlaySPITTypes.find(p_SPITTypeID);
if (i == m_PlaySPITTypes.end()) { if (i == m_PlaySPITTypes.end()) {
@@ -92,17 +92,15 @@ SPITPlayer::PlaySPITType* SPITPlayer::addSPITType_Playing (string p_SPITTypeID)
ptrPlaySPITType->setIsPlayed(true); ptrPlaySPITType->setIsPlayed(true);
ptrPlaySPITType->setIsNew(true); ptrPlaySPITType->setIsNew(true);
m_PlaySPITTypes[p_SPITTypeID] = ptrPlaySPITType; m_PlaySPITTypes[p_SPITTypeID] = ptrPlaySPITType;
} } else {
else {
ptrPlaySPITType = i->second; ptrPlaySPITType = i->second;
ptrPlaySPITType->setIsPlayed(true); ptrPlaySPITType->setIsPlayed(true);
} }
return ptrPlaySPITType; return ptrPlaySPITType;
} }
void SPITPlayer::startPlaySequence() { void SPITPlayer::startPlaySequence() {
PlaySPITType* ptrPlaySPITType; PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) { for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second; ptrPlaySPITType = i->second;
ptrPlaySPITType->startPlaySequence(); ptrPlaySPITType->startPlaySequence();
@@ -110,7 +108,7 @@ void SPITPlayer::startPlaySequence() {
} }
void SPITPlayer::endPlaySequence() { void SPITPlayer::endPlaySequence() {
PlaySPITType* ptrPlaySPITType; PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) { for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second; ptrPlaySPITType = i->second;
@@ -122,19 +120,18 @@ void SPITPlayer::endPlaySequence() {
} }
} }
} }
} }
SPITPlayer::PlaySPITType::PlaySPITType() { SPITPlayer::PlaySPITType::PlaySPITType() {
} }
SPITPlayer::PlaySPITType::PlaySPITType(SPITPlayer* p_SPITPlayer, string p_SPITTypeID) { SPITPlayer::PlaySPITType::PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITTypeID) {
m_SPITTypeID = p_SPITTypeID; m_SPITTypeID = p_SPITTypeID;
m_PlayerID = p_SPITPlayer->getID(); m_PlayerID = p_SPITPlayer->getID();
m_PlayerName = p_SPITPlayer->getName(); m_PlayerName = p_SPITPlayer->getName();
startPlaySequence(); startPlaySequence();
m_IsNew = true; m_IsNew = true;
} }
SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType& orig) { SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType &orig) {
m_SPITTypeID = orig.getSPITTypeID(); m_SPITTypeID = orig.getSPITTypeID();
m_IsPlayed = orig.getIsPlayed(); m_IsPlayed = orig.getIsPlayed();
m_IsNew = orig.getIsNew(); m_IsNew = orig.getIsNew();
components/spit/src/SPITSocket.cpp
+7 -7
View File
@@ -15,11 +15,11 @@
#include "SPITSocket.h" #include "SPITSocket.h"
#include "Task.hpp" #include "Task.hpp"
#include "esp/uuid.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_netif.h" #include "esp_netif.h"
#include "esp/uuid.h"
#include <unistd.h>
#include <string> #include <string>
#include <unistd.h>
using namespace std; using namespace std;
/** /**
@@ -201,7 +201,7 @@ int SPITSocket::sendMessageTo(int p_InetFamily, string p_ServerIP, string p_Serv
} }
return 0; return 0;
} }
/** /**
* Call this for receiving a message * Call this for receiving a message
* This will block until a message is received or the underlying socket is closed * This will block until a message is received or the underlying socket is closed
* @param p_InetFamily either AF_INET or AF_INET6<br> * @param p_InetFamily either AF_INET or AF_INET6<br>
@@ -226,7 +226,7 @@ int SPITSocket::receiveMessage(int p_InetFamily, char *p_Buffer, int p_BufferLen
} }
intSocklen = sizeof(o_IP4SocketAddress); intSocklen = sizeof(o_IP4SocketAddress);
memset(&o_IP4SocketAddress, 0, intSocklen); memset(&o_IP4SocketAddress, 0, intSocklen);
intResult = recvfrom(m_UDPSocketIP4, (void *)p_Buffer, p_BufferLength, 0 , (sockaddr *)&o_IP4SocketAddress, (socklen_t *)&intSocklen); intResult = recvfrom(m_UDPSocketIP4, (void *)p_Buffer, p_BufferLength, 0, (sockaddr *)&o_IP4SocketAddress, (socklen_t *)&intSocklen);
if (intResult >= 0) { if (intResult >= 0) {
if (p_ServerIP != NULL) { if (p_ServerIP != NULL) {
char bufferIP4[INET_ADDRSTRLEN]; char bufferIP4[INET_ADDRSTRLEN];
@@ -239,7 +239,6 @@ int SPITSocket::receiveMessage(int p_InetFamily, char *p_Buffer, int p_BufferLen
return intResult; return intResult;
} }
SPITSocket::IPAddress SPITSocket::getAdaptersInfo() { SPITSocket::IPAddress SPITSocket::getAdaptersInfo() {
// iterate over active interfaces, and print out IPs // iterate over active interfaces, and print out IPs
esp_netif_t *netif = NULL; esp_netif_t *netif = NULL;
@@ -279,10 +278,11 @@ string createGUID() {
/** The name of the client's host computer*/ /** The name of the client's host computer*/
string getClientHostName() { string getClientHostName() {
string stringHostName = ""; string stringHostName = "";
const char * hostname; const char *hostname;
esp_netif_get_hostname(esp_netif_get_default_netif(), &hostname); esp_netif_get_hostname(esp_netif_get_default_netif(), &hostname);
if (hostname != nullptr) { if (hostname != nullptr) {
stringHostName = hostname; stringHostName = hostname;
} }
return stringHostName;; return stringHostName;
;
} }
components/spit/src/SPITType.cpp
+136 -128
View File
@@ -12,16 +12,15 @@
* Created on 8. April 2019, 08:40 * Created on 8. April 2019, 08:40
*/ */
#include "SPITType.h" #include "SPITType.h"
#include "esp_log.h" #include "esp_log.h"
static const char * TAG = "SPIT"; static const char *TAG = "SPIT";
unordered_map<string, SPITType*> SPITType::s_SPITTypes; unordered_map<string, SPITType *> SPITType::s_SPITTypes;
unordered_map<string, SPITType*> SPITType::s_SPITTypesRemote; unordered_map<string, SPITType *> SPITType::s_SPITTypesRemote;
SPITType* SPITType::getSPITType(string p_ID) { SPITType *SPITType::getSPITType(string p_ID) {
{ {
auto i = s_SPITTypes.find(p_ID); auto i = s_SPITTypes.find(p_ID);
if (i == s_SPITTypes.end()) { if (i == s_SPITTypes.end()) {
@@ -29,14 +28,14 @@ static const char * TAG = "SPIT";
} }
return i->second; return i->second;
} }
} }
/** /**
* Returns the reference of the SPITType with ID == p_ID.<br> * Returns the reference of the SPITType with ID == p_ID.<br>
* Throws an exception if no SPITType is not found.<br> * Throws an exception if no SPITType is not found.<br>
* @param p_ID the ID * @param p_ID the ID
* @return reference of the SPITType with ID == p_ID * @return reference of the SPITType with ID == p_ID
*/ */
const SPITType& SPITType::getSPITTypeRef(string p_ID) { const SPITType &SPITType::getSPITTypeRef(string p_ID) {
{ {
auto i = s_SPITTypes.find(p_ID); auto i = s_SPITTypes.find(p_ID);
if (i == s_SPITTypes.end()) { if (i == s_SPITTypes.end()) {
@@ -44,9 +43,9 @@ static const char * TAG = "SPIT";
} }
return *(i->second); return *(i->second);
} }
} }
SPITType* SPITType::getSPITTypeRemote(string p_ID) { SPITType *SPITType::getSPITTypeRemote(string p_ID) {
{ {
auto i = s_SPITTypesRemote.find(p_ID); auto i = s_SPITTypesRemote.find(p_ID);
if (i == s_SPITTypesRemote.end()) { if (i == s_SPITTypesRemote.end()) {
@@ -54,14 +53,14 @@ static const char * TAG = "SPIT";
} }
return i->second; return i->second;
} }
} }
/** /**
* Returns the reference of the remote SPITType with ID == p_ID.<br> * Returns the reference of the remote SPITType with ID == p_ID.<br>
* Throws an exception if no SPITType is not found.<br> * Throws an exception if no SPITType is not found.<br>
* @param p_ID the ID * @param p_ID the ID
* @return reference of the SPITType with ID == p_ID * @return reference of the SPITType with ID == p_ID
*/ */
const SPITType& SPITType::getSPITTypeRemoteRef(string p_ID) { const SPITType &SPITType::getSPITTypeRemoteRef(string p_ID) {
{ {
auto i = s_SPITTypesRemote.find(p_ID); auto i = s_SPITTypesRemote.find(p_ID);
if (i == s_SPITTypesRemote.end()) { if (i == s_SPITTypesRemote.end()) {
@@ -69,24 +68,27 @@ static const char * TAG = "SPIT";
} }
return *(i->second); return *(i->second);
} }
} }
bool SPITType::addSPITType(SPITType* p_ptrSpitType) { bool SPITType::addSPITType(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false; if (p_ptrSpitType == NULL)
return false;
{ {
s_SPITTypes[p_ptrSpitType->getID()] = p_ptrSpitType; s_SPITTypes[p_ptrSpitType->getID()] = p_ptrSpitType;
return true; return true;
} }
} }
bool SPITType::addSPITTypeRemote(SPITType* p_ptrSpitType) { bool SPITType::addSPITTypeRemote(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false; if (p_ptrSpitType == NULL)
return false;
{ {
s_SPITTypesRemote[p_ptrSpitType->getID()] = p_ptrSpitType; s_SPITTypesRemote[p_ptrSpitType->getID()] = p_ptrSpitType;
return true; return true;
} }
} }
bool SPITType::removeSPITType(SPITType* p_ptrSpitType) { bool SPITType::removeSPITType(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false; if (p_ptrSpitType == NULL)
return false;
{ {
auto i = s_SPITTypes.find(p_ptrSpitType->getID()); auto i = s_SPITTypes.find(p_ptrSpitType->getID());
if (i == s_SPITTypes.end()) { if (i == s_SPITTypes.end()) {
@@ -95,9 +97,10 @@ static const char * TAG = "SPIT";
i = s_SPITTypes.erase(i); i = s_SPITTypes.erase(i);
return true; return true;
} }
} }
bool SPITType::removeSPITTypeRemote(SPITType* p_ptrSpitType) { bool SPITType::removeSPITTypeRemote(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false; if (p_ptrSpitType == NULL)
return false;
{ {
auto i = s_SPITTypesRemote.find(p_ptrSpitType->getID()); auto i = s_SPITTypesRemote.find(p_ptrSpitType->getID());
if (i == s_SPITTypesRemote.end()) { if (i == s_SPITTypesRemote.end()) {
@@ -106,75 +109,73 @@ static const char * TAG = "SPIT";
i = s_SPITTypesRemote.erase(i); i = s_SPITTypesRemote.erase(i);
return true; return true;
} }
} }
int SPITType::getSPITTypeCount() { int SPITType::getSPITTypeCount() {
return s_SPITTypes.size(); return s_SPITTypes.size();
} }
int SPITType::getSPITTypeRemoteCount() { int SPITType::getSPITTypeRemoteCount() {
return s_SPITTypesRemote.size(); return s_SPITTypesRemote.size();
} }
SPITType* SPITType::getSPITType(int p_Index) { SPITType *SPITType::getSPITType(int p_Index) {
SPITType* ptrSPITType = NULL; SPITType *ptrSPITType = NULL;
{ {
if (p_Index < s_SPITTypes.size()) { if (p_Index < s_SPITTypes.size()) {
unordered_map<string, SPITType*>::iterator i = next(s_SPITTypes.begin(), p_Index); unordered_map<string, SPITType *>::iterator i = next(s_SPITTypes.begin(), p_Index);
ptrSPITType = i->second; ptrSPITType = i->second;
} }
return ptrSPITType; return ptrSPITType;
} }
} }
/** /**
* Returns a reference to the SPITType at position p_Index.<br> * Returns a reference to the SPITType at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br> * Throws an exception if p_Index is out of range.<br>
* @param p_Index position * @param p_Index position
* @return the reference of the SPITType at position. * @return the reference of the SPITType at position.
*/ */
const SPITType& SPITType::getSPITTypeRef(int p_Index) { const SPITType &SPITType::getSPITTypeRef(int p_Index) {
SPITType* ptrSPITType = NULL; SPITType *ptrSPITType = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITTypes.size()) { if (p_Index >= 0 && p_Index < s_SPITTypes.size()) {
unordered_map<string, SPITType*>::iterator i = next(s_SPITTypes.begin(), p_Index); unordered_map<string, SPITType *>::iterator i = next(s_SPITTypes.begin(), p_Index);
ptrSPITType = i->second; ptrSPITType = i->second;
return *ptrSPITType; return *ptrSPITType;
} } else {
else {
throw "SPITType index out of range"; throw "SPITType index out of range";
} }
} }
} }
SPITType* SPITType::getSPITTypeRemote(int p_Index) { SPITType *SPITType::getSPITTypeRemote(int p_Index) {
SPITType* ptrSPITType = NULL; SPITType *ptrSPITType = NULL;
{ {
if (p_Index < s_SPITTypesRemote.size()) { if (p_Index < s_SPITTypesRemote.size()) {
unordered_map<string, SPITType*>::iterator i = next(s_SPITTypesRemote.begin(), p_Index); unordered_map<string, SPITType *>::iterator i = next(s_SPITTypesRemote.begin(), p_Index);
ptrSPITType = i->second; ptrSPITType = i->second;
} }
return ptrSPITType; return ptrSPITType;
} }
} }
/** /**
* Returns a reference to the remote SPITType at position p_Index.<br> * Returns a reference to the remote SPITType at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br> * Throws an exception if p_Index is out of range.<br>
* @param p_Index position * @param p_Index position
* @return the reference of the SPITType at position. * @return the reference of the SPITType at position.
*/ */
const SPITType& SPITType::getSPITTypeRemoteRef(int p_Index) { const SPITType &SPITType::getSPITTypeRemoteRef(int p_Index) {
SPITType* ptrSPITType = NULL; SPITType *ptrSPITType = NULL;
{ {
if (p_Index >= 0 && p_Index < s_SPITTypesRemote.size()) { if (p_Index >= 0 && p_Index < s_SPITTypesRemote.size()) {
unordered_map<string, SPITType*>::iterator i = next(s_SPITTypesRemote.begin(), p_Index); unordered_map<string, SPITType *>::iterator i = next(s_SPITTypesRemote.begin(), p_Index);
ptrSPITType = i->second; ptrSPITType = i->second;
return *ptrSPITType; return *ptrSPITType;
} } else {
else {
throw "Remote SPITType index out of range"; throw "Remote SPITType index out of range";
} }
} }
} }
void SPITType::clearSPITTypes() { void SPITType::clearSPITTypes() {
SPITType* ptrSPITType; SPITType *ptrSPITType;
{ {
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) { for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second; ptrSPITType = i->second;
@@ -185,9 +186,9 @@ static const char * TAG = "SPIT";
} }
} }
} }
} }
void SPITType::clearSPITTypesRemote() { void SPITType::clearSPITTypesRemote() {
SPITType* ptrSPITType; SPITType *ptrSPITType;
{ {
for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) { for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) {
ptrSPITType = i->second; ptrSPITType = i->second;
@@ -198,10 +199,10 @@ static const char * TAG = "SPIT";
} }
} }
} }
} }
void SPITType::eventProjectClosed() { void SPITType::eventProjectClosed() {
SPITType* ptrSPITType; SPITType *ptrSPITType;
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) { for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second; ptrSPITType = i->second;
if (ptrSPITType->getCreatedByClient() == true) { if (ptrSPITType->getCreatedByClient() == true) {
@@ -213,7 +214,7 @@ static const char * TAG = "SPIT";
break; break;
} }
} }
//Remote // Remote
for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) { for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) {
ptrSPITType = i->second; ptrSPITType = i->second;
i = s_SPITTypesRemote.erase(i); i = s_SPITTypesRemote.erase(i);
@@ -222,26 +223,21 @@ static const char * TAG = "SPIT";
break; break;
} }
} }
} }
/** /**
* Sets confirmed = false for all SPITTypes.<br> * Sets confirmed = false for all SPITTypes.<br>
* This should be called when the client has loaded a project.<br> * This should be called when the client has loaded a project.<br>
*/ */
void SPITType::setConfirmedFalse() { void SPITType::setConfirmedFalse() {
SPITType* ptrSPITType; SPITType *ptrSPITType;
{ {
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) { for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second; ptrSPITType = i->second;
ptrSPITType->setConfirmed(false); ptrSPITType->setConfirmed(false);
} }
} }
} }
SPITType::SPITType() { SPITType::SPITType() {
initMembers(); initMembers();
@@ -259,7 +255,7 @@ SPITType::SPITType(const SPITType& orig) {
m_ServerRemote = orig.getServerRemote(); m_ServerRemote = orig.getServerRemote();
} }
*/ */
SPITType::SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended,long long p_DefaultDelay, long long p_DefaultDuration) { SPITType::SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended, long long p_DefaultDelay, long long p_DefaultDuration) {
initMembers(); initMembers();
m_ActionAssigned = false; m_ActionAssigned = false;
m_Confirmed = false; m_Confirmed = false;
@@ -287,154 +283,166 @@ void SPITType::initMembers() {
m_ServerRemote = false; m_ServerRemote = false;
} }
void SPITType::setCreatedByClient(bool p_CreatedByClient) { void SPITType::setCreatedByClient(bool p_CreatedByClient) {
m_CreatedByClient = p_CreatedByClient; m_CreatedByClient = p_CreatedByClient;
} }
void SPITType::setID(string p_ID) {
void SPITType::setID(string p_ID) {
m_ID = p_ID; m_ID = p_ID;
} }
/** /**
* This is used by the server and client to tell if the other side has registered the changes. * This is used by the server and client to tell if the other side has registered the changes.
* @param p_Confirmed * @param p_Confirmed
* @return if m_Confirmed has changed * @return if m_Confirmed has changed
*/ */
bool SPITType::setConfirmed(bool p_Confirmed) { bool SPITType::setConfirmed(bool p_Confirmed) {
if (m_Confirmed == p_Confirmed) return false; if (m_Confirmed == p_Confirmed)
return false;
m_Confirmed = p_Confirmed; m_Confirmed = p_Confirmed;
return true; return true;
} }
bool SPITType::setGroupName(string p_GroupName) { bool SPITType::setGroupName(string p_GroupName) {
if (m_GroupName == p_GroupName) return false; if (m_GroupName == p_GroupName)
return false;
m_GroupName = p_GroupName; m_GroupName = p_GroupName;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setName(string p_Name) { bool SPITType::setName(string p_Name) {
if (m_Name == p_Name) return false; if (m_Name == p_Name)
return false;
m_Name = p_Name; m_Name = p_Name;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setServerRemote(bool p_BelongstoServer) { bool SPITType::setServerRemote(bool p_BelongstoServer) {
if (m_ServerRemote == p_BelongstoServer) return false; if (m_ServerRemote == p_BelongstoServer)
return false;
m_ServerRemote = p_BelongstoServer; m_ServerRemote = p_BelongstoServer;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setProjectIndepended(bool p_ProjectIndepended) { bool SPITType::setProjectIndepended(bool p_ProjectIndepended) {
if (m_ServerProjectIndepended == p_ProjectIndepended) return false; if (m_ServerProjectIndepended == p_ProjectIndepended)
return false;
m_ServerProjectIndepended = p_ProjectIndepended; m_ServerProjectIndepended = p_ProjectIndepended;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setFixed(bool p_Fixed) { bool SPITType::setFixed(bool p_Fixed) {
if (m_Fixed == p_Fixed) return false; if (m_Fixed == p_Fixed)
return false;
m_Fixed = p_Fixed; m_Fixed = p_Fixed;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setDefaultDelay(long long p_Delay) { bool SPITType::setDefaultDelay(long long p_Delay) {
if (m_DefaultDelay == p_Delay) return false; if (m_DefaultDelay == p_Delay)
return false;
m_DefaultDelay = p_Delay; m_DefaultDelay = p_Delay;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
bool SPITType::setDefaultDuration(long long p_Duration) { bool SPITType::setDefaultDuration(long long p_Duration) {
if (m_DefaultDuration == p_Duration) return false; if (m_DefaultDuration == p_Duration)
return false;
m_DefaultDuration = p_Duration; m_DefaultDuration = p_Duration;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
/** /**
* Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.<br> * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.<br>
* This can used to setActionAssigned to all SPITObjects with this SPITType.<br> * This can used to setActionAssigned to all SPITObjects with this SPITType.<br>
* This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.<br> * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.<br>
* @return true = the m_ActionAssigned has changed. * @return true = the m_ActionAssigned has changed.
*/ */
bool SPITType::setActionAssigned(bool p_ActionAssigned) { bool SPITType::setActionAssigned(bool p_ActionAssigned) {
if (m_ActionAssigned == p_ActionAssigned) return false; if (m_ActionAssigned == p_ActionAssigned)
return false;
m_ActionAssigned = p_ActionAssigned; m_ActionAssigned = p_ActionAssigned;
m_Confirmed = false; m_Confirmed = false;
return true; return true;
} }
/** /**
* Set the content of the SPITType as received from the server * Set the content of the SPITType as received from the server
* @param p_ReportSPITType * @param p_ReportSPITType
* @return true = the SPITType is changed<br> * @return true = the SPITType is changed<br>
* false = the SPITType is NOT changed, because it is not allowed to change. * false = the SPITType is NOT changed, because it is not allowed to change.
*/ */
bool SPITType::setMessageOP(SPIT_Message::ReportSPITType* p_ReportSPITType) { bool SPITType::setMessageOP(SPIT_Message::ReportSPITType *p_ReportSPITType) {
bool boolChangeAllowed; bool boolChangeAllowed;
bool boolChanged = false; bool boolChanged = false;
if (m_CreatedByClient == true && m_Fixed == true) { if (m_CreatedByClient == true && m_Fixed == true) {
boolChangeAllowed = false; boolChangeAllowed = false;
} } else {
else {
boolChangeAllowed = true; boolChangeAllowed = true;
} }
//Confirmation should be changable // Confirmation should be changable
if (m_CreatedByClient) { if (m_CreatedByClient) {
//Server reports a client created SPITType -> the type is confirmed // Server reports a client created SPITType -> the type is confirmed
m_Confirmed = true; m_Confirmed = true;
} } else {
else { // type is NOT client created -> the client has to confirm the SPITtype
//type is NOT client created -> the client has to confirm the SPITtype
m_Confirmed = p_ReportSPITType->getConfirmed(); m_Confirmed = p_ReportSPITType->getConfirmed();
} }
if (m_DefaultDelay != p_ReportSPITType->getDelay()) { if (m_DefaultDelay != p_ReportSPITType->getDelay()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_DefaultDelay = p_ReportSPITType->getDelay(); m_DefaultDelay = p_ReportSPITType->getDelay();
boolChanged = true; boolChanged = true;
} }
if (m_DefaultDuration != p_ReportSPITType->getDuration()) { if (m_DefaultDuration != p_ReportSPITType->getDuration()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_DefaultDuration = p_ReportSPITType->getDuration(); m_DefaultDuration = p_ReportSPITType->getDuration();
boolChanged = true; boolChanged = true;
} }
if (m_Fixed != p_ReportSPITType->getFixed()) { if (m_Fixed != p_ReportSPITType->getFixed()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Fixed = p_ReportSPITType->getFixed(); m_Fixed = p_ReportSPITType->getFixed();
boolChanged = true; boolChanged = true;
} }
if (m_GroupName != p_ReportSPITType->getGroupName()) { if (m_GroupName != p_ReportSPITType->getGroupName()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_GroupName = p_ReportSPITType->getGroupName(); m_GroupName = p_ReportSPITType->getGroupName();
boolChanged = true; boolChanged = true;
} }
if (m_ID != p_ReportSPITType->getID()) { if (m_ID != p_ReportSPITType->getID()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ID = p_ReportSPITType->getID(); m_ID = p_ReportSPITType->getID();
boolChanged = true; boolChanged = true;
} }
if (m_Name != p_ReportSPITType->getName()) { if (m_Name != p_ReportSPITType->getName()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_Name = p_ReportSPITType->getName(); m_Name = p_ReportSPITType->getName();
boolChanged = true; boolChanged = true;
} }
if (m_ServerProjectIndepended != p_ReportSPITType->getServerProjectIndepended()) { if (m_ServerProjectIndepended != p_ReportSPITType->getServerProjectIndepended()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ServerProjectIndepended = p_ReportSPITType->getServerProjectIndepended(); m_ServerProjectIndepended = p_ReportSPITType->getServerProjectIndepended();
boolChanged = true; boolChanged = true;
} }
if (m_ServerRemote != p_ReportSPITType->getServerRemote()) { if (m_ServerRemote != p_ReportSPITType->getServerRemote()) {
if (boolChangeAllowed == false) throw new exception(); if (boolChangeAllowed == false)
throw new exception();
m_ServerRemote = p_ReportSPITType->getServerRemote(); m_ServerRemote = p_ReportSPITType->getServerRemote();
boolChanged = true; boolChanged = true;
} }
return boolChanged; return boolChanged;
} }
void SPITType::fillMessageOP(SPIT_Message::ReportSPITType* ptrSMReportSPITType) { void SPITType::fillMessageOP(SPIT_Message::ReportSPITType *ptrSMReportSPITType) {
ptrSMReportSPITType->setConfirmed(m_Confirmed); ptrSMReportSPITType->setConfirmed(m_Confirmed);
ptrSMReportSPITType->setDelay(m_DefaultDelay); ptrSMReportSPITType->setDelay(m_DefaultDelay);
ptrSMReportSPITType->setDuration(m_DefaultDuration); ptrSMReportSPITType->setDuration(m_DefaultDuration);
@@ -444,7 +452,7 @@ void SPITType::setCreatedByClient(bool p_CreatedByClient) {
ptrSMReportSPITType->setName(m_Name); ptrSMReportSPITType->setName(m_Name);
ptrSMReportSPITType->setServerProjectIndepended(m_ServerProjectIndepended); ptrSMReportSPITType->setServerProjectIndepended(m_ServerProjectIndepended);
ptrSMReportSPITType->setServerRemote(m_ServerRemote); ptrSMReportSPITType->setServerRemote(m_ServerRemote);
} }
void SPITType::fillMessageOP(SPIT_Message::RemoveSPITType* ptrSMRemoveSPITType) { void SPITType::fillMessageOP(SPIT_Message::RemoveSPITType *ptrSMRemoveSPITType) {
ptrSMRemoveSPITType->setID(m_ID); ptrSMRemoveSPITType->setID(m_ID);
} }
components/spit/src/SPIT_Client.cpp
+351 -388
View File
File diff suppressed because it is too large Load Diff
components/spit/src/SPIT_Message.cpp
+871 -811
View File
File diff suppressed because it is too large Load Diff
main/watchMain.cpp
+350 -7
View File
@@ -27,6 +27,33 @@ struct {
const char *changingPosition = /* <mqttPrefix>/ */ "watch/changingPosition"; const char *changingPosition = /* <mqttPrefix>/ */ "watch/changingPosition";
} MqttTopics; } MqttTopics;
struct {
const char *expectedServer = "";
struct {
const char *group = "CatasWatchMovement";
const char *startShuffle = "ActionStartShuffle";
const char *moveToX[6] = {
"ActionMoveTo1",
"ActionMoveTo2",
"ActionMoveTo3",
"ActionMoveTo4",
"ActionMoveTo5",
"ActionMoveTo6",
};
} Provided;
struct {
const char *changingPos = "ChangingPositionScene";
const char *inPosX[6] = {
"InPosition1Scene",
"InPosition2Scene",
"InPosition3Scene",
"InPosition4Scene",
"InPosition5Scene",
"InPosition6Scene",
};
} Expected;
} SpitTypes;
// ToDo: // ToDo:
// - MQTT Integration // - MQTT Integration
// - OTA // - OTA
@@ -36,8 +63,8 @@ struct {
#include "watchMain.hpp" #include "watchMain.hpp"
string MyApp::s_ClientName = "CatasWatchDev"; string ClientName = "CatasWatchDev";
string MyApp::s_ProjectName = "CatastrphicProj"; string ProjectName = "CatastrphicProj";
extern "C" { // This switch allows the ROS C-implementation to find this main extern "C" { // This switch allows the ROS C-implementation to find this main
void app_main(void); void app_main(void);
@@ -59,8 +86,18 @@ enum class MoveType {
Shuffle, Shuffle,
Demo Demo
}; };
enum class ResponseType {
StepAt,
StartMoving,
};
struct MoveCommand { struct MoveCommand {
MoveType type; MoveType type;
// 1..6
uint8_t pos;
};
struct Arrived {
ResponseType type;
// 1..6
uint8_t pos; uint8_t pos;
}; };
struct PictoIllumCommand { struct PictoIllumCommand {
@@ -68,6 +105,7 @@ struct PictoIllumCommand {
}; };
static fos::Queue<MoveCommand> commandQueue(8); static fos::Queue<MoveCommand> commandQueue(8);
static fos::Queue<Arrived> responseQueue(8);
static fos::Queue<PictoIllumCommand> pictoIllumQue(2); static fos::Queue<PictoIllumCommand> pictoIllumQue(2);
DeviceState activeState; DeviceState activeState;
@@ -346,6 +384,7 @@ static void dmxSocketTask(int addrFamily) {
} }
fos::Semaphore etherActive; fos::Semaphore etherActive;
fos::Semaphore spitProjectFinish;
/** Event handler for IP_EVENT_ETH_GOT_IP */ /** Event handler for IP_EVENT_ETH_GOT_IP */
static void got_ip_event_handler(void *arg, esp_event_base_t event_base, static void got_ip_event_handler(void *arg, esp_event_base_t event_base,
@@ -587,9 +626,11 @@ void MovementTask() {
"Running Stepper by %i steps with prof=%i a=%.2f w=%.2f", "Running Stepper by %i steps with prof=%i a=%.2f w=%.2f",
delta, activeState.profile, activeState.accel, activeState.speed); delta, activeState.profile, activeState.accel, activeState.speed);
pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0)); pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0));
responseQueue.enqueue(std::make_unique<Arrived>(ResponseType::StartMoving, 0));
stepper.moveBy(delta * std::numbers::pi / 3, stepper.moveBy(delta * std::numbers::pi / 3,
activeState.profile, activeState.accel, activeState.speed); activeState.profile, activeState.accel, activeState.speed);
pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(newPos)); pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(newPos));
responseQueue.enqueue(std::make_unique<Arrived>(ResponseType::StepAt, newPos));
activeState.pictogram = newPos; activeState.pictogram = newPos;
} }
} else if (cmd->type == MoveType::Demo) { } else if (cmd->type == MoveType::Demo) {
@@ -616,19 +657,321 @@ void MovementTask() {
} }
} }
} }
struct LocalSpitObj {
string iD;
string groupName;
string name;
};
std::map<string, MoveCommand> ProvidedSpitActions;
std::map<string, string> ExpectedObjects;
void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_DetectedServer) {
switch (event) {
case SPIT_Client::ServerEvent::Detect:
ESP_LOGI(TAG, "SERVER DETECTED");
ESP_LOGI(TAG, " Name: %s", p_DetectedServer.getName().data());
ESP_LOGI(TAG, " ID: %s", p_DetectedServer.getID().data());
ESP_LOGI(TAG, " Computer: %s", p_DetectedServer.getComputerName().data());
ESP_LOGI(TAG, " IP: %s", p_DetectedServer.getIP().data());
ESP_LOGI(TAG, " Port: %s", p_DetectedServer.getPort().data());
ESP_LOGI(TAG, " Addition: %s", p_DetectedServer.getAdditions().data());
ESP_LOGI(TAG, " ClientIP: %s", p_DetectedServer.getClientIP().data());
break;
case SPIT_Client::ServerEvent::Lost:
ESP_LOGW(TAG, "Server lost Name: %s IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
break;
case SPIT_Client::ServerEvent::Changed:
ESP_LOGW(TAG, "Server lost Name: %s IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
break;
default:
break;
}
}
void onConnectionStatus(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, int p_ConnectionStatus, int p_OldConnectionStatus) {
ESP_LOGI(TAG, "MySPITApp: eventConnectionStatus %d ", p_ConnectionStatus);
}
// The transfer of the server's SPITTypes and SPITObjects is finished.
void onProjectUpdate(SPIT_Client::ProjUpdate state, string projectId) {
switch (state) {
case SPIT_Client::ProjUpdate::ServerLoaded:
ESP_LOGI(TAG, "eventProjectReport ID: %s ", projectId.data());
break;
case SPIT_Client::ProjUpdate::StartTransfer:
ESP_LOGI(TAG, "eventStartProjectTransfer");
break;
case SPIT_Client::ProjUpdate::EndTransfer:
ESP_LOGI(TAG, "eventEndProjectTransfer");
spitProjectFinish.give();
break;
case SPIT_Client::ProjUpdate::ServerClosed:
ESP_LOGI(TAG, "eventProjectClosed ID: %s", projectId.data());
// If we don't save SPITServer's project specific information
// perhaps close all SPITObjects and RemoteSPITObjects to avoid conflicts, when the SPITServer loads a new project
// SPITObject::clearSPITObjects();
// SPITObject::clearSPITObjectsRemote();
break;
default:
break;
}
}
/**
* The SPITCLientInterface (implemented by this) will be asked to veto the SPITType while SPIT_Client.parseReportSPITType.<br>
* @param p_ReportSPITType
* @return false = the SPITType is denied, true = the SPITType is accepted
*/
bool onCheckSpitTypeVeto(SPIT_Message::ReportSPITType *p_ReportSPITType) {
if (p_ReportSPITType == NULL)
return true;
SPITType *ptrSPITType;
ptrSPITType = SPITType::getSPITType(p_ReportSPITType->getID());
// Don't allow foreign SPITTypes
if (ptrSPITType == NULL)
return false;
if (ptrSPITType->getCreatedByClient() == false)
return false;
return true;
}
bool onCheckSpitObjectVeto(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
if (p_ReportSPITObject == NULL)
return true;
SPITType *ptrSPITType = SPITType::getSPITType(p_ReportSPITObject->getSPITTypeID());
if (ptrSPITType == NULL)
return false;
// Don't allow SPITObjects which refers to a SPITType which is not created by this client - other SPITTypes cannot be handled here
if (ptrSPITType->getCreatedByClient() == false)
return false;
SPITObject *ptrSPITObject = SPITObject::getSPITObject(p_ReportSPITObject->getID());
// Don't allow foreign SPITTypes
if (ptrSPITObject == NULL)
return false;
return true;
}
// Called when the server has created, loaded, changed or deleted a SPITType.
// May also occur when the server confirms a SPITType created or changed by the client.
void onSpitType(SPIT_Client::ObjectEvent event, const SPITType &p_SPITType) {
if (event == SPIT_Client::ObjectEvent::Created) {
// Whenever you provide an action for this SPITType take this over in your code.
// call _SpitClient.setActionSPITType(p_SPITType.getID(), true);
ESP_LOGI(TAG, "NEW SPIT-Type ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
auto typeName = p_SPITType.getName();
if (ExpectedObjects.contains(typeName)) {
ExpectedObjects[typeName] = p_SPITType.getID();
}
} else if (event == SPIT_Client::ObjectEvent::Changed) {
ESP_LOGI(TAG, "SPIT-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
} else if (event == SPIT_Client::ObjectEvent::Deleted) {
ESP_LOGI(TAG, "SPIT-Type Removed ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
}
}
/**
* Called when the server has created or changed a Remote SPITType.
* Remote SPITType are used in Remote SPITObjects. A Remote SPITObject is used to remote control the SPITServer.
* @param p_New true = server created a new SPITType / false = server changed a existing SPITType
*/
void onSpitTypeRemote(SPIT_Client::ObjectEvent event, const SPITType &p_SPITType) {
if (event == SPIT_Client::ObjectEvent::Created) {
ESP_LOGI(TAG, "NEW SPIT-REMOTE-Type ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
} else if (event == SPIT_Client::ObjectEvent::Changed) {
// we had to inform all Remote SPITObjects using the p_SPITType
// perhaps the SPITObject uses information from the SPITType
SPITObject *ptrSPITObject;
int intSPITObjectCount;
intSPITObjectCount = SPITObject::getSPITObjectRemoteCount();
for (int intObject = 0; intObject < intSPITObjectCount; intObject++) {
ptrSPITObject = SPITObject::getSPITObjectRemote(intObject);
if (ptrSPITObject == NULL)
continue;
if (ptrSPITObject->getSPITTypeID() == p_SPITType.getID()) {
// call ecentSPITObjectRemote
// onSpitObjectRemote(SPIT_Client::ObjectEvent::Changed, p_SPITType, *ptrSPITObject);
}
}
ESP_LOGI(TAG, "SPIT-REMOTE-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
} else if (event == SPIT_Client::ObjectEvent::Deleted) {
ESP_LOGD(TAG, "SPIT-REMOTE-Type Removed ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
}
}
/**
* Called when the server has created, loaded or changed a SPITObject.
* May also occur when the server confirms a SPITObject created by the client, what the client should never do!!.
* false = server changed a existing SPITObject
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void onSpitObject(SPIT_Client::ObjectEvent event, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
if (event == SPIT_Client::ObjectEvent::Created) {
ESP_LOGI(TAG, "NEW SPIT-Object ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
// check your actions
// Whenever you provide an action for this SPITObject take this over in your code.
// call _SpitClient.setActionSPITObject(p_SPITObject.getID(), true);
// for our little excample as described in loadClientProject:
// We have only actions for SPITTypes - means every SPITObject with the associated "Actionx"-SPITTypes will trigger the action when it is played
//-> no need to do something here, because setActionSPITType has been set prior and the SPITObject will automatically inherits this
// SPITObjects with other SPITTypes asscciated will trigger no actions
} else if (event == SPIT_Client::ObjectEvent::Changed) {
ESP_LOGI(TAG, "SPIT-Object CHANGED ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
} else if (event == SPIT_Client::ObjectEvent::Deleted) {
ESP_LOGD(TAG, "SPIT-Object Removed ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
// Check your actions
// take the removal of the SPITObject over in your code
// CAUTION: Deleted SPITObjects can be added later again (perhaps per UNDO on the SPITServer)
//-> don't remove your assigned action immediately - keep it to reassign it later
}
}
/**
* Called when the server has created or changed a Remote SPITObject.
* A Remote SPITObject is used to remote control the SPITServer.
* @param p_New true = server created a new remote SPITObject
* false = server changed a existing remote SPITObject
* @param p_SPITType a reference to a copy of the associated SPITType instance.
* @param p_SPITObject a reference to a copy of the SPITObject instance.
*/
void onSpitObjectRemote(SPIT_Client::ObjectEvent event, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
if (event == SPIT_Client::ObjectEvent::Created) {
ESP_LOGI(TAG, "NEW SPIT-REMOTE-Object ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
// This is a remote SPITObject which can be used to remote control the server.
// If you want you can list this for later use
} else if (event == SPIT_Client::ObjectEvent::Changed) {
ESP_LOGI(TAG, "SPIT-REMOTE-Object CHANGED ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
} else if (event == SPIT_Client::ObjectEvent::Deleted) {
ESP_LOGD(TAG, "SPIT-REMOTE-Object Removed ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
// This is a remote SPITObject
// If you have listet this prior you should remove it from the list
}
}
// SPITServer may use several methods for playing SPITObjects.
// e.g. liveSHOWsoftware has the timeline and jingles which plays objects, where the timeline the main player is.
// SPIT distinguishes between the different players. All eventPlay... functions contain the information which player plays the SPIT object.
void onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames) {
ESP_LOGD(TAG, "eventPlay Player: %s Runs: %d Time: %lld", p_PlayerName.data(), p_PlayerIsRunning, p_TimeFrames);
switch (p_PlayerType) {
case SPIT_Client::PLAYERTYPE_MAIN:
// 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);
break;
case SPIT_Client::PLAYERTYPE_CONTINOUS:
// The olayer is playing only single Object sequences sometime during the project
break;
case SPIT_Client::PLAYERTYPE_DISCRETE:
// Only discrete values where submitted, e.g the fader position of remote faders.
break;
}
}
/**
* Called when the SPITServer plays a SPITObject. For every played SPITObject one eventPlayObject is called.
* You can decide here which action should be done or not.
*/
void onPlaySpitType(string p_PlayerID, string spitTypeId, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value) {
// double doubleValue = ((double)p_PlayObject.getValue() / 1000000) * ((double)p_PlayObject.getValueFactor() / 1000000);
ESP_LOGD(TAG, "eventPlayObject Player: %s is running: %d Object Started: %d Stopped: %d", p_PlayerID.data(), p_PlayerIsRunning, p_Started, p_Ended);
// ESP_LOGD(TAG, " SPITType: %s SPITObject: %s Position: %lld Value: %f\n", spitTypeId.data(), p_SPITObject.getName().data(), p_PlayObject.getFrameInside(), doubleValue);
ESP_LOGD(TAG, " SPITType: %s Value: %f\n", spitTypeId.data(), p_Value);
if (!ProvidedSpitActions.contains(spitTypeId)) {
ESP_LOGE(TAG, "SPIT ID %s is not accepted", spitTypeId.c_str());
return;
}
if (p_Started == true) {
auto command = ProvidedSpitActions[spitTypeId];
ESP_LOGI(TAG, "Player: %s is running: %s Object", p_PlayerID.data(), spitTypeId.c_str());
commandQueue.enqueue(std::make_unique<MoveCommand>(command));
ESP_LOGI(TAG, "MyApp AKTION 1 started Value: %f and running: %d", p_Value, p_PlayerIsRunning);
}
}
/**
* Called when a remote SpitObject which value function is changed by the server.
* This allows the Client to adjust its display for the remote command.
* @param p_SPITType the assigned remote SPITType of p_SPITObject
* @param p_SPITObject the remote SPITObject which is changed
* @param p_FrameInsideObject can be discarded
* @param p_Value the new value
*/
void onPlayRemoteObjectStatus(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value) {
ESP_EARLY_LOGI(TAG, "eventPlayRemoteObjectStatus RemoteSPITType: %s RemoteSPITObject: %s Position: %lld Value: %d", p_SPITType.getName().data(), p_SPITObject.getName().data(), p_FrameInsideObject, p_Value);
}
void SpitClientApp() { void SpitClientApp() {
ESP_LOGI(TAG, "Starting SPIT task"); ESP_LOGI(TAG, "Starting SPIT task");
auto ptrMyApp = std::make_unique<MyApp>();
auto &provided = SpitTypes.Provided;
auto &expected = SpitTypes.Expected;
std::vector<LocalSpitObj> ProvidedObj;
ProvidedSpitActions[provided.startShuffle] = MoveCommand{.type = MoveType::Shuffle, .pos = 0};
ProvidedObj.push_back(LocalSpitObj{.iD = provided.startShuffle, .groupName = provided.group, .name = provided.startShuffle});
ExpectedObjects[expected.changingPos] = "";
for (size_t i = 0; i < 6; i++) {
ProvidedObj.push_back(LocalSpitObj{.iD = provided.moveToX[i], .groupName = provided.group, .name = provided.moveToX[i]});
ProvidedSpitActions[provided.moveToX[i]] = MoveCommand{.type = MoveType::StepTo, .pos = (uint8_t)(i + 1)};
ExpectedObjects[expected.inPosX[i]] = "";
}
// load a client project and start auto detection of SPITServers SPIT_Client spitClient(ClientName, ProjectName,
ptrMyApp->init(); {
.onServerEvent = onServerEvent,
.onConnectionStatus = onConnectionStatus,
.onProjectUpdate = onProjectUpdate,
.onSpitType = onSpitType,
.onSpitTypeRemote = onSpitTypeRemote,
.onSpitObject = onSpitObject,
.onSpitObjectRemote = onSpitObjectRemote,
.onPlay = onPlay,
.onPlaySpitType = onPlaySpitType,
.onPlayRemoteObjectStatus = onPlayRemoteObjectStatus,
.onCheckSpitTypeVeto = onCheckSpitTypeVeto,
.onCheckSpitObjectVeto = onCheckSpitObjectVeto,
});
for (auto &obj : ProvidedObj) {
SPITType *ptrSPITType1Fix = spitClient.createSPITTypeFixed(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.clientProjectLoaded();
spitClient.startServerAutoDetect();
spitProjectFinish.take();
string serverProjectID = spitClient.getServerProjectID();
string serverProjectName = spitClient.getClientProjectName();
int serverFramesPerSecond = spitClient.getServerFramesPerSecond(); // set when the server reports his project, see eventProjectReport
ESP_LOGI(TAG, "eventProjectReport ID: %s Name: %s FramesPerSecond: %d", serverProjectID.data(), serverProjectName.data(), serverFramesPerSecond);
for (auto &&obj : ExpectedObjects) {
if (obj.second == "") {
ESP_LOGE(TAG, "No matching Remote ID for %s", obj.first.c_str());
}
}
while (true) { while (true) {
fos::Task::delayMs(10000); fos::Task::delayMs(10000);
ESP_LOGI(TAG, "Test LiveShow"); ESP_LOGI(TAG, "Test LiveShow");
ptrMyApp->testLiveShowRemote(); //This is an excample how to remote control the liveSHOWsoftware
auto res = responseQueue.dequeue();
if (res->type == ResponseType::StartMoving) {
spitClient.sendRemoteObject(ExpectedObjects[expected.changingPos]);
} else if (res->type == ResponseType::StepAt) {
spitClient.sendRemoteObject(ExpectedObjects[expected.inPosX[res->pos - 1]]);
}
} }
} }
@@ -651,7 +994,7 @@ void app_main(void) {
static fos::TaskT<int> telnetSocket(telnetSocketTask, ipVersion, "tcpServer", 4096); static fos::TaskT<int> telnetSocket(telnetSocketTask, ipVersion, "tcpServer", 4096);
static fos::TaskT<int> dmxNode(dmxSocketTask, ipVersion, "dmxNode", 4096); static fos::TaskT<int> dmxNode(dmxSocketTask, ipVersion, "dmxNode", 4096);
// static Task otaUpdate(SystemFunctions::OtaTaskEntry, "otaTask", 8192); // static Task otaUpdate(SystemFunctions::OtaTaskEntry, "otaTask", 8192);
static fos::Task spit(SpitClientApp,"SpitClient"); static fos::Task spit(SpitClientApp, "SpitClient");
auto &store = NvsApi::getInstance(); auto &store = NvsApi::getInstance();
auto logger = store.getValue(ConfigKeys.syslogDest); auto logger = store.getValue(ConfigKeys.syslogDest);
main/watchMain.hpp
+9 -1
View File
@@ -36,7 +36,6 @@
#include "Processor.hpp" #include "Processor.hpp"
#include "nvsFunctions.hpp" #include "nvsFunctions.hpp"
#include "mqttClient.hpp" #include "mqttClient.hpp"
#include "MyApp.h"
// #include "esp_chip_info.h" // #include "esp_chip_info.h"
// #include "esp_flash.h" // #include "esp_flash.h"
@@ -52,3 +51,12 @@
// #include <inttypes.h> // #include <inttypes.h>
// #include <sys/param.h> // #include <sys/param.h>
// #include <unistd.h> // #include <unistd.h>
#include "SAD_DetectedServer.hpp"
#include "SPITObject.h"
#include "SPITPlayer.h"
#include "SPITType.h"
#include "SPIT_Client.h"
#include <chrono>
#include <string>
#include <map>