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>
using namespace std;
class SAD_DetectedServer;
class I_SAD_Client {
public:
public:
/**
* 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>
@@ -20,7 +21,7 @@ public:
* @param p_Addition sometimes server may have additional informations
* @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.
* 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_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(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 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
#include "I_SAD_Client.hpp"
#include <list>
#include <string>
#include <unordered_map>
#include <list>
using namespace std;
class SAD_DetectedServer {
public:
public:
SAD_DetectedServer();
SAD_DetectedServer(const SAD_DetectedServer& orig) {
SAD_DetectedServer(const SAD_DetectedServer &orig) {
m_ID = orig.getID();
m_Name = orig.getName();
m_ComputerName = orig.getComputerName();
m_IP = orig.getIP();
m_IPIsIP4 = orig.getIpIsIP4();
m_ClientIP = orig.getClientIP();
m_Port = orig.getPort();
m_Additions = orig.getAdditions();
@@ -28,7 +27,6 @@ public:
string m_Name;
string m_ComputerName;
string m_IP;
bool m_IPIsIP4;
string m_ClientIP;
string m_Port;
string m_Additions;
@@ -42,22 +40,21 @@ public:
string getName() const { return m_Name; }
string getComputerName() const { return m_ComputerName; }
string getIP() const { return m_IP; }
bool getIpIsIP4() const { return m_IPIsIP4; }
string getPort() const { return m_Port; }
string getClientIP() const { return m_ClientIP; }
string getAdditions() const { return m_Additions; }
string getProjectName() const {return m_ServerProjectName;}
private:
string getProjectName() const { return m_ServerProjectName; }
private:
void setID(string p_ID) { m_ID = p_ID; }
void setName(string p_Name) { m_Name = p_Name; }
void setComputerName(string p_ComputerName) { m_ComputerName = p_ComputerName; }
void setIP(string p_IP) { m_IP = p_IP; }
void setClientIP(string p_IP) { m_ClientIP = p_IP; }
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 setIPIsIP4(bool p_IsIP4) { m_IPIsIP4 = p_IsIP4; }
bool getNew() const { return m_New; }
bool getChanged() const { return m_Changed; }
bool getFoundAgain() const { return m_FoundAgain; }
@@ -65,18 +62,17 @@ private:
void setNew(bool p_New) { m_New = p_New; }
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() {
m_IPIsIP4 = false;
m_Changed = false;
m_FoundAgain = false;
m_New = false;
}
//SAD_Client m_Thread_Send has paused in the meantime m_ThreadReceive may received messages from servers
void endCycleSAD() { }
private:
static unordered_map<string, SAD_DetectedServer*> s_DetectedServers;
public:
private:
static unordered_map<string, SAD_DetectedServer *> s_DetectedServers;
public:
static const int PARAMINDEX_PRECODE = 0;
static const int PARAMINDEX_SPITTASKID = 1;
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_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
* @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
*/
@@ -111,7 +107,7 @@ public:
* Used by SAD_Client internally -don't use this manually
* @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>
@@ -119,20 +115,5 @@ public:
* @param p_ServerID the id of the SPITServer
* @return the reference of the SAD_DetectedServer instance with getID() == 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();
}
}
static const SAD_DetectedServer &getRefDetectedServer(string p_ServerID);
};
components/spit/include/SPITObject.h
+32 -32
View File
@@ -14,8 +14,8 @@
#ifndef SPITOBJECT_H
#define SPITOBJECT_H
#include "SPIT_Message.h"
#include "SPITType.h"
#include "SPIT_Message.h"
#include <string>
#include <unordered_map>
@@ -24,39 +24,40 @@ using namespace std;
class SPITObjectListener;
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;
static unordered_map<string, SPITObject*> s_SPITObjectsRemote;
public:
static SPITObject* getSPITObject(string p_ID);
static const SPITObject& getSPITObjectRef(string p_ID);
static bool addSPITObject(SPITObject* p_ptrSpitObject);
static bool removeSPITObject(SPITObject* p_ptrSpitObject);
public:
static SPITObject *getSPITObject(string p_ID);
static const SPITObject &getSPITObjectRef(string p_ID);
static bool addSPITObject(SPITObject *p_ptrSpitObject);
static bool removeSPITObject(SPITObject *p_ptrSpitObject);
static bool removeSPITObject(string p_SpitObjectID);
static int getSPITObjectCount();
static SPITObject* getSPITObject(int p_Index);
static const SPITObject& getSPITObjectRef(int p_Index);
static SPITObject *getSPITObject(int p_Index);
static const SPITObject &getSPITObjectRef(int p_Index);
static void clearSPITObjects();
static void clearUnconfirmedSPITObjects();
static void setConfirmedFalse();
static SPITObject* getSPITObjectRemote(string p_ID);
static const SPITObject& getSPITObjectRemoteRef(string p_ID);
static bool addSPITObjectRemote(SPITObject* p_ptrSpitObject);
static bool removeSPITObjectRemote(SPITObject* p_ptrSpitObject);
static SPITObject *getSPITObjectRemote(string p_ID);
static const SPITObject &getSPITObjectRemoteRef(string p_ID);
static bool addSPITObjectRemote(SPITObject *p_ptrSpitObject);
static bool removeSPITObjectRemote(SPITObject *p_ptrSpitObject);
static bool removeSPITObjectRemote(string p_SpitObjectID);
static int getSPITObjectRemoteCount();
static SPITObject* getSPITObjectRemote(int p_Index);
static const SPITObject& getSPITObjectRemoteRef(int p_Index);
static SPITObject *getSPITObjectRemote(int p_Index);
static const SPITObject &getSPITObjectRemoteRef(int p_Index);
static void clearSPITObjectsRemote();
static void eventProjectClosed();
SPITObject();
// SPITObject(const SPITObject& orig);
// SPITObject(const SPITObject& orig);
~SPITObject();
private:
private:
string m_ID;
string m_Name;
string m_SPITTypeID;
@@ -67,7 +68,7 @@ private:
bool m_CreatedByClient;
bool m_ServerRemote;
bool m_ActionAssigned;
bool m_ActionAssignedType; //Virtual construct
bool m_ActionAssignedType; // Virtual construct
long long m_FrameStart;
long long m_FrameLength;
long long m_FrameFadeInLength;
@@ -83,9 +84,9 @@ private:
int m_PlayValue;
char m_PlayValueFlag;
void initMembers();
public:
public:
string getID() const { return m_ID; }
string getName() const { return m_Name; }
string getRemark() const { return m_Remark; }
@@ -132,15 +133,16 @@ public:
long long getDuration() const { return m_Duration; }
bool getProjectIndepended() const {
SPITType* ptrSPITType;
SPITType *ptrSPITType;
if (m_ServerRemote == false) {
ptrSPITType = SPITType::getSPITType(m_SPITTypeID);
if (ptrSPITType == NULL) return true;
if (ptrSPITType == NULL)
return true;
return ptrSPITType->getProjectIndepended();
}
else {
} else {
ptrSPITType = SPITType::getSPITTypeRemote(m_SPITTypeID);
if (ptrSPITType == NULL) return true;
if (ptrSPITType == NULL)
return true;
return ptrSPITType->getProjectIndepended();
}
};
@@ -166,11 +168,9 @@ public:
bool setDelay(long long p_Delay);
bool setDuration(long long p_Duration);
bool setMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject);
void fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject);
void fillMessageOP(SPIT_Message::RemoveSPITObject* p_RemoveSPITObject);
bool setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void fillMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void fillMessageOP(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject);
};
#endif /* SPITOBJECT_H */
components/spit/include/SPITPlayer.h
+15 -17
View File
@@ -19,13 +19,13 @@
class SPITPlayer {
//----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
public:
//----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
public:
class PlaySPITType {
public:
PlaySPITType();
PlaySPITType(SPITPlayer* p_SPITPlayer, string p_SPITObjectID);
PlaySPITType(const PlaySPITType& orig);
PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
PlaySPITType(const PlaySPITType &orig);
string getSPITTypeID() const {
return m_SPITTypeID;
@@ -54,26 +54,25 @@ public:
double m_Value;
};
//----- SPITPlayer ------
public:
//list the SPITPlayers
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
//----- SPITPlayer ------
public:
// list the SPITPlayers
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 void clearPlayers();
SPITPlayer(string p_PlayerID);
virtual ~SPITPlayer();
void startPlaySequence(); //called by SPIT_Client::parsePlaySPITStart
PlaySPITType* addSPITType_Playing (string p_SPITTypeID); //called by SPIT_Client::parsePlaySPITStart
void endPlaySequence(); //called by SPIT_Client::parsePlaySPITEnd
void startPlaySequence(); // called by SPIT_Client::parsePlaySPITStart
PlaySPITType *addSPITType_Playing(string p_SPITTypeID); // called by SPIT_Client::parsePlaySPITStart
void endPlaySequence(); // called by SPIT_Client::parsePlaySPITEnd
string getID() {
return m_ID;
}
unordered_map<string, PlaySPITType*>* getPlaySPITTypes();
unordered_map<string, PlaySPITType *> *getPlaySPITTypes();
void setIsRunning(bool p_IsRunning);
bool getIsRunning() { return m_IsRunning; }
void setName(string p_Name);
@@ -83,14 +82,13 @@ public:
void setTime(long long p_Frames);
long long getTime() { return m_TimeFrames; }
private:
private:
string m_ID;
string m_Name;
char m_Type;
unordered_map<string, PlaySPITType*> m_PlaySPITTypes;
unordered_map<string, PlaySPITType *> m_PlaySPITTypes;
bool m_IsRunning;
long long m_TimeFrames;
};
#endif /* SPITPLAYER_H */
components/spit/include/SPITSocket.h
+23 -24
View File
@@ -16,17 +16,17 @@
#ifndef 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 "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;
@@ -35,7 +35,7 @@ string createGUID();
/** Returns the name of the client's host computer*/
string getClientHostName();
class SPITSocket{
class SPITSocket {
public:
static const int FAMILY_IP4 = AF_INET;
@@ -45,8 +45,8 @@ class SPITSocket{
*/
struct IPAddress {
public:
IPAddress(const string& p_IPAddress, const string& p_SubnetMask)
: m_IPAddress(p_IPAddress), m_SubnetMask(p_SubnetMask) { }
IPAddress(const string &p_IPAddress, const string &p_SubnetMask)
: m_IPAddress(p_IPAddress), m_SubnetMask(p_SubnetMask) {}
const string m_IPAddress;
const string m_SubnetMask;
@@ -72,10 +72,10 @@ class SPITSocket{
bool createSocket_UDP();
static const int INVALID_SOCKET = -1;
private:
private:
int m_UDPSocketIP4;
public:
public:
//-------- class --------------
SPITSocket(IPAddress ip) : mOwnIp(ip) {
m_UDPSocketIP4 = INVALID_SOCKET;
@@ -88,7 +88,6 @@ public:
m_BoundClientFamily = 0;
m_IsBound = false;
createSocket_UDP();
}
virtual ~SPITSocket() {
ESP_LOGD("UDP", "Shutting down ...");
@@ -101,16 +100,17 @@ public:
fos::Task::delayMs(100);
m_IsBound = false;
}
private:
private:
string m_ServerIP;
string m_ServerPort;
string m_ClientIP;
string m_ClientPort; //port given by the user maybe "0"
string m_BoundClientPort; //port set after bind
string m_ClientPort; // port given by the user maybe "0"
string m_BoundClientPort; // port set after bind
int m_BoundClientFamily;
bool m_IsBound;
public:
public:
/**
* Sets the ip address and port for server and client.
* @param p_ServerIP
@@ -131,7 +131,7 @@ public:
* @param p_MessageLength length of the messaeg
* @return
*/
int sendMessage(const char* p_MessageBytes, int p_MessageLength) {
int sendMessage(const char *p_MessageBytes, int p_MessageLength) {
if (m_ServerPort.length() <= 0)
return -1;
int intResult;
@@ -143,16 +143,16 @@ public:
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 bindSocket(string p_ServerIP, string p_ClientIP, string p_ClientPort);
// * Internal usage - don't use this manually
// * 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 getServerPort(){ return m_ServerPort; }
string getServerPort() { return m_ServerPort; }
string getClientIP() { return m_ClientIP; }
string getClientPort() { return m_ClientPort; }
string getBoundClientPort() { return m_BoundClientPort; }
@@ -164,4 +164,3 @@ public:
};
#endif /* SPITSOCKET_H */
components/spit/include/SPITType.h
+30 -32
View File
@@ -24,38 +24,38 @@ using namespace std;
class SPITTypeListener;
class SPITType {
private:
static unordered_map<string, SPITType*> s_SPITTypes;
static unordered_map<string, SPITType*> s_SPITTypesRemote;
private:
static unordered_map<string, SPITType *> s_SPITTypes;
static unordered_map<string, SPITType *> s_SPITTypesRemote;
public:
static SPITType* getSPITType(string p_ID);
static const SPITType& getSPITTypeRef(string p_ID);
static bool addSPITType(SPITType* p_ptrSpitType);
static bool removeSPITType(SPITType* p_ptrSpitType);
public:
static SPITType *getSPITType(string p_ID);
static const SPITType &getSPITTypeRef(string p_ID);
static bool addSPITType(SPITType *p_ptrSpitType);
static bool removeSPITType(SPITType *p_ptrSpitType);
static int getSPITTypeCount();
static SPITType* getSPITType(int p_Index);
static const SPITType& getSPITTypeRef(int p_Index);
static SPITType *getSPITType(int p_Index);
static const SPITType &getSPITTypeRef(int p_Index);
static void clearSPITTypes();
static void setConfirmedFalse();
static SPITType* getSPITTypeRemote(string p_ID);
static const SPITType& getSPITTypeRemoteRef(string p_ID);
static bool addSPITTypeRemote(SPITType* p_ptrSpitType);
static bool removeSPITTypeRemote(SPITType* p_ptrSpitType);
static SPITType *getSPITTypeRemote(string p_ID);
static const SPITType &getSPITTypeRemoteRef(string p_ID);
static bool addSPITTypeRemote(SPITType *p_ptrSpitType);
static bool removeSPITTypeRemote(SPITType *p_ptrSpitType);
static int getSPITTypeRemoteCount();
static SPITType* getSPITTypeRemote(int p_Index);
static const SPITType& getSPITTypeRemoteRef(int p_Index);
static SPITType *getSPITTypeRemote(int p_Index);
static const SPITType &getSPITTypeRemoteRef(int p_Index);
static void clearSPITTypesRemote();
static void eventProjectClosed();
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(const SPITType& orig);
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();
private:
private:
bool m_Confirmed;
string m_ID;
bool m_Fixed;
@@ -66,16 +66,16 @@ private:
long long m_DefaultDelay;
long long m_DefaultDuration;
bool m_CreatedByClient; //flag true = the SPITTyype is created by the client
//false = the SPITType is received from the server
bool m_CreatedByClient; // flag true = the SPITTyype is created by the client
// false = the SPITType is received from the server
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
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
void initMembers();
public:
string getID() const{ return m_ID; }
public:
string getID() const { return m_ID; }
string getGroupName() const { return m_GroupName; }
string getName() const { return m_Name; }
/**
@@ -110,8 +110,7 @@ public:
return m_ActionAssigned;
}
public:
public:
void setID(string p_ID);
bool setGroupName(string p_GroupName);
bool setName(string p_Name);
@@ -132,11 +131,10 @@ public:
*/
bool setActionAssigned(bool p_ActionAssigned);
bool setMessageOP(SPIT_Message::ReportSPITType* p_ReportSPITType);
void fillMessageOP(SPIT_Message::ReportSPITType* p_ReportSPITType);
void fillMessageOP(SPIT_Message::RemoveSPITType* p_RemoveSPITType);
// static char* stringCopy(const char* p_String);
bool setMessageOP(SPIT_Message::ReportSPITType *p_ReportSPITType);
void fillMessageOP(SPIT_Message::ReportSPITType *p_ReportSPITType);
void fillMessageOP(SPIT_Message::RemoveSPITType *p_RemoveSPITType);
// static char* stringCopy(const char* p_String);
};
#endif /* SPITTYPE_H */
components/spit/include/SPIT_Client.h
+115 -104
View File
@@ -14,12 +14,12 @@
#ifndef SPIT_CLIENT_H
#define SPIT_CLIENT_H
#include "SPITSocket.h"
#include "SAD_DetectedServer.hpp"
#include "SPIT_Message.h"
#include "SPITType.h"
#include "SPITObject.h"
#include "SPITPlayer.h"
#include "SPITSocket.h"
#include "SPITType.h"
#include "SPIT_Message.h"
#include <memory>
#include <vector>
@@ -27,40 +27,46 @@ using namespace std;
class SPIT_Client : I_SAD_Client {
public:
public:
/** Maximal length of a SPITMessage*/
static const int MAXSPITMESSAGEBYTECOUNT = 512;
enum ServerEvent {
enum class ProjUpdate {
ServerLoaded,
StartTransfer,
EndTransfer,
ServerClosed,
};
enum class ServerEvent {
Detect,
Lost,
Changed,
};
struct Callbacks {
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(*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);
enum class ObjectEvent {
Created,
Changed,
Deleted
};
//----- Connection Status -----
public:
struct Callbacks {
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*/
static const int CONNECTION_NONE = 0;
/** Server has disconnected*/
@@ -72,8 +78,8 @@ public:
/** A connection to the server is tried.*/
static const int CONNECTION_TRYCONNECTION = 4;
//------ PlayerType ------
public:
//------ PlayerType ------
public:
/** continous main player, time value can be used like a timecode.<br>The time value is the position in server's project.<br>A server should use only one main player.*/
static const char PLAYERTYPE_MAIN = 0x02;
/** 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.*/
static const char PLAYERTYPE_DISCRETE = 0x00;
//------ Value Flag ------
//------ used by sendRemoteObject
public:
//------ Value Flag ------
//------ used by sendRemoteObject
public:
/**Set the given value directly*/
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*/
@@ -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*/
static const char VALUEFLAG_DECREASE = 0x02;
//----- SPIT_Client -----
public:
//----- SPIT_Client -----
public:
SPIT_Client(string name, string projName, Callbacks calls);
virtual ~SPIT_Client();
static int s_MAX_OVERTAKING_SPIT_MESSAGES;
private:
private:
Callbacks mCallbacks;
fos::TaskT<SPIT_Client&> * m_ThreadReceive{};
fos::TaskT<SPIT_Client &> *m_ThreadReceive{};
bool m_StopReceiveSPITMessages;
int m_ConnectionStatus;
bool m_DisconnectedByServer{}; //flag true = when server disconnects
bool m_DisconnectedByServer{}; // flag true = when server disconnects
string m_ID;
string m_Name;
string m_ProjName;
@@ -113,9 +120,9 @@ private:
unsigned char m_MessageNumber_Send;
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_ServerName{};
string m_ServerComputerName{};
@@ -126,7 +133,7 @@ private:
string m_ServerProjectName;
int m_ServerFramesPerSecond;
public:
public:
/** The ID of the client.<br>Every client instance should set an unique id*/
string getID() { return m_ID; }
/** 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; }
string getClientProjectName() { return m_ClientProjectName; }
//connected Server Infos
// connected Server Infos
/** The ID of the connected SPITServer*/
string getServerID() { return m_ServerID; }
/** The host computername of the connected SPITServer*/
@@ -166,31 +173,31 @@ public:
void setActionSPITType(string p_SPITTypeID, bool p_ActionAssigned);
void setActionSPITObject(string p_SPITObjectID, bool p_ActionAssigned);
//--------------- SPITMessage ---------------
private:
//--------------- SPITMessage ---------------
private:
bool startReceiveSPITMessages();
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
bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by m_ServerID
public:
void fillHeader(SPIT_Message::Header* p_Header);
int sendSPITMessage(SPIT_Message::OPPart& p_SPITMessageOPPart);
public:
void fillHeader(SPIT_Message::Header *p_Header);
int sendSPITMessage(SPIT_Message::OPPart &p_SPITMessageOPPart);
//--------------- ServerAutoDetection SAD ---------------
public:
//--------------- ServerAutoDetection SAD ---------------
public:
/** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before.*/
void startServerAutoDetect();
/** Stops the autodetection of SPITServers in the local network*/
void stopServerAutoDetect();
/** Called every time a new SPITServer is detetced in the local network */
void eventServerDetected(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.*/
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 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 eventServerLost(SAD_DetectedServer &server);
void eventServerChanged(SAD_DetectedServer &server);
//--------------- Connection ---------------
public:
//--------------- Connection ---------------
public:
/**
* Tries a connection to the SPITServer
* @param p_ServerIP ip address of the SPITServer
@@ -208,26 +215,28 @@ public:
*/
void disconnect();
private:
private:
void disconnectInternal(int p_Cause);
void resetMessageNumberReceived();
void parseSPIT_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 parseConnectAnswer(SPIT_Message::ConnectAnswer* p_ConnectAnswer);
void parseDisconnect(SPIT_Message::Disconnect* p_Disconnect);
void parseWatchdog(SPIT_Message::Watchdog* p_Watchdog);
void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer* p_WatchdogAnswer);
public:
void addOvertakingSPIT_Message(SPIT_Message *p_SPIT_Message);
void parseConnectAnswer(SPIT_Message::ConnectAnswer *p_ConnectAnswer);
void parseDisconnect(SPIT_Message::Disconnect *p_Disconnect);
void parseWatchdog(SPIT_Message::Watchdog *p_Watchdog);
void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer *p_WatchdogAnswer);
public:
/** Used internally*/
void sendWatchdog();
/** Used internally. When the connection to the SPITServer is lost an eventConnectionStatus will occur*/
void eventWatchdogLost();
//--------------- SPIT Project ---------------
private:
void parseReportSPITProject(SPIT_Message::ReportSPITProject* p_ReportSPITProject);
void parseCloseSPITProject(SPIT_Message::CloseSPITProject* p_CloseSPITProject);
public:
//--------------- SPIT Project ---------------
private:
void parseReportSPITProject(SPIT_Message::ReportSPITProject *p_ReportSPITProject);
void parseCloseSPITProject(SPIT_Message::CloseSPITProject *p_CloseSPITProject);
public:
/** Returns the SPITServer's project ID - may be the same as the project's name*/
string getServerProjectID();
/** 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.*/
int getServerFramesPerSecond();
private:
void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer* p_RequestProjectTransfer);
void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer* p_StartProjectTransfer);
void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer* p_EndProjectTransfer);
public:
static void sendProject(SPIT_Client* p_PtrSPIT_Client);
private:
void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer *p_RequestProjectTransfer);
void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer *p_StartProjectTransfer);
void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer *p_EndProjectTransfer);
// --------------- 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>
* 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
* @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>
@@ -269,20 +279,22 @@ public:
* @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.
*/
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
void parseReportSPITType(SPIT_Message::ReportSPITType* p_ReportSPITType);
void parseRemoveSPITType(SPIT_Message::RemoveSPITType* p_RemoveSPITType);
int sendSPITTypeInternal(SPITType* p_SPITType);
public:
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
void parseReportSPITType(SPIT_Message::ReportSPITType *p_ReportSPITType);
void parseRemoveSPITType(SPIT_Message::RemoveSPITType *p_RemoveSPITType);
int sendSPITTypeInternal(SPITType *p_SPITType);
public:
/**
* If a client wants to change a SPITType, he should send it to the server.<br>
* If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br>
* @param p_SPITTypeID the id of the SPITType to remove.
* @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 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
*/
int removeSPITType(string p_SPITTypeID);
public:
//--------------- SPIT Objects ---------------
private:
void parseReportSPITObject(SPIT_Message::ReportSPITObject* p_ReportSPITObject);
void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject* p_RemoveSPITObject);
int sendSPITObjectInternal(SPITObject* ptrSPITObject);
public:
public:
//--------------- SPIT Objects ---------------
private:
void parseReportSPITObject(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject *p_RemoveSPITObject);
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>
* The SPITServer may discard the changes and an eventSPITObject occurs.<br>
* @param p_SPITObject the pointer to the changed SPITObject.
* @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>
* The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
@@ -312,31 +325,29 @@ public:
* @return 0 = sended, -1 = not sended
*/
int removeSPITObject(string p_SPITObjectID);
public:
//--------------- Play SPIT Objects ---------------
private:
void parsePlaySPITStart(SPIT_Message::PlaySPITStart* p_PlaySPITStart);
void parsePlaySPITObject(SPIT_Message::PlaySPITObject* p_PlaySPITObject);
void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd* p_PlaySPITEnd);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus* p_ReportPlayStatus);
public:
//--------------- Play SPIT Objects ---------------
private:
void parsePlaySPITStart(SPIT_Message::PlaySPITStart *p_PlaySPITStart);
void parsePlaySPITObject(SPIT_Message::PlaySPITObject *p_PlaySPITObject);
void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd *p_PlaySPITEnd);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus *p_ReportPlayStatus);
public:
//--------- Remote ----------
void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00);
private:
static void processSocketTask(SPIT_Client & instance);
fos::TaskT<SPIT_Client &>* sThread{};
static void processSocketTask(SPIT_Client &instance);
fos::TaskT<SPIT_Client &> *sThread{};
bool abortSearch{};
bool sAnswered{};
static fos::Semaphore sStartSad;
SPITSocket * mSPITSocket;
SPITSocket *mSPITSocket;
void answerWatchdog() {
sAnswered = true;
}
};
#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 "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() {
}
@@ -29,7 +29,6 @@ SAD_DetectedServer::SAD_DetectedServer() {
m_ClientIP = "";
m_Port = "";
m_Additions = "";
m_IPIsIP4 = false;
}
void SAD_DetectedServer::setProjectName(string p_ServerProjectName) {
@@ -46,94 +45,43 @@ void SAD_DetectedServer::cycleStart() {
i->second->startCycleSAD();
}
}
void SAD_DetectedServer::cycleEnd(I_SAD_Client& sadClient) {
list<SAD_DetectedServer*> o_LostServers;
list<SAD_DetectedServer*> o_NewServers;
list<SAD_DetectedServer*> o_ChangedServers;
SAD_DetectedServer* ptrDetectedServer;
{
for (auto i = s_DetectedServers.begin(); i != s_DetectedServers.end(); i++) {
ptrDetectedServer = i->second;
void SAD_DetectedServer::cycleEnd(I_SAD_Client &sadClient) {
for (auto &srv : s_DetectedServers) {
SAD_DetectedServer *ptrDetectedServer = srv.second;
if (ptrDetectedServer->getFoundAgain() == false) {
o_LostServers.push_back(ptrDetectedServer);
ptrDetectedServer->endCycleSAD();
}
else if (ptrDetectedServer->getNew()) {
o_NewServers.push_back(ptrDetectedServer);
sadClient.eventServerLost(*ptrDetectedServer);
removeDetectedServer(*ptrDetectedServer);
} else if (ptrDetectedServer->getNew()) {
ptrDetectedServer->setNew(false);
ptrDetectedServer->endCycleSAD();
}
else if (ptrDetectedServer->getChanged()) {
o_ChangedServers.push_back(ptrDetectedServer);
ptrDetectedServer->endCycleSAD();
}
else {
ptrDetectedServer->endCycleSAD();
sadClient.eventServerDetected(*ptrDetectedServer);
} else if (ptrDetectedServer->getChanged()) {
sadClient.eventServerChanged(*ptrDetectedServer);
}
}
}
//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
* @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_ServerParams the server's parameter
*/
void SAD_DetectedServer::addDetectedServer(bool p_IsIP4, string p_ServerID, string p_ServerParams[]) {
SAD_DetectedServer* ptrDetectedServer;
void SAD_DetectedServer::addDetectedServer(string p_ServerID, string p_ServerParams[]) {
SAD_DetectedServer *ptrDetectedServer;
{
auto i = s_DetectedServers.find(p_ServerID);
if (i != s_DetectedServers.end()) {
ptrDetectedServer = i->second;
}
else {
} else {
ptrDetectedServer = new SAD_DetectedServer();
ptrDetectedServer->setID(p_ServerParams[PARAMINDEX_ID]);
ptrDetectedServer->setNew(true);
}
ptrDetectedServer->setFoundAgain();
//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){
// second prefer IP4
ptrDetectedServer->setIP(p_ServerParams[PARAMINDEX_IP]);
ptrDetectedServer->setClientIP(p_ServerParams[PARAMINDEX_CLIENTIP]);
}
ptrDetectedServer->setName(p_ServerParams[PARAMINDEX_NAME]);
ptrDetectedServer->setComputerName(p_ServerParams[PARAMINDEX_COMPUTERNAME]);
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;
}
}
/**
}
/**
* Used by SAD_Client to remove a SPITServer - don't use this manually
* @param p_DetectedServer
*/
void SAD_DetectedServer::removeDetectedServer(SAD_DetectedServer* p_DetectedServer) {
SAD_DetectedServer* o_DetectedServer;
{
auto i = s_DetectedServers.find(p_DetectedServer->getID());
void SAD_DetectedServer::removeDetectedServer(SAD_DetectedServer &server) {
auto i = s_DetectedServers.find(server.getID());
if (i != s_DetectedServers.end()) {
o_DetectedServer = i->second;
SAD_DetectedServer *o_DetectedServer = i->second;
i = s_DetectedServers.erase(i);
delete o_DetectedServer;
}
}
}
}
/**
/**
* Used by SAD_Client to clear all found SPITServers - don't use this manually
*/
void SAD_DetectedServer::clearDetectedServers() {
SAD_DetectedServer* ptrDetectedServer;
{
for (auto i = s_DetectedServers.begin(); i != s_DetectedServers.end(); i++) {
ptrDetectedServer = i->second;
SAD_DetectedServer *ptrDetectedServer = i->second;
i = s_DetectedServers.erase(i);
delete ptrDetectedServer;
if (i == s_DetectedServers.end()) {
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 "SPITSocket.h"
unordered_map<string, SPITObject*> SPITObject::s_SPITObjects;
unordered_map<string, SPITObject*> SPITObject::s_SPITObjectsRemote;
unordered_map<string, SPITObject *> SPITObject::s_SPITObjects;
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);
if (i == s_SPITObjects.end()) {
@@ -26,14 +26,14 @@
}
return i->second;
}
}
/**
}
/**
* Returns the reference of the SPITObject with ID == p_ID.<br>
* Throws an exception if no SPITObject is not found.<br>
* @param p_ID the 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);
if (i == s_SPITObjects.end()) {
@@ -41,9 +41,9 @@
}
return *(i->second);
}
}
}
SPITObject* SPITObject::getSPITObjectRemote(string p_ID) {
SPITObject *SPITObject::getSPITObjectRemote(string p_ID) {
{
auto i = s_SPITObjectsRemote.find(p_ID);
if (i == s_SPITObjectsRemote.end()) {
@@ -51,14 +51,14 @@
}
return i->second;
}
}
/**
}
/**
* Returns the reference of the remote SPITObject with ID == p_ID.<br>
* Throws an exception if no SPITObject is not found.<br>
* @param p_ID the 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);
if (i == s_SPITObjectsRemote.end()) {
@@ -66,27 +66,30 @@
}
return *(i->second);
}
}
}
bool SPITObject::addSPITObject(SPITObject* p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false;
bool SPITObject::addSPITObject(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL)
return false;
{
s_SPITObjects[p_ptrSPITObject->getID()] = p_ptrSPITObject;
return true;
}
}
bool SPITObject::addSPITObjectRemote(SPITObject* p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false;
}
bool SPITObject::addSPITObjectRemote(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL)
return false;
{
s_SPITObjectsRemote[p_ptrSPITObject->getID()] = p_ptrSPITObject;
return true;
}
}
bool SPITObject::removeSPITObject(SPITObject* p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false;
}
bool SPITObject::removeSPITObject(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL)
return false;
return removeSPITObject(p_ptrSPITObject->getID());
}
bool SPITObject::removeSPITObject(string p_SPITObjectID) {
}
bool SPITObject::removeSPITObject(string p_SPITObjectID) {
{
auto i = s_SPITObjects.find(p_SPITObjectID);
if (i == s_SPITObjects.end()) {
@@ -95,12 +98,13 @@
i = s_SPITObjects.erase(i);
return true;
}
}
bool SPITObject::removeSPITObjectRemote(SPITObject* p_ptrSPITObject) {
if (p_ptrSPITObject == NULL) return false;
}
bool SPITObject::removeSPITObjectRemote(SPITObject *p_ptrSPITObject) {
if (p_ptrSPITObject == NULL)
return false;
return removeSPITObjectRemote(p_ptrSPITObject->getID());
}
bool SPITObject::removeSPITObjectRemote(string p_ptrSPITObject) {
}
bool SPITObject::removeSPITObjectRemote(string p_ptrSPITObject) {
{
auto i = s_SPITObjectsRemote.find(p_ptrSPITObject);
if (i == s_SPITObjectsRemote.end()) {
@@ -109,81 +113,77 @@
i = s_SPITObjectsRemote.erase(i);
return true;
}
}
}
int SPITObject::getSPITObjectCount() {
int SPITObject::getSPITObjectCount() {
return s_SPITObjects.size();
}
int SPITObject::getSPITObjectRemoteCount() {
}
int SPITObject::getSPITObjectRemoteCount() {
return s_SPITObjectsRemote.size();
}
SPITObject* SPITObject::getSPITObject(int p_Index) {
SPITObject* ptrSPITObject = NULL;
}
SPITObject *SPITObject::getSPITObject(int p_Index) {
SPITObject *ptrSPITObject = NULL;
{
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;
return ptrSPITObject;
}
else {
} else {
return NULL;
}
}
}
/**
}
/**
* Returns a reference to the SPITObject at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br>
* @param p_Index position
* @return the reference of the SPITObject at position.
*/
const SPITObject& SPITObject::getSPITObjectRef(int p_Index) {
SPITObject* ptrSPITObject = NULL;
const SPITObject &SPITObject::getSPITObjectRef(int p_Index) {
SPITObject *ptrSPITObject = NULL;
{
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;
return *ptrSPITObject;
}
else {
} else {
throw "SPITObject index out of range";
}
}
}
SPITObject* SPITObject::getSPITObjectRemote(int p_Index) {
SPITObject* ptrSPITObject = NULL;
}
SPITObject *SPITObject::getSPITObjectRemote(int p_Index) {
SPITObject *ptrSPITObject = NULL;
{
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;
return ptrSPITObject;
}
else {
} else {
return NULL;
}
}
}
/**
}
/**
* Returns a reference to the remote SPITObject at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br>
* @param p_Index position
* @return the reference of the SPITObject at position.
*/
const SPITObject& SPITObject::getSPITObjectRemoteRef(int p_Index) {
SPITObject* ptrSPITObject = NULL;
const SPITObject &SPITObject::getSPITObjectRemoteRef(int p_Index) {
SPITObject *ptrSPITObject = NULL;
{
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;
return *ptrSPITObject;
}
else {
} else {
throw "Remote SPITObject index out of range";
}
}
}
}
void SPITObject::clearSPITObjects() {
SPITObject* ptrSPITObject;
void SPITObject::clearSPITObjects() {
SPITObject *ptrSPITObject;
{
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
ptrSPITObject = i->second;
@@ -194,9 +194,9 @@
}
}
}
}
void SPITObject::clearSPITObjectsRemote() {
SPITObject* ptrSPITObject;
}
void SPITObject::clearSPITObjectsRemote() {
SPITObject *ptrSPITObject;
{
for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) {
ptrSPITObject = i->second;
@@ -207,14 +207,14 @@
}
}
}
}
}
/**
/**
* 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++) {
SPITObject* ptrSPITObject = i->second;
SPITObject *ptrSPITObject = i->second;
if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) {
i = s_SPITObjects.erase(i);
delete ptrSPITObject;
@@ -223,11 +223,11 @@
break;
}
}
}
}
void SPITObject::eventProjectClosed() {
void SPITObject::eventProjectClosed() {
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
SPITObject* ptrSPITObject = i->second;
SPITObject *ptrSPITObject = i->second;
if (ptrSPITObject->getCreatedByClient() == true) {
continue;
}
@@ -237,31 +237,29 @@
break;
}
}
//Remote
// Remote
for (auto i = s_SPITObjectsRemote.begin(); i != s_SPITObjectsRemote.end(); i++) {
SPITObject* ptrSPITObject = i->second;
SPITObject *ptrSPITObject = i->second;
i = s_SPITObjectsRemote.erase(i);
delete ptrSPITObject;
if (i == s_SPITObjectsRemote.end()) {
break;
}
}
}
/**
}
/**
* sets confirmed = false for all SPITObjects.<br>
* This should be called when the client has loaded a project.<br>
*/
void SPITObject::setConfirmedFalse() {
SPITObject* ptrSPITObject;
void SPITObject::setConfirmedFalse() {
SPITObject *ptrSPITObject;
{
for (auto i = s_SPITObjects.begin(); i != s_SPITObjects.end(); i++) {
ptrSPITObject = i->second;
ptrSPITObject->setConfirmed(false);
}
}
}
}
SPITObject::SPITObject() {
initMembers();
@@ -285,119 +283,132 @@ void SPITObject::initMembers() {
m_ServerParams = "";
m_ServerRemote = false;
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;
}
SPITObject::~SPITObject() { }
SPITObject::~SPITObject() {}
bool SPITObject::setMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject) {
bool SPITObject::setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
bool boolChangeAllowed;
bool boolChanged = false;
if (m_CreatedByClient == true && m_Fixed == true) {
boolChangeAllowed = false;
}
else {
} else {
boolChangeAllowed = true;
}
//Confirmation should be changable
// Confirmation should be changable
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;
}
else {
//type is NOT client created -> the client has to confirm the SPITtype
} else {
// type is NOT client created -> the client has to confirm the SPITtype
m_Confirmed = p_ReportSPITObject->getConfirmed();
}
if (m_Delay != p_ReportSPITObject->getDelay()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Delay = p_ReportSPITObject->getDelay();
boolChanged = true;
}
if (m_Duration != p_ReportSPITObject->getDuration()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Duration = p_ReportSPITObject->getDuration();
boolChanged = true;
}
if (m_Fixed != p_ReportSPITObject->getFixed()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Fixed = p_ReportSPITObject->getFixed();
boolChanged = true;
}
if (m_FrameFadeInLength != p_ReportSPITObject->getFrameFadeInLength()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_FrameFadeInLength = p_ReportSPITObject->getFrameFadeInLength();
boolChanged= true;
boolChanged = true;
}
if (m_FrameFadeOutLength != p_ReportSPITObject->getFrameFadeOutLength()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_FrameFadeOutLength = p_ReportSPITObject->getFrameFadeOutLength();
boolChanged = true;
}
if (m_FrameLength != p_ReportSPITObject->getFrameLength()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_FrameLength = p_ReportSPITObject->getFrameLength();
boolChanged = true;
}
if (m_FrameStart != p_ReportSPITObject->getFrameStart()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_FrameStart = p_ReportSPITObject->getFrameStart();
boolChanged = true;
}
if (m_Remark != p_ReportSPITObject->getRemark()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Remark = p_ReportSPITObject->getRemark();
boolChanged = true;
}
if (m_ID != p_ReportSPITObject->getID()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ID = p_ReportSPITObject->getID();
boolChanged = true;
}
if (m_Name != p_ReportSPITObject->getName()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Name = p_ReportSPITObject->getName();
boolChanged = true;
}
if (m_SPITTypeID != p_ReportSPITObject->getSPITTypeID()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_SPITTypeID = p_ReportSPITObject->getSPITTypeID();
boolChanged = true;
}
if (m_ServerParams != p_ReportSPITObject->getServerParams()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ServerParams = p_ReportSPITObject->getServerParams();
boolChanged = true;
}
if (m_ServerRemote != p_ReportSPITObject->getServerRemote()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ServerRemote = p_ReportSPITObject->getServerRemote();
boolChanged = true;
}
if (m_Track != p_ReportSPITObject->getTrack()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Track = p_ReportSPITObject->getTrack();
boolChanged = true;
}
if (m_ValueFactor != p_ReportSPITObject->getValueFactor()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ValueFactor = p_ReportSPITObject->getValueFactor();
boolChanged = true;
}
if (m_ValueUse != p_ReportSPITObject->getValueUse()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ValueUse = p_ReportSPITObject->getValueUse();
boolChanged = true;
}
return boolChanged;
}
void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObject) {
p_ReportSPITObject->setActionAssigned(getActionAssigned()); //Action can be assigned to type or to this object
void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
p_ReportSPITObject->setActionAssigned(getActionAssigned()); // Action can be assigned to type or to this object
p_ReportSPITObject->setConfirmed(m_Confirmed);
p_ReportSPITObject->setDelay(m_Delay);
p_ReportSPITObject->setDuration(m_Duration);
@@ -416,7 +427,7 @@ void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject* p_ReportSPITObjec
p_ReportSPITObject->setValueFactor(m_ValueFactor);
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);
}
@@ -433,121 +444,141 @@ void SPITObject::setCreatedByClient(bool p_CreatedByClient) {
* @return if m_Confirmed has changed
*/
bool SPITObject::setConfirmed(bool p_Confirmed) {
if (m_Confirmed == p_Confirmed) return false;
if (m_Confirmed == p_Confirmed)
return false;
m_Confirmed = p_Confirmed;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
/**
/**
* 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>
* Then this action is done for every SPITObject with the SPITType.
* @return true = an action is assigned for the SPITType.
*/
bool SPITObject::setActionAssignedType(bool p_ActionAssigned) {
if (m_ActionAssignedType == p_ActionAssigned) return false;
if (m_ActionAssignedType == p_ActionAssigned)
return false;
bool boolOldActionAssigend;
boolOldActionAssigend = getActionAssigned();
m_ActionAssignedType = p_ActionAssigned;
if (getActionAssigned() == boolOldActionAssigend) return false;
if (getActionAssigned() == boolOldActionAssigend)
return false;
m_Confirmed = false;
return true;
}
bool SPITObject::setActionAssigned(bool p_ActionAssigned) {
if (m_ActionAssigned == p_ActionAssigned) return false;
if (m_ActionAssigned == p_ActionAssigned)
return false;
bool boolOldActionAssigend;
boolOldActionAssigend = getActionAssigned();
m_ActionAssigned = p_ActionAssigned;
if (getActionAssigned() == boolOldActionAssigend) return false;
if (getActionAssigned() == boolOldActionAssigend)
return false;
m_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
}
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_Confirmed = false;
return true;
components/spit/src/SPITPlayer.cpp
+16 -19
View File
@@ -15,29 +15,30 @@
#include "SPITPlayer.h"
#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);
if (i == s_SPITPlayers.end()) {
s_SPITPlayers[p_PlayerID] = new SPITPlayer(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;
}
}
void SPITPlayer::clearPlayers() {
;
vector<SPITPlayer*> o_SPITPlayers;
vector<SPITPlayer *> o_SPITPlayers;
for (auto i = s_SPITPlayers.begin(); i != s_SPITPlayers.end(); i++) {
SPITPlayer* ptrSPITPlayer = i->second;
SPITPlayer *ptrSPITPlayer = i->second;
o_SPITPlayers.push_back(ptrSPITPlayer);
}
for (auto i = o_SPITPlayers.begin(); i != o_SPITPlayers.end(); i++) {
SPITPlayer* ptrSPITPlayer = *i;
SPITPlayer *ptrSPITPlayer = *i;
delete ptrSPITPlayer;
}
o_SPITPlayers.clear();
@@ -49,7 +50,7 @@ SPITPlayer::SPITPlayer(string p_PlayerID) {
}
SPITPlayer::~SPITPlayer() {
PlaySPITType* ptrPlaySPITType;
PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second;
i = m_PlaySPITTypes.erase(i);
@@ -58,7 +59,6 @@ SPITPlayer::~SPITPlayer() {
break;
}
}
}
void SPITPlayer::setIsRunning(bool p_IsRunning) {
@@ -74,7 +74,7 @@ void SPITPlayer::setTime(long long p_Frames) {
m_TimeFrames = p_Frames;
}
unordered_map<string, SPITPlayer::PlaySPITType*>* SPITPlayer::getPlaySPITTypes() {
unordered_map<string, SPITPlayer::PlaySPITType *> *SPITPlayer::getPlaySPITTypes() {
return &m_PlaySPITTypes;
}
/**
@@ -83,8 +83,8 @@ unordered_map<string, SPITPlayer::PlaySPITType*>* SPITPlayer::getPlaySPITTypes()
* @return true = new PlayObject added<br>
* false = PlayObject exists
*/
SPITPlayer::PlaySPITType* SPITPlayer::addSPITType_Playing (string p_SPITTypeID) {
PlaySPITType* ptrPlaySPITType;
SPITPlayer::PlaySPITType *SPITPlayer::addSPITType_Playing(string p_SPITTypeID) {
PlaySPITType *ptrPlaySPITType;
auto i = m_PlaySPITTypes.find(p_SPITTypeID);
if (i == m_PlaySPITTypes.end()) {
@@ -92,17 +92,15 @@ SPITPlayer::PlaySPITType* SPITPlayer::addSPITType_Playing (string p_SPITTypeID)
ptrPlaySPITType->setIsPlayed(true);
ptrPlaySPITType->setIsNew(true);
m_PlaySPITTypes[p_SPITTypeID] = ptrPlaySPITType;
}
else {
} else {
ptrPlaySPITType = i->second;
ptrPlaySPITType->setIsPlayed(true);
}
return ptrPlaySPITType;
}
void SPITPlayer::startPlaySequence() {
PlaySPITType* ptrPlaySPITType;
PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second;
ptrPlaySPITType->startPlaySequence();
@@ -110,7 +108,7 @@ void SPITPlayer::startPlaySequence() {
}
void SPITPlayer::endPlaySequence() {
PlaySPITType* ptrPlaySPITType;
PlaySPITType *ptrPlaySPITType;
for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
ptrPlaySPITType = i->second;
@@ -122,19 +120,18 @@ void SPITPlayer::endPlaySequence() {
}
}
}
}
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_PlayerID = p_SPITPlayer->getID();
m_PlayerName = p_SPITPlayer->getName();
startPlaySequence();
m_IsNew = true;
}
SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType& orig) {
SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType &orig) {
m_SPITTypeID = orig.getSPITTypeID();
m_IsPlayed = orig.getIsPlayed();
m_IsNew = orig.getIsNew();
components/spit/src/SPITSocket.cpp
+7 -7
View File
@@ -15,11 +15,11 @@
#include "SPITSocket.h"
#include "Task.hpp"
#include "esp/uuid.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp/uuid.h"
#include <unistd.h>
#include <string>
#include <unistd.h>
using namespace std;
/**
@@ -201,7 +201,7 @@ int SPITSocket::sendMessageTo(int p_InetFamily, string p_ServerIP, string p_Serv
}
return 0;
}
/**
/**
* Call this for receiving a message
* This will block until a message is received or the underlying socket is closed
* @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);
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 (p_ServerIP != NULL) {
char bufferIP4[INET_ADDRSTRLEN];
@@ -239,7 +239,6 @@ int SPITSocket::receiveMessage(int p_InetFamily, char *p_Buffer, int p_BufferLen
return intResult;
}
SPITSocket::IPAddress SPITSocket::getAdaptersInfo() {
// iterate over active interfaces, and print out IPs
esp_netif_t *netif = NULL;
@@ -279,10 +278,11 @@ string createGUID() {
/** The name of the client's host computer*/
string getClientHostName() {
string stringHostName = "";
const char * hostname;
const char *hostname;
esp_netif_get_hostname(esp_netif_get_default_netif(), &hostname);
if (hostname != nullptr) {
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
*/
#include "SPITType.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_SPITTypesRemote;
unordered_map<string, SPITType *> SPITType::s_SPITTypes;
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);
if (i == s_SPITTypes.end()) {
@@ -29,14 +28,14 @@ static const char * TAG = "SPIT";
}
return i->second;
}
}
/**
}
/**
* Returns the reference of the SPITType with ID == p_ID.<br>
* Throws an exception if no SPITType is not found.<br>
* @param p_ID the 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);
if (i == s_SPITTypes.end()) {
@@ -44,9 +43,9 @@ static const char * TAG = "SPIT";
}
return *(i->second);
}
}
}
SPITType* SPITType::getSPITTypeRemote(string p_ID) {
SPITType *SPITType::getSPITTypeRemote(string p_ID) {
{
auto i = s_SPITTypesRemote.find(p_ID);
if (i == s_SPITTypesRemote.end()) {
@@ -54,14 +53,14 @@ static const char * TAG = "SPIT";
}
return i->second;
}
}
/**
}
/**
* Returns the reference of the remote SPITType with ID == p_ID.<br>
* Throws an exception if no SPITType is not found.<br>
* @param p_ID the 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);
if (i == s_SPITTypesRemote.end()) {
@@ -69,24 +68,27 @@ static const char * TAG = "SPIT";
}
return *(i->second);
}
}
}
bool SPITType::addSPITType(SPITType* p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false;
bool SPITType::addSPITType(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL)
return false;
{
s_SPITTypes[p_ptrSpitType->getID()] = p_ptrSpitType;
return true;
}
}
bool SPITType::addSPITTypeRemote(SPITType* p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false;
}
bool SPITType::addSPITTypeRemote(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL)
return false;
{
s_SPITTypesRemote[p_ptrSpitType->getID()] = p_ptrSpitType;
return true;
}
}
bool SPITType::removeSPITType(SPITType* p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false;
}
bool SPITType::removeSPITType(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL)
return false;
{
auto i = s_SPITTypes.find(p_ptrSpitType->getID());
if (i == s_SPITTypes.end()) {
@@ -95,9 +97,10 @@ static const char * TAG = "SPIT";
i = s_SPITTypes.erase(i);
return true;
}
}
bool SPITType::removeSPITTypeRemote(SPITType* p_ptrSpitType) {
if (p_ptrSpitType == NULL) return false;
}
bool SPITType::removeSPITTypeRemote(SPITType *p_ptrSpitType) {
if (p_ptrSpitType == NULL)
return false;
{
auto i = s_SPITTypesRemote.find(p_ptrSpitType->getID());
if (i == s_SPITTypesRemote.end()) {
@@ -106,75 +109,73 @@ static const char * TAG = "SPIT";
i = s_SPITTypesRemote.erase(i);
return true;
}
}
}
int SPITType::getSPITTypeCount() {
int SPITType::getSPITTypeCount() {
return s_SPITTypes.size();
}
int SPITType::getSPITTypeRemoteCount() {
}
int SPITType::getSPITTypeRemoteCount() {
return s_SPITTypesRemote.size();
}
SPITType* SPITType::getSPITType(int p_Index) {
SPITType* ptrSPITType = NULL;
}
SPITType *SPITType::getSPITType(int p_Index) {
SPITType *ptrSPITType = NULL;
{
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;
}
return ptrSPITType;
}
}
/**
}
/**
* Returns a reference to the SPITType at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br>
* @param p_Index position
* @return the reference of the SPITType at position.
*/
const SPITType& SPITType::getSPITTypeRef(int p_Index) {
SPITType* ptrSPITType = NULL;
const SPITType &SPITType::getSPITTypeRef(int p_Index) {
SPITType *ptrSPITType = NULL;
{
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;
return *ptrSPITType;
}
else {
} else {
throw "SPITType index out of range";
}
}
}
SPITType* SPITType::getSPITTypeRemote(int p_Index) {
SPITType* ptrSPITType = NULL;
}
SPITType *SPITType::getSPITTypeRemote(int p_Index) {
SPITType *ptrSPITType = NULL;
{
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;
}
return ptrSPITType;
}
}
/**
}
/**
* Returns a reference to the remote SPITType at position p_Index.<br>
* Throws an exception if p_Index is out of range.<br>
* @param p_Index position
* @return the reference of the SPITType at position.
*/
const SPITType& SPITType::getSPITTypeRemoteRef(int p_Index) {
SPITType* ptrSPITType = NULL;
const SPITType &SPITType::getSPITTypeRemoteRef(int p_Index) {
SPITType *ptrSPITType = NULL;
{
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;
return *ptrSPITType;
}
else {
} else {
throw "Remote SPITType index out of range";
}
}
}
}
void SPITType::clearSPITTypes() {
SPITType* ptrSPITType;
void SPITType::clearSPITTypes() {
SPITType *ptrSPITType;
{
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second;
@@ -185,9 +186,9 @@ static const char * TAG = "SPIT";
}
}
}
}
void SPITType::clearSPITTypesRemote() {
SPITType* ptrSPITType;
}
void SPITType::clearSPITTypesRemote() {
SPITType *ptrSPITType;
{
for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) {
ptrSPITType = i->second;
@@ -198,10 +199,10 @@ static const char * TAG = "SPIT";
}
}
}
}
}
void SPITType::eventProjectClosed() {
SPITType* ptrSPITType;
void SPITType::eventProjectClosed() {
SPITType *ptrSPITType;
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second;
if (ptrSPITType->getCreatedByClient() == true) {
@@ -213,7 +214,7 @@ static const char * TAG = "SPIT";
break;
}
}
//Remote
// Remote
for (auto i = s_SPITTypesRemote.begin(); i != s_SPITTypesRemote.end(); i++) {
ptrSPITType = i->second;
i = s_SPITTypesRemote.erase(i);
@@ -222,26 +223,21 @@ static const char * TAG = "SPIT";
break;
}
}
}
}
/**
/**
* Sets confirmed = false for all SPITTypes.<br>
* This should be called when the client has loaded a project.<br>
*/
void SPITType::setConfirmedFalse() {
SPITType* ptrSPITType;
void SPITType::setConfirmedFalse() {
SPITType *ptrSPITType;
{
for (auto i = s_SPITTypes.begin(); i != s_SPITTypes.end(); i++) {
ptrSPITType = i->second;
ptrSPITType->setConfirmed(false);
}
}
}
}
SPITType::SPITType() {
initMembers();
@@ -259,7 +255,7 @@ SPITType::SPITType(const SPITType& orig) {
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();
m_ActionAssigned = false;
m_Confirmed = false;
@@ -287,154 +283,166 @@ void SPITType::initMembers() {
m_ServerRemote = false;
}
void SPITType::setCreatedByClient(bool p_CreatedByClient) {
m_CreatedByClient = p_CreatedByClient;
}
void SPITType::setID(string p_ID) {
void SPITType::setID(string p_ID) {
m_ID = p_ID;
}
}
/**
/**
* This is used by the server and client to tell if the other side has registered the changes.
* @param p_Confirmed
* @return if m_Confirmed has changed
*/
bool SPITType::setConfirmed(bool p_Confirmed) {
if (m_Confirmed == p_Confirmed) return false;
bool SPITType::setConfirmed(bool p_Confirmed) {
if (m_Confirmed == p_Confirmed)
return false;
m_Confirmed = p_Confirmed;
return true;
}
}
bool SPITType::setGroupName(string p_GroupName) {
if (m_GroupName == p_GroupName) return false;
bool SPITType::setGroupName(string p_GroupName) {
if (m_GroupName == p_GroupName)
return false;
m_GroupName = p_GroupName;
m_Confirmed = false;
return true;
}
bool SPITType::setName(string p_Name) {
if (m_Name == p_Name) return false;
}
bool SPITType::setName(string p_Name) {
if (m_Name == p_Name)
return false;
m_Name = p_Name;
m_Confirmed = false;
return true;
}
bool SPITType::setServerRemote(bool p_BelongstoServer) {
if (m_ServerRemote == p_BelongstoServer) return false;
}
bool SPITType::setServerRemote(bool p_BelongstoServer) {
if (m_ServerRemote == p_BelongstoServer)
return false;
m_ServerRemote = p_BelongstoServer;
m_Confirmed = false;
return true;
}
bool SPITType::setProjectIndepended(bool p_ProjectIndepended) {
if (m_ServerProjectIndepended == p_ProjectIndepended) return false;
}
bool SPITType::setProjectIndepended(bool p_ProjectIndepended) {
if (m_ServerProjectIndepended == p_ProjectIndepended)
return false;
m_ServerProjectIndepended = p_ProjectIndepended;
m_Confirmed = false;
return true;
}
bool SPITType::setFixed(bool p_Fixed) {
if (m_Fixed == p_Fixed) return false;
}
bool SPITType::setFixed(bool p_Fixed) {
if (m_Fixed == p_Fixed)
return false;
m_Fixed = p_Fixed;
m_Confirmed = false;
return true;
}
bool SPITType::setDefaultDelay(long long p_Delay) {
if (m_DefaultDelay == p_Delay) return false;
}
bool SPITType::setDefaultDelay(long long p_Delay) {
if (m_DefaultDelay == p_Delay)
return false;
m_DefaultDelay = p_Delay;
m_Confirmed = false;
return true;
}
bool SPITType::setDefaultDuration(long long p_Duration) {
if (m_DefaultDuration == p_Duration) return false;
}
bool SPITType::setDefaultDuration(long long p_Duration) {
if (m_DefaultDuration == p_Duration)
return false;
m_DefaultDuration = p_Duration;
m_Confirmed = false;
return true;
}
}
/**
/**
* 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 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.
*/
bool SPITType::setActionAssigned(bool p_ActionAssigned) {
if (m_ActionAssigned == p_ActionAssigned) return false;
bool SPITType::setActionAssigned(bool p_ActionAssigned) {
if (m_ActionAssigned == p_ActionAssigned)
return false;
m_ActionAssigned = p_ActionAssigned;
m_Confirmed = false;
return true;
}
}
/**
/**
* Set the content of the SPITType as received from the server
* @param p_ReportSPITType
* @return true = the SPITType is changed<br>
* 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 boolChanged = false;
if (m_CreatedByClient == true && m_Fixed == true) {
boolChangeAllowed = false;
}
else {
} else {
boolChangeAllowed = true;
}
//Confirmation should be changable
// Confirmation should be changable
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;
}
else {
//type is NOT client created -> the client has to confirm the SPITtype
} else {
// type is NOT client created -> the client has to confirm the SPITtype
m_Confirmed = p_ReportSPITType->getConfirmed();
}
if (m_DefaultDelay != p_ReportSPITType->getDelay()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_DefaultDelay = p_ReportSPITType->getDelay();
boolChanged = true;
}
if (m_DefaultDuration != p_ReportSPITType->getDuration()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_DefaultDuration = p_ReportSPITType->getDuration();
boolChanged = true;
}
if (m_Fixed != p_ReportSPITType->getFixed()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Fixed = p_ReportSPITType->getFixed();
boolChanged = true;
}
if (m_GroupName != p_ReportSPITType->getGroupName()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_GroupName = p_ReportSPITType->getGroupName();
boolChanged = true;
}
if (m_ID != p_ReportSPITType->getID()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ID = p_ReportSPITType->getID();
boolChanged = true;
}
if (m_Name != p_ReportSPITType->getName()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_Name = p_ReportSPITType->getName();
boolChanged = true;
}
if (m_ServerProjectIndepended != p_ReportSPITType->getServerProjectIndepended()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ServerProjectIndepended = p_ReportSPITType->getServerProjectIndepended();
boolChanged = true;
}
if (m_ServerRemote != p_ReportSPITType->getServerRemote()) {
if (boolChangeAllowed == false) throw new exception();
if (boolChangeAllowed == false)
throw new exception();
m_ServerRemote = p_ReportSPITType->getServerRemote();
boolChanged = true;
}
return boolChanged;
}
}
void SPITType::fillMessageOP(SPIT_Message::ReportSPITType* ptrSMReportSPITType) {
void SPITType::fillMessageOP(SPIT_Message::ReportSPITType *ptrSMReportSPITType) {
ptrSMReportSPITType->setConfirmed(m_Confirmed);
ptrSMReportSPITType->setDelay(m_DefaultDelay);
ptrSMReportSPITType->setDuration(m_DefaultDuration);
@@ -444,7 +452,7 @@ void SPITType::setCreatedByClient(bool p_CreatedByClient) {
ptrSMReportSPITType->setName(m_Name);
ptrSMReportSPITType->setServerProjectIndepended(m_ServerProjectIndepended);
ptrSMReportSPITType->setServerRemote(m_ServerRemote);
}
void SPITType::fillMessageOP(SPIT_Message::RemoveSPITType* ptrSMRemoveSPITType) {
}
void SPITType::fillMessageOP(SPIT_Message::RemoveSPITType *ptrSMRemoveSPITType) {
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";
} 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:
// - MQTT Integration
// - OTA
@@ -36,8 +63,8 @@ struct {
#include "watchMain.hpp"
string MyApp::s_ClientName = "CatasWatchDev";
string MyApp::s_ProjectName = "CatastrphicProj";
string ClientName = "CatasWatchDev";
string ProjectName = "CatastrphicProj";
extern "C" { // This switch allows the ROS C-implementation to find this main
void app_main(void);
@@ -59,8 +86,18 @@ enum class MoveType {
Shuffle,
Demo
};
enum class ResponseType {
StepAt,
StartMoving,
};
struct MoveCommand {
MoveType type;
// 1..6
uint8_t pos;
};
struct Arrived {
ResponseType type;
// 1..6
uint8_t pos;
};
struct PictoIllumCommand {
@@ -68,6 +105,7 @@ struct PictoIllumCommand {
};
static fos::Queue<MoveCommand> commandQueue(8);
static fos::Queue<Arrived> responseQueue(8);
static fos::Queue<PictoIllumCommand> pictoIllumQue(2);
DeviceState activeState;
@@ -346,6 +384,7 @@ static void dmxSocketTask(int addrFamily) {
}
fos::Semaphore etherActive;
fos::Semaphore spitProjectFinish;
/** Event handler for IP_EVENT_ETH_GOT_IP */
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",
delta, activeState.profile, activeState.accel, activeState.speed);
pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0));
responseQueue.enqueue(std::make_unique<Arrived>(ResponseType::StartMoving, 0));
stepper.moveBy(delta * std::numbers::pi / 3,
activeState.profile, activeState.accel, activeState.speed);
pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(newPos));
responseQueue.enqueue(std::make_unique<Arrived>(ResponseType::StepAt, newPos));
activeState.pictogram = newPos;
}
} 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() {
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
ptrMyApp->init();
SPIT_Client spitClient(ClientName, ProjectName,
{
.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) {
fos::Task::delayMs(10000);
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> dmxNode(dmxSocketTask, ipVersion, "dmxNode", 4096);
// static Task otaUpdate(SystemFunctions::OtaTaskEntry, "otaTask", 8192);
static fos::Task spit(SpitClientApp,"SpitClient");
static fos::Task spit(SpitClientApp, "SpitClient");
auto &store = NvsApi::getInstance();
auto logger = store.getValue(ConfigKeys.syslogDest);
main/watchMain.hpp
+9 -1
View File
@@ -36,7 +36,6 @@
#include "Processor.hpp"
#include "nvsFunctions.hpp"
#include "mqttClient.hpp"
#include "MyApp.h"
// #include "esp_chip_info.h"
// #include "esp_flash.h"
@@ -52,3 +51,12 @@
// #include <inttypes.h>
// #include <sys/param.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>