diff --git a/components/spit/include/SAD_DetectedServer.hpp b/components/spit/include/SAD_DetectedServer.hpp
deleted file mode 100644
index 426e2f1..0000000
--- a/components/spit/include/SAD_DetectedServer.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#pragma once
-
-#include <list>
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-using namespace std;
-
-class SAD_DetectedServer;
-class I_SAD_Client {
-  public:
-    virtual void eventServerDetected(SAD_DetectedServer &server) = 0;
-    virtual void eventServerChanged(SAD_DetectedServer &server) = 0;
-    virtual void eventServerLost(SAD_DetectedServer &server) = 0;
-};
-
-class SAD_DetectedServer {
-  public:
-    SAD_DetectedServer(string p_Name, string p_ID, string p_ComputerName,
-                       string p_IP, string p_Port, string p_ClientIP,
-                       string p_Additions, string projName)
-        : m_Name(p_Name),
-          m_ID(p_ID),
-          m_ComputerName(p_ComputerName),
-          m_IP(p_IP),
-          m_Port(p_Port),
-          m_ClientIP(p_ClientIP),
-          m_Additions(p_Additions),
-          m_ServerProjectName(projName) {
-    }
-
-  private:
-    string m_Name{};
-    string m_ID{};
-    string m_ComputerName{};
-    string m_IP{};
-    string m_Port{};
-    string m_ClientIP{};
-    string m_Additions{};
-    string m_ServerProjectName{};
-    bool m_New{true};
-    bool m_Changed{};
-    bool m_FoundAgain{};
-
-  public:
-    string getID() const { return m_ID; }
-    string getName() const { return m_Name; }
-    string getComputerName() const { return m_ComputerName; }
-    string getIP() const { return m_IP; }
-    string getPort() const { return m_Port; }
-    string getClientIP() const { return m_ClientIP; }
-    string getAdditions() const { return m_Additions; }
-    string getProjectName() const { return m_ServerProjectName; }
-    bool getNew() const { return m_New; }
-    bool getChanged() const { return m_Changed; }
-    bool getFoundAgain() const { return m_FoundAgain; }
-
-    void setChanged() { m_Changed = true; }
-    void setKnown() { m_New = false; }
-    void setFoundAgain() { m_FoundAgain = true; }
-    void updateProjectName(string newProjectName) {
-        m_ServerProjectName = newProjectName;
-        if (m_ServerProjectName != newProjectName) {
-            m_Changed = true;
-        }
-    }
-
-    // SAD_Client m_ThreadSend will send to Multicast addresses
-    void resetFlags() {
-        m_Changed = false;
-        m_FoundAgain = false;
-        m_New = false;
-    }
-
-  private:
-    static unordered_map<string, unique_ptr<SAD_DetectedServer>> sKnownServers;
-
-  public:
-    static constexpr int PARAMINDEX_PRECODE = 0;
-    static constexpr int PARAMINDEX_SPITTASKID = 1;
-    static constexpr int PARAMINDEX_NAME = 2;
-    static constexpr int PARAMINDEX_ID = 3;
-    static constexpr int PARAMINDEX_COMPUTERNAME = 4;
-    static constexpr int PARAMINDEX_PORT = 5;
-    static constexpr int PARAMINDEX_CLIENTIP = 6;
-    static constexpr int PARAMINDEX_ADDITIONS = 7;
-    static constexpr int PARAMINDEX_SERVERPROJECTNAME = 8;
-    static constexpr int PARAMINDEX_IP = 9;
-
-    /**
-     * Used by SAD_Client to add a found SPITServer - don't use this manually
-     * @param id the id of the server, every instance of a SPITServer has an own id
-     * @param p_ServerParams the server's parameter
-     */
-    static void addDetectedServer(unique_ptr<SAD_DetectedServer> detected) {
-        if (auto i = sKnownServers.find(detected->getID()); i != sKnownServers.end()) {
-            auto &known = *(i->second.get());
-            known.setFoundAgain();
-            if (detected->getProjectName() != known.getProjectName()) {
-                known.updateProjectName(detected->getProjectName());
-            }
-            return;
-        }
-        sKnownServers[detected->getID()] = move(detected);
-    }
-    static void removeDetectedServer(SAD_DetectedServer &server) {
-        auto i = sKnownServers.find(server.getID());
-        if (i != sKnownServers.end()) {
-            sKnownServers.erase(i);
-        }
-    }
-    static void clearDetectedServers() {
-        sKnownServers.clear();
-    }
-
-    static void resetServerFlags() {
-        for (auto &srv : sKnownServers) {
-            srv.second->resetFlags();
-        }
-    }
-    /**
-     * Used by SAD_Client internally -don't use this manually
-     * @param p_SADClientInterface
-     */
-    static void evaluateDetectedServers(I_SAD_Client &sadClient) {
-        for (auto &srv : sKnownServers) {
-            SAD_DetectedServer &known = *srv.second;
-            if (known.getNew()) {
-                known.setKnown();
-                sadClient.eventServerDetected(known);
-            } else if (known.getChanged()) {
-                sadClient.eventServerChanged(known);
-            } else if (known.getFoundAgain() == false) {
-                sadClient.eventServerLost(known);
-                removeDetectedServer(known);
-            }
-        }
-    }
-
-    /**
-     * Returns a reference of the DetectedServer with the id p_ServerID.<br>
-     * If no DetectedServer is found an eyception is thrown.
-     * @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(const string &id) {
-        return *sKnownServers.at(id);
-    }
-};
diff --git a/components/spit/include/SPITObject.h b/components/spit/include/SPITObject.h
deleted file mode 100644
index dc5904b..0000000
--- a/components/spit/include/SPITObject.h
+++ /dev/null
@@ -1,147 +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:   SPITObject.h
- * Author: Hagi
- *
- * Created on 9. April 2019, 12:11
- */
-
-#ifndef SPITOBJECT_H
-#define SPITOBJECT_H
-
-#include "SPITType.h"
-#include "spit_message.hpp"
-#include "spit_repo.hpp"
-
-using namespace std;
-using namespace spit;
-
-class SPITObjectListener;
-
-class SPITObject {
-  public:
-    static void clearUnconfirmedSPITObjects(SpitRepo<SPITObject> &repo);
-    static void setConfirmedFalse(SpitRepo<SPITObject> &repo);
-    static void eventProjectClosed(SpitRepo<SPITObject> &repo, SpitRepo<SPITObject> &remoteRepo);
-
-    SPITObject(string p_ID);
-
-  private:
-    string m_ID;
-    string m_Name{};
-    string m_SPITTypeID{};
-    string m_ServerParams{};
-    string m_Remark{};
-    bool m_Confirmed{};
-    bool m_Fixed{};
-    bool m_CreatedByClient{};
-    bool m_ServerRemote{};
-    bool m_ActionAssigned{};
-    bool m_ActionAssignedType{}; // Virtual construct
-    long long m_FrameStart{};
-    long long m_FrameLength{};
-    long long m_FrameFadeInLength{};
-    long long m_FrameFadeOutLength{};
-    char m_ValueUse{0x01};
-    int m_ValueFactor{1000000}; // Values are given in ppm -> 1000000 = 1/1;
-    int m_Track{};
-    long long m_Delay{};
-    long long m_Duration{};
-
-    bool m_PlayPrePosition;
-    long long m_PlayTimeInsideFrames;
-    int m_PlayValue;
-    char m_PlayValueFlag;
-
-  public:
-    string getID() const { return m_ID; }
-    string getName() const { return m_Name; }
-    string getRemark() const { return m_Remark; }
-    string getSPITTypeID() const { return m_SPITTypeID; }
-    string getServerParams() const { return m_ServerParams; }
-
-    /**
-     * Returns if the SPITType triggers an action on the Server or on the client.
-     * @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
-     * true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
-     */
-    bool getServerRemote() const { return m_ServerRemote; }
-
-    /**
-     * This is used by the server and client to tell if the other side has registered the changes.
-     * @return true = other side has registered the changes.
-     */
-    bool getConfirmed() const { return m_Confirmed; }
-    bool getFixed() const { return m_Fixed; }
-    bool getCreatedByClient() const { return m_CreatedByClient; }
-    /**
-     * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
-     * This is used when an action is associated with a SPITType.
-     * Then this action is done for every SPITObject with the SPITType.
-     * @return true = an action is assigned for the SPITType.
-     */
-    bool getActionAssignedType() const { return m_ActionAssignedType; }
-    /** Returns if this SPITObject has an associated action or not.
-     * @return true = the user has asscociated an action with this SPITObject or
-     *  the user has asscociated an action with the SPITType of this SPITObject
-     */
-    bool getActionAssigned() const { return m_ActionAssigned || m_ActionAssignedType; }
-
-    long long getFrameStart() const { return m_FrameStart; }
-    // contains the length of the SPITObject
-    long long getFrameLength() const { return m_FrameLength; }
-    long long getFrameFadeInLength() const { return m_FrameFadeInLength; }
-    long long getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
-    char getValueUse() const { return m_ValueUse; }
-    int getValueFactor() const { return m_ValueFactor; }
-    int getTrack() const { return m_Track; }
-
-    long long getDelay() const { return m_Delay; }
-    long long getDuration() const { return m_Duration; }
-
-    bool getProjectIndepended(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo) const {
-        SPITType *ptrSPITType;
-        if (m_ServerRemote == false) {
-            ptrSPITType = repo.getEntry(m_SPITTypeID);
-            if (ptrSPITType == nullptr)
-                return true;
-            return ptrSPITType->getProjectIndepended();
-        } else {
-            ptrSPITType = remoteRepo.getEntry(m_SPITTypeID);
-            if (ptrSPITType == nullptr)
-                return true;
-            return ptrSPITType->getProjectIndepended();
-        }
-    };
-
-    bool setConfirmed(bool p_Confirmed);
-    void setCreatedByClient(bool p_CreatedByClient) { m_CreatedByClient = p_CreatedByClient; }
-    bool setName(string p_Name);
-    bool setRemark(string p_Remark);
-    bool setServerParams(string p_ServerParams);
-    bool setSPITTypeID(string p_GroupName);
-    bool setServerRemote(bool p_BelongstoServer);
-    bool setActionAssignedType(bool p_ActionAssigned);
-    bool setActionAssigned(bool p_ActionAssigned);
-    bool setFixed(bool p_Fixed);
-    bool setFrameStart(long long p_FrameStart);
-    bool setFrameLength(long long p_FrameLength);
-    bool setFrameFadeInLength(long long p_FrameFadeInLength);
-    bool setFrameFadeOutLength(long long p_FrameFadeOutLength);
-    bool setValueUse(char p_ValueUse);
-    bool setValueFactor(int p_ValueFactor);
-    bool setTrack(int p_Track);
-    bool setDelay(long long p_Delay);
-    bool setDuration(long long p_Duration);
-
-    bool setMessageOP(Message::ReportObject *p_ReportSPITObject);
-    void fillMessageOP(Message::ReportObject &p_ReportSPITObject);
-    void fillMessageOP(Message::RemoveObject &p_RemoveSPITObject);
-};
-
-#endif /* SPITOBJECT_H */
diff --git a/components/spit/include/SPITPlayer.h b/components/spit/include/SPITPlayer.h
deleted file mode 100644
index 34e41ac..0000000
--- a/components/spit/include/SPITPlayer.h
+++ /dev/null
@@ -1,92 +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:   SPITPLayer.h
- * Author: Hagi
- *
- * Created on 30. April 2019, 11:44
- */
-
-#ifndef SPITPLAYER_H
-#define SPITPLAYER_H
-
-#include "SPITObject.h"
-#include <unordered_map>
-
-class SPITPlayer {
-
-    //----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
-  public:
-    class PlaySPITType {
-      public:
-        PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
-        PlaySPITType(const PlaySPITType &orig);
-
-        string getSPITTypeID() const { return m_SPITTypeID; }
-
-        void startPlaySequence();
-        bool getIsNew() const { return m_IsNew; }
-        void setIsNew(bool p_IsNew) { m_IsNew = p_IsNew; }
-        bool getIsPlayed() const { return m_IsPlayed; }
-        void setIsPlayed(bool p_IsFound) { m_IsPlayed = p_IsFound; }
-        string getPlayerID() const { return m_PlayerID; }
-        string getPlayerName() const { return m_PlayerName; }
-        bool getPlayerIsRunning() const { return m_PlayerRuns; }
-        void setPlayerIsRunning(bool p_PlayerRuns) { m_PlayerRuns = p_PlayerRuns; }
-        void setValue(double p_Value) { m_Value = p_Value; }
-        void addValue(double p_Value, double p_ValueFactor) { m_Value += (p_Value * p_ValueFactor); }
-        double getValue() const { return m_Value; }
-
-      private:
-        string m_PlayerID;
-        string m_PlayerName;
-        bool m_PlayerRuns;
-        string m_SPITTypeID;
-        bool m_IsPlayed;
-        bool m_IsNew;
-        double m_Value;
-    };
-
-    //----- SPITPlayer ------
-  public:
-    // list the SPITPlayers
-    static unordered_map<string, unique_ptr<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() { s_SPITPlayers.clear(); }
-
-    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
-
-    string getID() {
-        return m_ID;
-    }
-
-    unordered_map<string, unique_ptr<PlaySPITType>> &getPlaySPITTypes() { return m_PlaySPITTypes; }
-    void setIsRunning(bool p_IsRunning) { m_IsRunning = p_IsRunning; }
-    void setName(string p_Name) { m_Name = p_Name; }
-    void setType(char p_Type) { m_Type = p_Type; }
-    void setTime(long long p_Frames) { m_TimeFrames = p_Frames; }
-    bool getIsRunning() const { return m_IsRunning; }
-    string getName() const { return m_Name; }
-    char getType() const { return m_Type; }
-    long long getTime() const { return m_TimeFrames; }
-
-  private:
-    string m_ID;
-    string m_Name;
-    char m_Type;
-    unordered_map<string, unique_ptr<PlaySPITType>> m_PlaySPITTypes;
-
-    bool m_IsRunning;
-    long long m_TimeFrames;
-};
-
-#endif /* SPITPLAYER_H */
diff --git a/components/spit/include/SPITSocket.h b/components/spit/include/SPITSocket.h
deleted file mode 100644
index 7d0baff..0000000
--- a/components/spit/include/SPITSocket.h
+++ /dev/null
@@ -1,149 +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.
- */
-
-/*
- * SPITSocket is the base class for WindowsSocket, UnixSocket,.
- * Used by SPIT_Client and SAD_Client.
- * File:   SPITSocket.h
- * Author: Hagi
- *
- * Created on 12. April 2019, 15:40
- */
-
-#ifndef SPITSOCKET_H
-#define SPITSOCKET_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;
-
-/** Returns an guid */
-string createGUID();
-/** Returns the name of the client's host computer*/
-string getClientHostName();
-
-class SPITSocket {
-  public:
-    static const int FAMILY_IP4 = AF_INET;
-
-    /**
-     * IPAddress class is used to fetch all available IP addresses of the computer
-     * This is for internal usage
-     */
-    struct IPAddress {
-      public:
-        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;
-
-        /**
-         * Calculates the broadcast address from a ip4 address
-         * @param p_IPAddress the ip4 address
-         * @return returns the broadcast address
-         */
-        string getBroadcastIP4() const {
-            struct in_addr broadcast;
-            unsigned long ulIPAddress;
-            unsigned long ulSubnetMask;
-
-            ulIPAddress = inet_addr(m_IPAddress.data());
-            ulSubnetMask = inet_addr(m_SubnetMask.data());
-            broadcast.s_addr = ulIPAddress | ~ulSubnetMask;
-
-            return inet_ntoa(broadcast);
-        }
-    };
-    const IPAddress mOwnIp;
-    static IPAddress getAdaptersInfo();
-    bool createSocket_UDP();
-    static const int INVALID_SOCKET = -1;
-
-  private:
-    int m_UDPSocketIP4;
-
-  public:
-    //-------- class --------------
-    SPITSocket(IPAddress ip) : mOwnIp(ip) {
-        m_UDPSocketIP4 = INVALID_SOCKET;
-        createSocket_UDP();
-    }
-    virtual ~SPITSocket() {
-        ESP_LOGD("UDP", "Shutting down ...");
-
-        if (m_UDPSocketIP4 != INVALID_SOCKET) {
-            shutdown(m_UDPSocketIP4, 2);
-            close(m_UDPSocketIP4);
-            m_UDPSocketIP4 = INVALID_SOCKET;
-        }
-        fos::Task::delayMs(100);
-        m_IsBound = false;
-    }
-
-  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
-    bool m_IsBound{};
-
-  public:
-    // Sets the ip address and port for server and client.
-    void setConnectionParams(const string &serverIp, const string &serverPort, const string &clientIp, const string &clientPort) {
-        m_ServerIP = serverIp;
-        m_ServerPort = serverPort;
-        m_ClientIP = clientIp;
-        m_ClientPort = clientPort;
-    }
-
-    /**
-     * Send a message to the server as set by setConnectionParams
-     * @param message  byte buffer containing the message
-     * @param length length of the message
-     * @return
-     */
-    int sendMessage(const char *message, int length) {
-        if (m_ServerPort.length() <= 0) {
-            return -1;
-        }
-
-        if (m_IsBound == false) {
-            return -1;
-        }
-        int intResult = sendMessageTo(m_ServerIP, m_ServerPort, message, length);
-        return intResult;
-    }
-
-    int receiveMessage(char *p_Buffer, int p_BufferLength, string *serverIp) const;
-    int setBroadcast(bool p_Broadcast) const;
-    int bindSocket(string clientIp, string clientPort);
-
-    int sendMessageTo(const string &ip, const string &port, const char *message, int msgLength);
-
-    string getServerIP() const { return m_ServerIP; }
-    string getServerPort() const { return m_ServerPort; }
-    string getClientIP() const { return m_ClientIP; }
-    string getClientPort() const { return m_ClientPort; }
-    string getBoundClientPort() const { return m_BoundClientPort; }
-    void setBoundClientPort(const string &p_Port) { m_BoundClientPort = p_Port; }
-    void setIsBound(bool p_IsBound) { m_IsBound = p_IsBound; }
-    bool getIsBound() const { return m_IsBound; }
-
-  private:
-};
-
-#endif /* SPITSOCKET_H */
diff --git a/components/spit/include/SPITType.h b/components/spit/include/SPITType.h
deleted file mode 100644
index e0b182b..0000000
--- a/components/spit/include/SPITType.h
+++ /dev/null
@@ -1,105 +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:   SPITType.h
- * Author: Hagi
- *
- * Created on 8. April 2019, 08:40
- */
-
-#ifndef SPITTYPE_H
-#define SPITTYPE_H
-
-#include "SPITSocket.h"
-#include "spit_message.hpp"
-#include "spit_repo.hpp"
-
-using namespace std;
-using namespace spit;
-
-class SPITTypeListener;
-
-class SPITType {
-  public:
-    static void setConfirmedFalse(SpitRepo<SPITType> &repo);
-    static void eventProjectClosed(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo);
-
-    SPITType(string p_ID);
-    SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended, long long p_DefaultDelay, long long p_DefaultDuration);
-
-  private:
-    bool m_Confirmed{};
-    string m_ID;
-    bool m_Fixed{};
-    bool m_ServerRemote{};
-    bool m_ServerProjectIndepended{};
-    string m_GroupName{};
-    string m_Name{};
-    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_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
-
-  public:
-    string getID() const { return m_ID; }
-    string getGroupName() const { return m_GroupName; }
-    string getName() const { return m_Name; }
-    /**
-     * Returns if the SPITType triggers an action on the Server or on the client.
-     * @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
-     * true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
-     */
-    bool getServerRemote() const { return m_ServerRemote; }
-    bool getProjectIndepended() const { return m_ServerProjectIndepended; }
-    /**
-     * This is used by the server and client to tell if the other side has registered the changes.
-     * @return true = other side has registered the changes.
-     */
-    bool getConfirmed() const { return m_Confirmed; }
-    bool getFixed() const { return m_Fixed; }
-    long long getDefaultDelay() const { return m_DefaultDelay; }
-    long long getDefaultDuration() const { return m_DefaultDuration; }
-    bool getCreatedByClient() const { return m_CreatedByClient; }
-
-    /**
-     * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
-     * This can used to setActionAssigned to all SPITObjects with this SPITType.
-     * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
-     * @return true = the user has associated an action with this SPITType.
-     */
-    bool getActionAssigned() const {
-        return m_ActionAssigned;
-    }
-
-    bool setGroupName(const string &p_GroupName);
-    bool setName(const string &p_Name);
-    bool setServerRemote(bool p_BelongstoServer);
-    bool setProjectIndepended(bool p_ProjectIndepeneded);
-    bool setConfirmed(bool p_Confirmed);
-    bool setFixed(bool p_Fixed);
-    bool setDefaultDelay(long long p_Delay);
-    bool setDefaultDuration(long long p_Duration);
-    void setCreatedByClient(bool p_CreatedByClient);
-
-    /**
-     * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
-     * This can used to setActionAssigned to all SPITObjects with this SPITType.
-     * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
-     * @return true = the m_ActionAssigned has changed.
-     */
-    bool setActionAssigned(bool p_ActionAssigned);
-
-    bool setMessageOP(Message::ReportType &reportSpitType);
-    void fillMessageOP(Message::ReportType &smReportSpitType) const;
-    void fillMessageOP(Message::RemoveType &smRemoveSpitType) const;
-};
-
-#endif /* SPITTYPE_H */
\ No newline at end of file
diff --git a/components/spit/include/sad_DetectedServer.hpp b/components/spit/include/sad_DetectedServer.hpp
new file mode 100644
index 0000000..e07f5a2
--- /dev/null
+++ b/components/spit/include/sad_DetectedServer.hpp
@@ -0,0 +1,155 @@
+#pragma once
+
+#include <list>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+using namespace std;
+
+namespace spit {
+
+class SadDetectedServer;
+class ISadClient {
+  public:
+    virtual void eventServerDetected(SadDetectedServer &server) = 0;
+    virtual void eventServerChanged(SadDetectedServer &server) = 0;
+    virtual void eventServerLost(SadDetectedServer &server) = 0;
+};
+
+class SadDetectedServer {
+  public:
+    SadDetectedServer(string name, string iD, string computerName,
+                       string iP, string port, string clientIP,
+                       string additions, string projName)
+        : mName(name),
+          mID(iD),
+          mComputerName(computerName),
+          mIP(iP),
+          mPort(port),
+          mClientIP(clientIP),
+          mAdditions(additions),
+          mServerProjectName(projName) {
+    }
+
+  private:
+    string mName{};
+    string mID{};
+    string mComputerName{};
+    string mIP{};
+    string mPort{};
+    string mClientIP{};
+    string mAdditions{};
+    string mServerProjectName{};
+    bool mNew{true};
+    bool mChanged{};
+    bool mFoundAgain{};
+
+  public:
+    string getID() const { return mID; }
+    string getName() const { return mName; }
+    string getComputerName() const { return mComputerName; }
+    string getIP() const { return mIP; }
+    string getPort() const { return mPort; }
+    string getClientIP() const { return mClientIP; }
+    string getAdditions() const { return mAdditions; }
+    string getProjectName() const { return mServerProjectName; }
+    bool getNew() const { return mNew; }
+    bool getChanged() const { return mChanged; }
+    bool getFoundAgain() const { return mFoundAgain; }
+
+    void setChanged() { mChanged = true; }
+    void setKnown() { mNew = false; }
+    void setFoundAgain() { mFoundAgain = true; }
+    void updateProjectName(string newProjectName) {
+        mServerProjectName = newProjectName;
+        if (mServerProjectName != newProjectName) {
+            mChanged = true;
+        }
+    }
+
+    // SAD_Client mThreadSend will send to Multicast addresses
+    void resetFlags() {
+        mChanged = false;
+        mFoundAgain = false;
+        mNew = false;
+    }
+
+  private:
+    static unordered_map<string, unique_ptr<SadDetectedServer>> sKnownServers;
+
+  public:
+    enum ParamIndex {
+        PARAM_PRECODE = 0,
+        PARAM_SPITTASKID = 1,
+        PARAM_NAME = 2,
+        PARAM_ID = 3,
+        PARAM_COMPUTERNAME = 4,
+        PARAM_PORT = 5,
+        PARAM_CLIENTIP = 6,
+        PARAM_ADDITIONS = 7,
+        PARAM_SERVERPROJECTNAME = 8,
+        PARAM_IP = 9,
+    };
+    
+    /**
+     * Used by SAD_Client to add a found SPITServer - don't use this manually
+     * @param id the id of the server, every instance of a SPITServer has an own id
+     * @param p_ServerParams the server's parameter
+     */
+    static void addDetectedServer(unique_ptr<SadDetectedServer> detected) {
+        if (auto i = sKnownServers.find(detected->getID()); i != sKnownServers.end()) {
+            auto &known = *(i->second.get());
+            known.setFoundAgain();
+            if (detected->getProjectName() != known.getProjectName()) {
+                known.updateProjectName(detected->getProjectName());
+            }
+            return;
+        }
+        sKnownServers[detected->getID()] = move(detected);
+    }
+    static void removeDetectedServer(SadDetectedServer &server) {
+        auto i = sKnownServers.find(server.getID());
+        if (i != sKnownServers.end()) {
+            sKnownServers.erase(i);
+        }
+    }
+    static void clearDetectedServers() {
+        sKnownServers.clear();
+    }
+
+    static void resetServerFlags() {
+        for (auto &srv : sKnownServers) {
+            srv.second->resetFlags();
+        }
+    }
+    /**
+     * Used by SAD_Client internally -don't use this manually
+     */
+    static void evaluateDetectedServers(ISadClient &sadClient) {
+        for (auto &srv : sKnownServers) {
+            SadDetectedServer &known = *srv.second;
+            if (known.getNew()) {
+                known.setKnown();
+                sadClient.eventServerDetected(known);
+            } else if (known.getChanged()) {
+                sadClient.eventServerChanged(known);
+            } else if (known.getFoundAgain() == false) {
+                sadClient.eventServerLost(known);
+                removeDetectedServer(known);
+            }
+        }
+    }
+
+    /**
+     * Returns a reference of the DetectedServer with the id p_ServerID.<br>
+     * If no DetectedServer is found an eyception is thrown.
+     * @param id the id of the SPITServer
+     * @return the reference of the SadDetectedServer instance with getID() == p_ServerID
+     */
+    static const SadDetectedServer &getRefDetectedServer(const string &id) {
+        return *sKnownServers.at(id);
+    }
+};
+
+}
\ No newline at end of file
diff --git a/components/spit/include/SPIT_Client.h b/components/spit/include/spit_client.hpp
similarity index 59%
rename from components/spit/include/SPIT_Client.h
rename to components/spit/include/spit_client.hpp
index 25ee0f6..5fe9903 100644
--- a/components/spit/include/SPIT_Client.h
+++ b/components/spit/include/spit_client.hpp
@@ -1,34 +1,21 @@
-/*
- * 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.
- */
+#pragma once
 
-/*
- * File:   SPIT_Client.h
- * Author: Hagi
- *
- * Created on 7. April 2019, 08:50
- */
-
-#ifndef SPIT_CLIENT_H
-#define SPIT_CLIENT_H
-
-#include "SAD_DetectedServer.hpp"
-#include "SPITObject.h"
-#include "SPITPlayer.h"
-#include "SPITSocket.h"
-#include "SPITType.h"
+#include "sad_DetectedServer.hpp"
+#include "spit_object.hpp"
+#include "spit_player.hpp"
+#include "spit_socket.hpp"
+#include "spit_type.hpp"
 #include "spit_message.hpp"
 #include "spit_repo.hpp"
 #include <memory>
 #include <vector>
+#include <functional>
 
 using namespace std;
-using namespace spit;
 
-class SPIT_Client : I_SAD_Client {
+namespace spit {
 
+class SClient : ISadClient {
   public:
     /** Maximal length of a SPITMessage*/
     static const int MAXSPITMESSAGEBYTECOUNT = 512;
@@ -58,17 +45,16 @@ class SPIT_Client : I_SAD_Client {
     };
 
     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, Connection p_ConnectionStatus, Connection p_OldConnectionStatus){};
-        void (*onProjectUpdate)(ProjUpdate state, string projectId){};
-        void (*onSpitType)(ObjectEvent event, bool isRemote, const SPITType &p_SPITType){};
-        void (*onSpitObject)(ObjectEvent event, bool isRemote, 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)(bool knownType, bool createdByClient){};
-        bool (*onCheckSpitObjectVeto)(bool knownType){};
+        function<void(ServerEvent event, const SadDetectedServer &detectedServer)> onServerEvent;
+        function<void(string serverID, string serverComputerName, string serverName, int serverStepTime, Connection connectionStatus, Connection oldConnectionStatus)> onConnectionStatus;
+        function<void(ProjUpdate state, string projectId)> onProjectUpdate;
+        function<void(ObjectEvent event, bool isRemote, const SType &spitType)> onSpitType;
+        function<void(ObjectEvent event, bool isRemote, const SType &spitType, const SObject &spitObject)> onSpitObject;
+        function<void(string playerID, string playerName, char playerType, bool playerIsRunning, uint64_t timeFrames)> onPlay;
+        function<void(string playerID, string spitTypeID, bool playerIsRunning, bool started, bool ended, double value)> onPlaySpitType;
+        function<void(const SType &spitType, const SObject &spitObject, uint64_t p_FrameInsideObject, int value)> onPlayRemoteObjectStatus;
+        function<bool(bool knownType, bool createdByClient)> onCheckSpitTypeVeto;
+        function<bool(bool knownType)> onCheckSpitObjectVeto;
     };
 
     //------ PlayerType ------
@@ -91,65 +77,65 @@ class SPIT_Client : I_SAD_Client {
     static constexpr char VALUEFLAG_DECREASE = 0x02;
     static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
 
-    //----- SPIT_Client -----
+    //----- SClient -----
   public:
-    SPIT_Client(string name, string projName, Callbacks calls);
-    virtual ~SPIT_Client();
+    SClient(string name, string projName, ISocket &socket, Callbacks calls);
+    virtual ~SClient();
 
   private:
     Callbacks mCallbacks;
 
-    fos::TaskT<SPIT_Client &> *m_ThreadReceive{};
-    bool m_StopReceiveSPITMessages{};
+    fos::TaskT<SClient &> *mThreadReceive{};
+    bool mStopReceiveMessages{};
 
-    Connection m_ConnectionStatus{Connection::None};
-    bool m_DisconnectedByServer{}; // flag true = when server disconnects
-    string m_ID;
-    string m_Name;
-    string m_ProjName;
-    string m_ComputerName;
+    Connection mConnectionStatus{Connection::None};
+    bool mDisconnectedByServer{}; // flag true = when server disconnects
+    string mID;
+    string mName;
+    string mProjName;
+    string mComputerName;
 
-    string m_ClientProjectName;
+    string mClientProjectName;
 
-    uint8_t m_MessageNumber_Send{1};
-    int m_MessageNumber_Received{-1}; // set to -1 because the first received message will set the number (1..255)
-    vector<unique_ptr<Message>> m_OvertakingSPIT_Messages;
+    uint8_t mMessageNumberSend{1};
+    int mMessageNumberReceived{-1}; // set to -1 because the first received message will set the number (1..255)
+    vector<unique_ptr<Message>> mOvertakingMessages;
 
     // Server's info filled by parseConnectAnswer
-    string m_ServerID{};
-    string m_ServerName{};
-    string m_ServerComputerName{};
-    int m_ServerStepTime{-1};
+    string mServerID{};
+    string mServerName{};
+    string mServerComputerName{};
+    int mServerStepTime{-1};
 
     //--- Server Project ---
-    string m_ServerProjectID;
-    string m_ServerProjectName;
-    int m_ServerFramesPerSecond;
+    string mServerProjectID;
+    string mServerProjectName;
+    int mServerFramesPerSecond;
 
   public:
     /** The ID of the client.<br>Every client instance should set an unique id*/
-    string getID() { return m_ID; }
+    string getID() { return mID; }
     /** The name of the client, should be set by the user app*/
-    string getName() { return m_Name; }
+    string getName() { return mName; }
     //----- Computer Params -----
     /** The name of the client's host computer*/
-    string getComputerName() { return m_ComputerName; }
-    void setClientProjectName(string p_ClientProjectName) { m_ClientProjectName = p_ClientProjectName; }
-    string getClientProjectName() { return m_ClientProjectName; }
+    string getComputerName() { return mComputerName; }
+    void setClientProjectName(string clientProjectName) { mClientProjectName = clientProjectName; }
+    string getClientProjectName() { return mClientProjectName; }
 
     // connected Server Infos
     /** The ID of the connected SPITServer*/
-    string getServerID() { return m_ServerID; }
+    string getServerID() { return mServerID; }
     /** The host computername of the connected SPITServer*/
-    string getServerComputerName() { return m_ServerComputerName; }
+    string getServerComputerName() { return mServerComputerName; }
     /** The name of the connected SPITServer*/
-    string getServerName() { return m_ServerName; }
+    string getServerName() { return mServerName; }
 
     /** Expected Refreah Rate of the connectd SPITServer.<br>
      * When the server plays objects, it will do so at discrete time steps.<br>
      * Play events will take place in these time steps..
      */
-    int getServerStepTime() { return m_ServerStepTime; }
+    int getServerStepTime() { return mServerStepTime; }
 
     /** Should be called when the client wants to close his project*/
     void clientProjectClose();
@@ -158,21 +144,16 @@ class SPIT_Client : I_SAD_Client {
      */
     void clientProjectLoaded();
 
-    /**
-     *
-     * @param p_SPITTypeID
-     * @param p_ActionAssigned
-     */
-    void setActionSPITType(string p_SPITTypeID, bool p_ActionAssigned);
-    void setActionSPITObject(string p_SPITObjectID, bool p_ActionAssigned);
+    void setActionSPITType(string spitypeID, bool actionAssigned);
+    void setActionSPITObject(string objectID, bool actionAssigned);
 
     //--------------- SPITMessage ---------------
   private:
     bool startReceiveSPITMessages();
     void stopReceiveSPITMessages();
-    static void receiveSPITMessage(SPIT_Client &rM);
+    static void receiveSPITMessage(SClient &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
+    bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by mServerID
   public:
     int sendSPITMessage(Message::OPPart & spitMessageOPPart);
 
@@ -183,10 +164,10 @@ class SPIT_Client : I_SAD_Client {
     /** 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(SAD_DetectedServer &server);
+    void eventServerDetected(SadDetectedServer &server);
     /** Called every time a prior detected SPITServer is is no longer found.*/
-    void eventServerLost(SAD_DetectedServer &server);
-    void eventServerChanged(SAD_DetectedServer &server);
+    void eventServerLost(SadDetectedServer &server);
+    void eventServerChanged(SadDetectedServer &server);
 
     //--------------- Connection ---------------
   public:
@@ -201,22 +182,22 @@ class SPIT_Client : I_SAD_Client {
      * @return true = the connection try is ok, SPITServer will answer with COnnectAnswer and an eventConnectionStatus will occur.<br>
      * false = something is going wrong. (client could not bind)
      */
-    bool connect(string p_ServerIP, string p_ServerPort, string p_ClientIP, string p_ClientPort, string p_LoginName = "", string p_LoginPassword = "");
+    bool connect(string serverIP, string serverPort, string clientIP, string clientPort, string loginName = "", string loginPassword = "");
     /**
      * Terminates the connection to the SPITServer.
      */
     void disconnect();
 
   private:
-    void disconnectInternal(Connection p_Cause);
+    void disconnectInternal(Connection cause);
     void resetMessageNumberReceived();
-    void parseSPIT_Message(unique_ptr<Message> p_SPITMessage);
-    void checkParseSPIT_Message(unique_ptr<Message> p_SPITMessage);
-    void addOvertakingSPIT_Message(unique_ptr<Message> p_SPIT_Message);
-    void parseConnectAnswer(Message::ConnectAnswer &p_ConnectAnswer);
-    void parseDisconnect(Message::Disconnect &p_Disconnect);
-    void parseWatchdog(Message::Watchdog &p_Watchdog);
-    void parseWatchdogAnswer(Message::WatchdogAnswer &p_WatchdogAnswer);
+    void parseMessage(unique_ptr<Message> message);
+    void checkParseMessage(unique_ptr<Message> message);
+    void addOvertakingMessage(unique_ptr<Message> message);
+    void parseConnectAnswer(Message::ConnectAnswer &message);
+    void parseDisconnect(Message::Disconnect &message);
+    void parseWatchdog(Message::Watchdog &message);
+    void parseWatchdogAnswer(Message::WatchdogAnswer &message);
 
   public:
     /** Used internally*/
@@ -225,8 +206,8 @@ class SPIT_Client : I_SAD_Client {
     void eventWatchdogLost();
     //--------------- SPIT Project ---------------
   private:
-    void parseReportSPITProject(Message::ReportProject &p_ReportSPITProject);
-    void parseCloseSPITProject(Message::CloseProject &p_CloseSPITProject);
+    void parseReportProject(Message::ReportProject &message);
+    void parseCloseProject(Message::CloseProject &message);
 
   public:
     /** Returns the SPITServer's project ID - may be the same as the project's name*/
@@ -237,12 +218,12 @@ class SPIT_Client : I_SAD_Client {
     int getServerFramesPerSecond();
 
   private:
-    void parseRequestProjectTransfer(Message::RequestProjectTransfer &p_RequestProjectTransfer);
-    void parseStartProjectTransfer(Message::StartProjectTransfer &p_StartProjectTransfer);
-    void parseEndProjectTransfer(Message::EndProjectTransfer &p_EndProjectTransfer);
+    void parseRequestProjectTransfer(Message::RequestProjectTransfer &message);
+    void parseStartProjectTransfer(Message::StartProjectTransfer &message);
+    void parseEndProjectTransfer(Message::EndProjectTransfer &message);
 
   public:
-    static void sendProject(SPIT_Client *p_PtrSPIT_Client);
+    static void sendProject(SClient *p_PtrSClient);
 
     // --------------- SPIT Types ---------------
   public:
@@ -257,7 +238,7 @@ class SPIT_Client : I_SAD_Client {
      * @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);
+    SType *createSPITTypeFixed(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration);
 
     /**
      * Creates a SPITType for application actions.<br>
@@ -271,80 +252,80 @@ class SPIT_Client : I_SAD_Client {
      * @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);
+    SType *createSPITType(string iD, string groupName, string name, uint64_t defaultDelay, uint64_t defaultDuration, bool fixed, bool projectIndepended);
 
   private:
     // receive SPITTypes
-    void parseReportSPITType(Message::ReportType &p_ReportSPITType);
-    void parseRemoveSPITType(Message::RemoveType &p_RemoveSPITType);
-    int sendSPITTypeInternal(SPITType &p_SPITType);
+    void parseReportSPITType(Message::ReportType &message);
+    void parseRemoveSPITType(Message::RemoveType &message);
+    int sendSPITTypeInternal(SType &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.
+     * @param spitypeID the id of the SPITType to remove.
      * @return 0 = is sended, -1 = is not sended
      */
-    bool changeSPITType(SPITType *p_SPITType);
+    bool changeSPITType(SType *spitType);
     /**
      * If a client wants to remove a SPITType, he should send it to the server.<br>
      * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br>
-     * @param p_SPITTypeID the id of the SPITType to remove.
+     * @param spitypeID the id of the SPITType to remove.
      * @return 0 = is sended, -1 = is not sended
      */
-    int removeSPITType(string p_SPITTypeID);
+    int removeSPITType(string spitypeID);
 
   public:
     //--------------- SPIT Objects ---------------
   private:
-    void parseReportSPITObject(Message::ReportObject &p_ReportSPITObject);
-    void parseRemoveSPITObject(Message::RemoveObject &p_RemoveSPITObject);
-    int sendSPITObjectInternal(SPITObject *ptrSPITObject);
+    void parseReportSPITObject(Message::ReportObject &message);
+    void parseRemoveSPITObject(Message::RemoveObject &message);
+    int sendSPITObjectInternal(SObject *ptrObject);
 
   public:
     /**
      * When the client changes a SPITObject (normally the client should not do this), then it should send the changes to the SPITServer.<br>
      * The SPITServer may discard the changes and an eventSPITObject occurs.<br>
-     * @param p_SPITObject the pointer to the changed SPITObject.
+     * @param spitObject the pointer to the changed SPITObject.
      * @return 0 = sended, -1 = not sended
      */
-    bool changeSPITObject(SPITObject *p_SPITObject);
+    bool changeSPITObject(SObject *spitObject);
     /**
      * When the client removes a SPITObject (normally the client should not do this), then he should send it to the SPITServer.<br>
      * The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
-     * @param p_SPITObjectID the id of the SPITObject to remove.
+     * @param objectID the id of the SPITObject to remove.
      * @return 0 = sended, -1 = not sended
      */
-    int removeSPITObject(string p_SPITObjectID);
+    int removeSPITObject(string objectID);
 
   public:
     //--------------- Play SPIT Objects ---------------
   private:
-    void parsePlaySPITStart(Message::PlayStart &p_PlaySPITStart);
-    void parsePlaySPITObject(Message::PlayObject &p_PlaySPITObject);
-    void parsePlaySPITEnd(Message::PlayEnd &p_PlaySPITEnd);
-    void parseReportPlayStatus(Message::ReportPlayStatus &p_ReportPlayStatus);
+    void parsePlaySPITStart(Message::PlayStart &message);
+    void parsePlaySPITObject(Message::PlayObject &message);
+    void parsePlaySPITEnd(Message::PlayEnd &message);
+    void parseReportPlayStatus(Message::ReportPlayStatus &message);
 
   public:
     //--------- Remote ----------
-    void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00);
+    void sendRemoteObject(string objectID, int valuePpm = 0, char valueFlag = 0x00);
 
   private:
-    static void processSocketTask(SPIT_Client &instance);
-    fos::TaskT<SPIT_Client &> *sThread{};
+    static void processSocketTask(SClient &instance);
+    fos::TaskT<SClient &> *sThread{};
     bool mAbortSearch{};
     bool sAnswered{};
     static fos::Semaphore sStartSad;
-    SPITSocket *mSPITSocket;
+    ISocket &mSocket;
     void answerWatchdog() {
         sAnswered = true;
     }
 
-    SpitRepo<SPITObject> mSpitObjects;
-    SpitRepo<SPITObject> mRemoteSpitObjects;
-    SpitRepo<SPITType> mSpitTypes;
-    SpitRepo<SPITType> mRemoteSpitTypes;
+    SpitRepo<SObject> mSpitObjects;
+    SpitRepo<SObject> mRemoteSpitObjects;
+    SpitRepo<SType> mSpitTypes;
+    SpitRepo<SType> mRemoteSpitTypes;
 };
 
-#endif /* SPIT_CLIENT_H */
+}
\ No newline at end of file
diff --git a/components/spit/include/spit_message.hpp b/components/spit/include/spit_message.hpp
index 7b1e20d..c35533a 100644
--- a/components/spit/include/spit_message.hpp
+++ b/components/spit/include/spit_message.hpp
@@ -1,15 +1,3 @@
-/*
- * 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:   Message.h
- * Author: Hagi
- *
- * Created on 3. April 2019, 08:51
- */
 #pragma once 
 
 #include <cstdlib>
@@ -37,8 +25,8 @@ class Message {
         int mVersion{SPITVERSION};
         unsigned char mMessageNumber{};
         int mBytesCount{BYTESLENGTH};
-        string mServerID{};
-        string mClientID{};
+        string mServerId{};
+        string mClientId{};
         int mOpFlag{-1};
         int mParseOffset{};
 
@@ -47,8 +35,8 @@ class Message {
         int getSPITVersion() const { return mVersion; }
         unsigned char getMessageNumber() const { return mMessageNumber; }
         int getBytesCount() const { return mBytesCount; }
-        string getServerID() const { return mServerID; }
-        string getClientID() const { return mClientID; }
+        string getServerID() const { return mServerId; }
+        string getClientID() const { return mClientId; }
         int getType() const { return mOpFlag; }
 
         // Receive
@@ -56,9 +44,9 @@ class Message {
 
         // Send
         Header(int p_SPITVersion, int pOpFlag);
-        void setMessageNumber(unsigned char p_MessageNumber) { mMessageNumber = p_MessageNumber; }
-        void setServerID(string p_ID) { mServerID = p_ID; }
-        void setClientID(string p_ID) { mClientID = p_ID; }
+        void setMessageNumber(unsigned char messageNumber) { mMessageNumber = messageNumber; }
+        void setServerID(string iD) { mServerId = iD; }
+        void setClientID(string iD) { mClientId = iD; }
         void setOPFlag(int pOpFlag) { mOpFlag = pOpFlag; }
         bool fillBytes(std::vector<char> &message);
     };
@@ -112,7 +100,7 @@ class Message {
         }
 
         // Receive
-        OPPart(unique_ptr<Header> p_Header, int pOpFlag, int size);
+        OPPart(unique_ptr<Header> header, int pOpFlag, int size);
         void setHeader(int opFlag);
         virtual bool parse(const std::vector<char> &message) = 0;
 
@@ -145,22 +133,22 @@ class Message {
 
     // Members
   private:
-    unique_ptr<OPPart> m_OPPart{};
+    unique_ptr<OPPart> oPPart{};
 
     // Receive
   public:
     Message(std::vector<char> message);
 
-    const Header *getHeader() const { return m_OPPart->getHeader(); }
+    const Header *getHeader() const { return oPPart->getHeader(); }
     int getType() const {
-        if (!m_OPPart || !m_OPPart->getHeader()) {
+        if (!oPPart || !oPPart->getHeader()) {
             return -1;
         }
-        return m_OPPart->getHeader()->getType();
+        return oPPart->getHeader()->getType();
     }
-    const OPPart *getOPPart() const { return m_OPPart.get(); }
+    const OPPart *getOPPart() const { return oPPart.get(); }
     template<typename T>
-    T &getAs() const { return *reinterpret_cast<T *>(m_OPPart.get()); }
+    T &getAs() const { return *reinterpret_cast<T *>(oPPart.get()); }
 
   private:
     bool parse(std::vector<char> message);
@@ -179,31 +167,31 @@ class Message {
         static constexpr int BYTESLENGTH = 304;
 
       private:
-        string m_ClientComputerName{};
-        string m_ClientName{};
-        string m_LoginName{};
-        string m_LoginPassword{};
-        string m_ServerIP{};
-        int m_ServerPort{};
+        string mClientComputerName{};
+        string mClientName{};
+        string mLoginName{};
+        string mLoginPassword{};
+        string mServerIp{};
+        int mServerPort{};
 
       public:
         // Receive
-        Connect(unique_ptr<Header> p_Header);
+        Connect(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        string getClientComputerName() const { return m_ClientComputerName; }
-        string getClientName() const { return m_ClientName; }
-        string getLoginName() const { return m_LoginName; }
-        string getLoginPassword() const { return m_LoginPassword; }
-        string getServerIP() const { return m_ServerIP; }
-        int getServerPort() const { return m_ServerPort; }
+        string getClientComputerName() const { return mClientComputerName; }
+        string getClientName() const { return mClientName; }
+        string getLoginName() const { return mLoginName; }
+        string getLoginPassword() const { return mLoginPassword; }
+        string getServerIP() const { return mServerIp; }
+        int getServerPort() const { return mServerPort; }
 
         // Send
         Connect(string p_ComputerName, string p_ClientName);
 
-        void setLoginName(string p_LoginName) { m_LoginName = p_LoginName; }
-        void setLoginPassword(string p_LoginPassword) { m_LoginPassword = p_LoginPassword; }
-        void setServerIP(string p_ServerIP) { m_ServerIP = p_ServerIP; }
+        void setLoginName(string p_LoginName) { mLoginName = p_LoginName; }
+        void setLoginPassword(string p_LoginPassword) { mLoginPassword = p_LoginPassword; }
+        void setServerIP(string p_ServerIP) { mServerIp = p_ServerIP; }
         void setServerPort(int p_ServerPort);
         bool fillBytes(std::vector<char> &message);
     };
@@ -216,28 +204,28 @@ class Message {
         static constexpr int BYTESLENGTH = 137;
 
       private:
-        string m_ServerComputerName{};
-        string m_ServerName{};
-        bool m_Connected{};
-        int m_StepTime{40}; // ms step size the Server will send play sequences
+        string mServerComputerName{};
+        string mServerName{};
+        bool mConnected{};
+        int mStepTime{40}; // ms step size the Server will send play sequences
 
       public:
         ConnectAnswer(const ConnectAnswer &orig);
         // Receive
-        ConnectAnswer(unique_ptr<Header> p_Header);
+        ConnectAnswer(unique_ptr<Header> header);
 
         bool parse(const std::vector<char> &message);
 
-        const string getServerComputerName() const { return m_ServerComputerName; }
-        const string getServerName() const { return m_ServerName; }
-        bool getConnected() const { return m_Connected; }
-        int getStepTime() const { return m_StepTime; }
+        const string getServerComputerName() const { return mServerComputerName; }
+        const string getServerName() const { return mServerName; }
+        bool getConnected() const { return mConnected; }
+        int getStepTime() const { return mStepTime; }
 
         // Send
         ConnectAnswer();
-        void setServerComputerName(string p_ServerComputerName) { m_ServerComputerName = p_ServerComputerName; }
-        void setServerName(string p_ServerName) { m_ServerName = p_ServerName; }
-        void setConnected(bool p_Connected) { m_Connected = p_Connected; }
+        void setServerComputerName(string p_ServerComputerName) { mServerComputerName = p_ServerComputerName; }
+        void setServerName(string p_ServerName) { mServerName = p_ServerName; }
+        void setConnected(bool p_Connected) { mConnected = p_Connected; }
         void setStepTime(int p_StepTime_ms);
         bool fillBytes(std::vector<char> &message);
     };
@@ -251,7 +239,7 @@ class Message {
 
         Disconnect(const Disconnect &orig);
         // Receive
-        Disconnect(unique_ptr<Header> p_Header);
+        Disconnect(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
         // Send
@@ -268,7 +256,7 @@ class Message {
 
         Watchdog(const Watchdog &orig);
         // Receive
-        Watchdog(unique_ptr<Header> p_Header);
+        Watchdog(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
         // Send
@@ -285,7 +273,7 @@ class Message {
 
         // Receive
         WatchdogAnswer(const WatchdogAnswer &orig);
-        WatchdogAnswer(unique_ptr<Header> p_Header);
+        WatchdogAnswer(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
         // Send
@@ -303,22 +291,22 @@ class Message {
         static constexpr int BYTESLENGTH = 113;
 
       private:
-        string m_ProjectID{};
-        string m_ProjectName{};
-        int m_FramesPerSecond{1000}; // Frames per second
+        string mProjectID{};
+        string mProjectName{};
+        int mFramesPerSecond{1000}; // Frames per second
 
         // Receive
       public:
         ReportProject(const ReportProject &orig);
-        ReportProject(unique_ptr<Header> p_Header);
+        ReportProject(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
-        const string getProjectID() const { return m_ProjectID; }
-        const string getProjectName() const { return m_ProjectName; }
-        int getFramesPerSecond() const { return m_FramesPerSecond; }
+        const string getProjectID() const { return mProjectID; }
+        const string getProjectName() const { return mProjectName; }
+        int getFramesPerSecond() const { return mFramesPerSecond; }
         // Send
         ReportProject(string p_ProjectID, string p_ProjectName);
 
-        void setFramesPerSecond(const int p_FramesPerSecond) { m_FramesPerSecond = p_FramesPerSecond; }
+        void setFramesPerSecond(const int p_FramesPerSecond) { mFramesPerSecond = p_FramesPerSecond; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -330,15 +318,15 @@ class Message {
         static constexpr int BYTESLENGTH = 45;
 
       private:
-        string m_ProjectID{};
+        string mProjectID{};
 
       public:
         CloseProject(const CloseProject &orig);
         // Receive
-        CloseProject(unique_ptr<Header> p_Header);
+        CloseProject(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
         const string getProjectID() const {
-            return m_ProjectID;
+            return mProjectID;
         }
         // Send
         CloseProject(string projectID);
@@ -353,7 +341,7 @@ class Message {
 
         RequestProjectTransfer(const RequestProjectTransfer &orig);
         // Receive
-        RequestProjectTransfer(unique_ptr<Header> p_Header);
+        RequestProjectTransfer(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
         // Send
         RequestProjectTransfer();
@@ -369,7 +357,7 @@ class Message {
 
         StartProjectTransfer(const StartProjectTransfer &orig);
         // Receive
-        StartProjectTransfer(unique_ptr<Header> p_Header);
+        StartProjectTransfer(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
         // Send
         StartProjectTransfer();
@@ -384,7 +372,7 @@ class Message {
 
         EndProjectTransfer(const EndProjectTransfer &orig);
         // Receive
-        EndProjectTransfer(unique_ptr<Header> p_Header);
+        EndProjectTransfer(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
         // Send
         EndProjectTransfer();
@@ -400,43 +388,43 @@ class Message {
         static constexpr int BYTESLENGTH = 168;
 
       private:
-        bool m_Confirmed{};
-        string m_SPITTypeID{};
-        bool m_Fixed{};
-        bool m_ServerRemote{};
-        bool m_ServerProjectIndepended{};
-        string m_SPITTypeGroupName{};
-        string m_SPITTypeName{};
-        uint64_t m_Delay{};
-        uint64_t m_Duration{};
+        bool mConfirmed{};
+        string mSPITTypeID{};
+        bool mFixed{};
+        bool mServerRemote{};
+        bool mServerProjectIndepended{};
+        string mTypeGroupName{};
+        string mSPITTypeName{};
+        uint64_t mDelay{};
+        uint64_t mDuration{};
 
       public:
         ReportType(const ReportType &orig);
         // Receive
-        ReportType(unique_ptr<Header> p_Header);
+        ReportType(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        bool getConfirmed() const { return m_Confirmed; }
-        const string getID() const { return m_SPITTypeID; }
-        bool getFixed() const { return m_Fixed; }
-        bool getServerRemote() const { return m_ServerRemote; }
-        bool getServerProjectIndepended() const { return m_ServerProjectIndepended; }
-        const string getGroupName() const { return m_SPITTypeGroupName; }
-        const string getName() const { return m_SPITTypeName; }
-        uint64_t getDelay() const { return m_Delay; }
-        uint64_t getDuration() const { return m_Duration; }
+        bool getConfirmed() const { return mConfirmed; }
+        const string getID() const { return mSPITTypeID; }
+        bool getFixed() const { return mFixed; }
+        bool getServerRemote() const { return mServerRemote; }
+        bool getServerProjectIndepended() const { return mServerProjectIndepended; }
+        const string getGroupName() const { return mTypeGroupName; }
+        const string getName() const { return mSPITTypeName; }
+        uint64_t getDelay() const { return mDelay; }
+        uint64_t getDuration() const { return mDuration; }
         // Send
 
         ReportType();
-        void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; }
-        void setID(string p_ID) { m_SPITTypeID = p_ID; }
-        void setFixed(bool p_Fixed) { m_Fixed = p_Fixed; }
-        void setServerRemote(bool p_IsServerRemote) { m_ServerRemote = p_IsServerRemote; }
-        void setServerProjectIndepended(bool p_ProjectIndpended) { m_ServerProjectIndepended = p_ProjectIndpended; }
-        void setGroupName(string p_GroupName) { m_SPITTypeGroupName = p_GroupName; }
-        void setName(string p_Name) { m_SPITTypeName = p_Name; }
-        void setDelay(uint64_t p_Delay) { m_Delay = p_Delay; }
-        void setDuration(uint64_t p_Duration) { m_Duration = p_Duration; }
+        void setConfirmed(bool p_Confirmed) { mConfirmed = p_Confirmed; }
+        void setID(string iD) { mSPITTypeID = iD; }
+        void setFixed(bool p_Fixed) { mFixed = p_Fixed; }
+        void setServerRemote(bool p_IsServerRemote) { mServerRemote = p_IsServerRemote; }
+        void setServerProjectIndepended(bool p_ProjectIndpended) { mServerProjectIndepended = p_ProjectIndpended; }
+        void setGroupName(string p_GroupName) { mTypeGroupName = p_GroupName; }
+        void setName(string p_Name) { mSPITTypeName = p_Name; }
+        void setDelay(uint64_t p_Delay) { mDelay = p_Delay; }
+        void setDuration(uint64_t p_Duration) { mDuration = p_Duration; }
 
         bool fillBytes(std::vector<char> &message);
     };
@@ -449,19 +437,19 @@ class Message {
         static constexpr int BYTESLENGTH = 45;
 
       private:
-        string m_SPITTypeID{};
+        string mSPITTypeID{};
 
       public:
         RemoveType(const RemoveType &orig);
         // Receive
-        RemoveType(unique_ptr<Header> p_Header);
+        RemoveType(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        const string getID() const { return m_SPITTypeID; }
+        const string getID() const { return mSPITTypeID; }
 
         // Send
         RemoveType();
-        void setID(string p_ID) { m_SPITTypeID = p_ID; }
+        void setID(string iD) { mSPITTypeID = iD; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -475,71 +463,71 @@ class Message {
         static constexpr int BYTESLENGTH = 339;
 
       private:
-        bool m_Confirmed{};
-        string m_SPITObjectID{};
-        bool m_Fixed{};
-        bool m_ServerRemote{};
-        string m_SPITObjectName{};
-        string m_SPITTypeID{};
-        string m_ServerParams{};
-        uint64_t m_FrameStart{};
-        uint64_t m_FrameLength{};
-        uint64_t m_FrameFadeInLength{};
-        uint64_t m_FrameFadeOutLength{};
-        int m_ValueFactor{};
-        char m_ValueUse{VALUEUSE_DISCARD};
-        int m_Track{};
-        string m_Remark{};
-        uint64_t m_Delay{};
-        uint64_t m_Duration{};
-        bool m_ActionAssigned{};
+        bool mConfirmed{};
+        string mSPITObjectID{};
+        bool mFixed{};
+        bool mServerRemote{};
+        string mSPITObjectName{};
+        string mSPITTypeID{};
+        string mServerParams{};
+        uint64_t mFrameStart{};
+        uint64_t mFrameLength{};
+        uint64_t mFrameFadeInLength{};
+        uint64_t mFrameFadeOutLength{};
+        int mValueFactor{};
+        char mValueUse{VALUEUSE_DISCARD};
+        int mTrack{};
+        string mRemark{};
+        uint64_t mDelay{};
+        uint64_t mDuration{};
+        bool mActionAssigned{};
 
       public:
         ReportObject(const ReportObject &orig);
         // Receive
-        ReportObject(unique_ptr<Header> p_Header);
+        ReportObject(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        bool getConfirmed() const { return m_Confirmed; }
-        const string getID() const { return m_SPITObjectID; }
-        bool getFixed() const { return m_Fixed; }
-        bool getServerRemote() const { return m_ServerRemote; }
-        const string getName() const { return m_SPITObjectName; }
-        const string getSPITTypeID() const { return m_SPITTypeID; }
-        const string getServerParams() const { return m_ServerParams; }
-        uint64_t getFrameStart() const { return m_FrameStart; }
-        uint64_t getFrameLength() const { return m_FrameLength; }
-        uint64_t getFrameFadeInLength() const { return m_FrameFadeInLength; }
-        uint64_t getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
-        int getValueFactor() const { return m_ValueFactor; }
-        char getValueUse() const { return m_ValueUse; }
-        int getTrack() const { return m_Track; }
-        const string getRemark() const { return m_Remark; }
-        uint64_t getDelay() const { return m_Delay; }
-        uint64_t getDuration() const { return m_Duration; }
-        bool getActionAssigned() const { return m_ActionAssigned; }
+        bool getConfirmed() const { return mConfirmed; }
+        const string getID() const { return mSPITObjectID; }
+        bool getFixed() const { return mFixed; }
+        bool getServerRemote() const { return mServerRemote; }
+        const string getName() const { return mSPITObjectName; }
+        const string getSPITTypeID() const { return mSPITTypeID; }
+        const string getServerParams() const { return mServerParams; }
+        uint64_t getFrameStart() const { return mFrameStart; }
+        uint64_t getFrameLength() const { return mFrameLength; }
+        uint64_t getFrameFadeInLength() const { return mFrameFadeInLength; }
+        uint64_t getFrameFadeOutLength() const { return mFrameFadeOutLength; }
+        int getValueFactor() const { return mValueFactor; }
+        char getValueUse() const { return mValueUse; }
+        int getTrack() const { return mTrack; }
+        const string getRemark() const { return mRemark; }
+        uint64_t getDelay() const { return mDelay; }
+        uint64_t getDuration() const { return mDuration; }
+        bool getActionAssigned() const { return mActionAssigned; }
         // Send
       public:
         ReportObject();
 
-        void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; };
-        void setID(string p_ID) { m_SPITObjectID = p_ID; };
-        void setFixed(bool p_Fixed) { m_Fixed = p_Fixed; };
-        void setServerRemote(bool p_IsRemote) { m_ServerRemote = p_IsRemote; };
-        void setName(string p_Name) { m_SPITObjectName = p_Name; };
-        void setSPITTypeID(string p_ID) { m_SPITTypeID = p_ID; };
-        void setServerParams(string p_Parameters) { m_ServerParams = p_Parameters; };
-        void setFrameStart(uint64_t p_StartTime) { m_FrameStart = p_StartTime; };
-        void setFrameLength(uint64_t p_Length) { m_FrameLength = p_Length; };
-        void setFrameFadeInLength(uint64_t p_FadeInTime) { m_FrameFadeInLength = p_FadeInTime; };
-        void setFrameFadeOutLength(uint64_t p_FadeOutTime) { m_FrameFadeOutLength = p_FadeOutTime; };
-        void setValueFactor(int p_Volume) { m_ValueFactor = p_Volume; };
-        void setValueUse(char p_ValueUse) { m_ValueUse = p_ValueUse; };
-        void setTrack(int p_Track) { m_Track = p_Track; };
-        void setRemark(string p_Description) { m_Remark = p_Description; };
+        void setConfirmed(bool p_Confirmed) { mConfirmed = p_Confirmed; };
+        void setID(string iD) { mSPITObjectID = iD; };
+        void setFixed(bool p_Fixed) { mFixed = p_Fixed; };
+        void setServerRemote(bool p_IsRemote) { mServerRemote = p_IsRemote; };
+        void setName(string p_Name) { mSPITObjectName = p_Name; };
+        void setSPITTypeID(string iD) { mSPITTypeID = iD; };
+        void setServerParams(string p_Parameters) { mServerParams = p_Parameters; };
+        void setFrameStart(uint64_t p_StartTime) { mFrameStart = p_StartTime; };
+        void setFrameLength(uint64_t p_Length) { mFrameLength = p_Length; };
+        void setFrameFadeInLength(uint64_t p_FadeInTime) { mFrameFadeInLength = p_FadeInTime; };
+        void setFrameFadeOutLength(uint64_t p_FadeOutTime) { mFrameFadeOutLength = p_FadeOutTime; };
+        void setValueFactor(int p_Volume) { mValueFactor = p_Volume; };
+        void setValueUse(char p_ValueUse) { mValueUse = p_ValueUse; };
+        void setTrack(int p_Track) { mTrack = p_Track; };
+        void setRemark(string p_Description) { mRemark = p_Description; };
         void setDelay(uint64_t p_Delay);
         void setDuration(uint64_t p_Duration);
-        void setActionAssigned(bool p_ActionAssigned) { m_ActionAssigned = p_ActionAssigned; }
+        void setActionAssigned(bool p_ActionAssigned) { mActionAssigned = p_ActionAssigned; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -551,19 +539,19 @@ class Message {
         static constexpr int BYTESLENGTH = 45;
 
       private:
-        string m_SPITObjectID{};
+        string mSPITObjectID{};
 
       public:
         RemoveObject(const RemoveObject &orig);
         // Receive
-        RemoveObject(unique_ptr<Header> p_Header);
+        RemoveObject(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        const string getID() const { return m_SPITObjectID; }
+        const string getID() const { return mSPITObjectID; }
         // Send
       public:
         RemoveObject();
-        void setID(string p_ID) { m_SPITObjectID = p_ID; }
+        void setID(string iD) { mSPITObjectID = iD; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -577,28 +565,28 @@ class Message {
         static constexpr int BYTESLENGTH = 119;
 
       private:
-        string m_PlayerID{};
-        string m_PlayerName{};
-        char m_PlayerType{};
-        bool m_PlayerIsRunning{};
-        uint64_t m_Time; // Frames
+        string mPlayerID{};
+        string mPlayerName{};
+        char mPlayerType{};
+        bool mPlayerIsRunning{};
+        uint64_t mTime; // Frames
 
       public:
         PlayStart(const PlayStart &orig);
         // Receive
-        PlayStart(unique_ptr<Header> p_Header);
+        PlayStart(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        const string getPlayerID() const { return m_PlayerID; }
-        const string getPlayerName() const { return m_PlayerName; }
-        char getPlayerType() const { return m_PlayerType; }
-        bool getPlayerIsRunning() const { return m_PlayerIsRunning; }
-        uint64_t getTime() const { return m_Time; }
+        const string getPlayerID() const { return mPlayerID; }
+        const string getPlayerName() const { return mPlayerName; }
+        char getPlayerType() const { return mPlayerType; }
+        bool getPlayerIsRunning() const { return mPlayerIsRunning; }
+        uint64_t getTime() const { return mTime; }
 
         // Send
         PlayStart(string p_PlayerID, string p_PlayerName, char p_PlayerType);
-        void setPlayerIsRunning(bool p_IsPlaying) { m_PlayerIsRunning = p_IsPlaying; }
-        void setTime(uint64_t p_Time) { m_Time = p_Time; }
+        void setPlayerIsRunning(bool p_IsPlaying) { mPlayerIsRunning = p_IsPlaying; }
+        void setTime(uint64_t p_Time) { mTime = p_Time; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -610,34 +598,34 @@ class Message {
         static constexpr int BYTESLENGTH = 100;
 
       private:
-        string m_PlayerID{};
-        string m_SPITObjectID{};
-        uint64_t m_FrameInsideObject{}; // Frames
-        bool m_PlayPrePosition{};
-        int m_Value{};
-        char m_ValueFlag{VALUEFLAG_DIRECT};
+        string mPlayerID{};
+        string mSPITObjectID{};
+        uint64_t mFrameInsideObject{}; // Frames
+        bool mPlayPrePosition{};
+        int mValue{};
+        char mValueFlag{VALUEFLAG_DIRECT};
 
       public:
         PlayObject(const PlayObject &orig);
         // Receive
-        PlayObject(unique_ptr<Header> p_Header);
+        PlayObject(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        const string getPlayerID() const { return m_PlayerID; }
-        const string getSPITObjectID() const { return m_SPITObjectID; }
-        uint64_t getFrameInsideObject() const { return m_FrameInsideObject; }
-        bool getPlayPrePosition() const { return m_PlayPrePosition; }
-        int getValue() const { return m_Value; }
-        char getValueFlag() const { return m_ValueFlag; }
+        const string getPlayerID() const { return mPlayerID; }
+        const string getSPITObjectID() const { return mSPITObjectID; }
+        uint64_t getFrameInsideObject() const { return mFrameInsideObject; }
+        bool getPlayPrePosition() const { return mPlayPrePosition; }
+        int getValue() const { return mValue; }
+        char getValueFlag() const { return mValueFlag; }
         // Send
         PlayObject();
 
-        void setPlayerID(string p_PlayerID) { m_PlayerID = p_PlayerID; }
-        void setID(string p_ID) { m_SPITObjectID = p_ID; }
-        void setFrameInsideObject(uint64_t p_TimeInside) { m_FrameInsideObject = p_TimeInside; }
-        void setPlayPrePosition(bool p_PlayOldPosition) { m_PlayPrePosition = p_PlayOldPosition; }
-        void setValue(int p_Value) { m_Value = p_Value; }
-        void setValueFlag(char p_ValueFlag) { m_ValueFlag = p_ValueFlag; }
+        void setPlayerID(string p_PlayerID) { mPlayerID = p_PlayerID; }
+        void setID(string iD) { mSPITObjectID = iD; }
+        void setFrameInsideObject(uint64_t p_TimeInside) { mFrameInsideObject = p_TimeInside; }
+        void setPlayPrePosition(bool p_PlayOldPosition) { mPlayPrePosition = p_PlayOldPosition; }
+        void setValue(int p_Value) { mValue = p_Value; }
+        void setValueFlag(char p_ValueFlag) { mValueFlag = p_ValueFlag; }
         bool fillBytes(std::vector<char> &message);
     };
 
@@ -648,14 +636,14 @@ class Message {
         static constexpr int BYTESLENGTH = 45;
 
       private:
-        string m_PlayerID{};
+        string mPlayerID{};
 
       public:
         PlayEnd(const PlayEnd &orig);
         // Receive
-        PlayEnd(unique_ptr<Header> p_Header);
+        PlayEnd(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
-        const string getPlayerID() const { return m_PlayerID; }
+        const string getPlayerID() const { return mPlayerID; }
 
         // Send
         PlayEnd(string p_PlayerID);
@@ -669,23 +657,23 @@ class Message {
         static constexpr int BYTESLENGTH = 57;
 
       private:
-        string m_SPITObjectID{};
-        uint64_t m_FrameInsideObject{};
-        int m_Value{};
+        string mSPITObjectID{};
+        uint64_t mFrameInsideObject{};
+        int mValue{};
 
       public:
         ReportPlayStatus(const ReportPlayStatus &orig);
         // Receive
-        ReportPlayStatus(unique_ptr<Header> p_Header);
+        ReportPlayStatus(unique_ptr<Header> header);
         bool parse(const std::vector<char> &message);
 
-        const string getID() const { return m_SPITObjectID; }
-        uint64_t getFrameInsideObject() const { return m_FrameInsideObject; }
-        int getValue() const { return m_Value; }
+        const string getID() const { return mSPITObjectID; }
+        uint64_t getFrameInsideObject() const { return mFrameInsideObject; }
+        int getValue() const { return mValue; }
         // Send
         ReportPlayStatus();
 
-        void setID(string p_ID);
+        void setID(string iD);
         void setFrameInsideObject(uint64_t p_TimeInside);
         void setValue(int p_Value);
         bool fillBytes(std::vector<char> &message);
diff --git a/components/spit/include/spit_object.hpp b/components/spit/include/spit_object.hpp
new file mode 100644
index 0000000..3d7e062
--- /dev/null
+++ b/components/spit/include/spit_object.hpp
@@ -0,0 +1,122 @@
+#pragma once 
+
+#include "spit_type.hpp"
+#include "spit_message.hpp"
+#include "spit_repo.hpp"
+
+using namespace std;
+namespace spit {
+
+class SObjectListener;
+
+class SObject {
+  public:
+    template <typename T>
+    struct Property {
+        friend SObject;
+        Property(bool &confirmed) 
+          : rConfirmed(confirmed) {
+        }
+        bool set(const T& val) {
+            if (mValue == val)
+              return false;
+            mValue = val;
+            rConfirmed = false;
+            return true;
+        }
+        T get () const {
+            return mValue;
+        }
+        private:
+          bool & rConfirmed;
+          T mValue{};
+    };
+
+    Property<string> Name{mConfirmed};
+    Property<string> Remark{mConfirmed};
+    Property<string> ServerParams{mConfirmed};
+    Property<string> SPITTypeID{mConfirmed};
+    // Returns if the SPITType triggers an action on the Server or on the client.
+    // @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
+    // true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
+    Property<bool> ServerRemote{mConfirmed};
+    Property<bool> Fixed{mConfirmed};
+    Property<uint64_t> FrameStart{mConfirmed};
+    Property<uint64_t> FrameLength{mConfirmed};
+    Property<uint64_t> FrameFadeInLength{mConfirmed};
+    Property<uint64_t> FrameFadeOutLength{mConfirmed};
+    Property<char> ValueUse{mConfirmed};
+    Property<int> ValueFactor{mConfirmed};
+    Property<int> Track{mConfirmed};
+    Property<uint64_t> Delay{mConfirmed};
+    Property<uint64_t> Duration{mConfirmed};
+
+    static void clearUnconfirmedObjects(SpitRepo<SObject> &repo);
+    static void setConfirmedFalse(SpitRepo<SObject> &repo);
+    static void eventProjectClosed(SpitRepo<SObject> &repo, SpitRepo<SObject> &remoteRepo);
+
+    SObject(string iD) {
+        mID = iD;
+    }
+
+  private:
+    string mID;
+    bool mConfirmed{};
+    bool mCreatedByClient{};
+    bool mActionAssigned{};
+    bool mActionAssignedType{}; // Virtual construct
+    char mValueUse{0x01};
+    int mValueFactor{1000000}; // Values are given in ppm -> 1000000 = 1/1;
+    bool mPlayPrePosition;
+    uint64_t mPlayTimeInsideFrames;
+    int mPlayValue;
+    char mPlayValueFlag;
+
+  public:
+    string getID() const { return mID; }
+   
+    /**
+     * This is used by the server and client to tell if the other side has registered the changes.
+     * @return true = other side has registered the changes.
+     */
+    bool getConfirmed() const { return mConfirmed; }
+    bool getCreatedByClient() const { return mCreatedByClient; }
+    /**
+     * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
+     * This is used when an action is associated with a SPITType.
+     * Then this action is done for every SObject with the SPITType.
+     * @return true = an action is assigned for the SPITType.
+     */
+    bool getActionAssignedType() const { return mActionAssignedType; }
+    /** Returns if this SObject has an associated action or not.
+     * @return true = the user has asscociated an action with this SObject or
+     *  the user has asscociated an action with the SPITType of this SObject
+     */
+    bool getActionAssigned() const { return mActionAssigned || mActionAssignedType; }
+
+    bool getProjectIndepended(SpitRepo<SType> &repo, SpitRepo<SType> &remoteRepo) const {
+        SType *ptrSPITType;
+        if (ServerRemote.get() == false) {
+            ptrSPITType = repo.getEntry(SPITTypeID.get());
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->ProjectIndepended.get();
+        } else {
+            ptrSPITType = remoteRepo.getEntry(SPITTypeID.get());
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->ProjectIndepended.get();
+        }
+    };
+
+    bool setConfirmed(bool confirmed);
+    void setCreatedByClient(bool createdByClient) { mCreatedByClient = createdByClient; }
+    bool setActionAssignedType(bool actionAssigned);
+    bool setActionAssigned(bool actionAssigned);
+
+    bool setMessageOP(Message::ReportObject *message);
+    void fillMessageOP(Message::ReportObject &message);
+    void fillMessageOP(Message::RemoveObject &message);
+};
+
+}
\ No newline at end of file
diff --git a/components/spit/include/spit_player.hpp b/components/spit/include/spit_player.hpp
new file mode 100644
index 0000000..eff2ef2
--- /dev/null
+++ b/components/spit/include/spit_player.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "spit_object.hpp"
+#include <unordered_map>
+
+namespace spit {
+
+class SPlayer {
+
+    //----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
+  public:
+    class PlayType {
+      public:
+        PlayType(SPlayer *spitPlayer, string spitObjectID);
+        PlayType(const PlayType &orig);
+
+        string getSPITTypeID() const { return mSpitTypeID; }
+
+        void startPlaySequence();
+        bool getIsNew() const { return mIsNew; }
+        void setIsNew(bool isNew) { mIsNew = isNew; }
+        bool getIsPlayed() const { return mIsPlayed; }
+        void setIsPlayed(bool p_IsFound) { mIsPlayed = p_IsFound; }
+        string getPlayerID() const { return mPlayerID; }
+        string getPlayerName() const { return mPlayerName; }
+        bool getPlayerIsRunning() const { return mPlayerRuns; }
+        void setPlayerIsRunning(bool playerRuns) { mPlayerRuns = playerRuns; }
+        void setValue(double value) { mValue = value; }
+        void addValue(double value, double valueFactor) { mValue += (value * valueFactor); }
+        double getValue() const { return mValue; }
+
+      private:
+        string mPlayerID;
+        string mPlayerName;
+        bool mPlayerRuns;
+        string mSpitTypeID;
+        bool mIsPlayed;
+        bool mIsNew;
+        double mValue;
+    };
+
+    //----- SPlayer ------
+  public:
+    // list the SPITPlayers
+    static unordered_map<string, unique_ptr<SPlayer>> sSpitPlayers; // all actual played objects
+    static SPlayer &getSPITPlayer(string pPlayerID);      // if a player does not exist creates a new one
+    static void clearPlayers() { sSpitPlayers.clear(); }
+
+    SPlayer(string pPlayerID);
+    virtual ~SPlayer();
+
+    void startPlaySequence();                    // called by SPIT_Client::parsePlaySPITStart
+    PlayType *addTypePlaying(string spitTypeID); // called by SPIT_Client::parsePlaySPITStart
+    void endPlaySequence();                      // called by SPIT_Client::parsePlaySPITEnd
+
+    string getID() {
+        return mId;
+    }
+
+    unordered_map<string, unique_ptr<PlayType>> &getPlaySPITTypes() { return mPlaySPITTypes; }
+    void setIsRunning(bool isRunning) { mIsRunning = isRunning; }
+    void setName(string name) { mName = name; }
+    void setType(char type) { mType = type; }
+    void setTime(uint64_t frames) { mTimeFrames = frames; }
+    bool getIsRunning() const { return mIsRunning; }
+    string getName() const { return mName; }
+    char getType() const { return mType; }
+    uint64_t getTime() const { return mTimeFrames; }
+
+  private:
+    string mId;
+    string mName;
+    char mType;
+    unordered_map<string, unique_ptr<PlayType>> mPlaySPITTypes;
+
+    bool mIsRunning;
+    uint64_t mTimeFrames;
+};
+
+}
\ No newline at end of file
diff --git a/components/spit/include/spit_repo.hpp b/components/spit/include/spit_repo.hpp
index c896f28..891cc37 100644
--- a/components/spit/include/spit_repo.hpp
+++ b/components/spit/include/spit_repo.hpp
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <memory>
 #include <string>
 #include <unordered_map>
diff --git a/components/spit/include/spit_socket.hpp b/components/spit/include/spit_socket.hpp
new file mode 100644
index 0000000..a31350f
--- /dev/null
+++ b/components/spit/include/spit_socket.hpp
@@ -0,0 +1,149 @@
+#pragma once
+
+#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;
+
+namespace spit {
+
+/** Returns an guid */
+string createGUID();
+/** Returns the name of the client's host computer*/
+string getClientHostName();
+
+class ISocket {
+  public:
+    /**
+     * IpAddress class is used to fetch all available IP addresses of the computer
+     * This is for internal usage
+     */
+    struct IpAddress {
+      public:
+        IpAddress(const string &iPAddress, const string &subnetMask)
+            : mIpAddress(iPAddress), mSubnetMask(subnetMask) {}
+        const string mIpAddress;
+        const string mSubnetMask;
+
+        /**
+         * Calculates the broadcast address from a ip4 address
+         * @param iPAddress the ip4 address
+         * @return returns the broadcast address
+         */
+        string getBroadcastIP4() const {
+            struct in_addr broadcast;
+            unsigned long ipAddress;
+            unsigned long subnetMask;
+
+            ipAddress = inet_addr(mIpAddress.data());
+            subnetMask = inet_addr(mSubnetMask.data());
+            broadcast.s_addr = ipAddress | ~subnetMask;
+            return inet_ntoa(broadcast);
+        }
+    };
+    const IpAddress mOwnIp;
+
+    ISocket(IpAddress ip) 
+      : mOwnIp(ip) {}
+
+    virtual int sendMessage(const char *message, int length) = 0;
+    virtual int receiveMessage(char *bu1ffer, int bufferLength, string *serverIp) const =0;
+    virtual void setConnectionParams(const string &serverIp, const string &serverPort, const string &clientIp, const string &clientPort) =0;
+    virtual int bindSocket(string clientIp, string clientPort) =0;
+    virtual int setBroadcast(bool broadcast) const =0;
+    virtual int sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) =0;
+
+    bool getIsBound() const { return mIsBound; }
+  protected: 
+    bool mIsBound{};
+};
+
+class Socket : public ISocket {
+  public:
+    static const int FAMILY_IP4 = AF_INET;
+
+
+    static IpAddress getAdaptersInfo();
+    bool createSocketUdp();
+    static const int INVALID_SOCKET = -1;
+
+  private:
+    int mUdpSocketIp4;
+
+  public:
+    //-------- class --------------
+    Socket(IpAddress ip) : ISocket(ip) {
+        mUdpSocketIp4 = INVALID_SOCKET;
+        createSocketUdp();
+    }
+    virtual ~Socket() {
+        ESP_LOGD("UDP", "Shutting down ...");
+
+        if (mUdpSocketIp4 != INVALID_SOCKET) {
+            shutdown(mUdpSocketIp4, 2);
+            close(mUdpSocketIp4);
+            mUdpSocketIp4 = INVALID_SOCKET;
+        }
+        fos::Task::delayMs(100);
+        mIsBound = false;
+    }
+
+  private:
+    string mServerIP{};
+    string mServerPort{};
+    string mClientIp{};
+    string mClientPort{};      // port given by the user maybe "0"
+    string mBoundClientPort{}; // port set after bind
+
+  public:
+    // Sets the ip address and port for server and client.
+    void setConnectionParams(const string &serverIp, const string &serverPort, const string &clientIp, const string &clientPort) override {
+        mServerIP = serverIp;
+        mServerPort = serverPort;
+        mClientIp = clientIp;
+        mClientPort = clientPort;
+    }
+
+    /**
+     * Send a message to the server as set by setConnectionParams
+     * @param message  byte buffer containing the message
+     * @param length length of the message
+     * @return
+     */
+    int sendMessage(const char *message, int length) override {
+        if (mServerPort.length() <= 0) {
+            return -1;
+        }
+        if (mIsBound == false) {
+            return -1;
+        }
+        int intResult = sendMessageTo(mServerIP, mServerPort, message, length);
+        return intResult;
+    }
+
+    int receiveMessage(char *bu1ffer, int bufferLength, string *serverIp) const override;
+    int setBroadcast(bool broadcast) const override;
+    int bindSocket(string clientIp, string clientPort) override;
+    int sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) override;
+
+    string getServerIP() const { return mServerIP; }
+    string getServerPort() const { return mServerPort; }
+    string getClientIP() const { return mClientIp; }
+    string getClientPort() const { return mClientPort; }
+    string getBoundClientPort() const { return mBoundClientPort; }
+    void setBoundClientPort(const string &port) { mBoundClientPort = port; }
+    void setIsBound(bool isBound) { mIsBound = isBound; }
+
+  private:
+};
+
+}
\ No newline at end of file
diff --git a/components/spit/include/spit_type.hpp b/components/spit/include/spit_type.hpp
new file mode 100644
index 0000000..ed8c1bb
--- /dev/null
+++ b/components/spit/include/spit_type.hpp
@@ -0,0 +1,190 @@
+#pragma once
+
+#include "spit_socket.hpp"
+#include "spit_message.hpp"
+#include "spit_repo.hpp"
+
+using namespace std;
+namespace spit {
+
+class STypeListener;
+
+class SType {
+  public:
+    template <typename T>
+    struct Property {
+        friend SType;
+        Property(bool &confirmed) 
+          : rConfirmed(confirmed) {
+        }
+        bool set(const T& val) {
+            if (mValue == val)
+              return false;
+            mValue = val;
+            rConfirmed = false;
+            return true;
+        }
+        T get () const {
+            return mValue;
+        }
+        private:
+          bool & rConfirmed;
+          T mValue{};
+    };
+
+    Property<string> GroupName{mConfirmed};
+    Property<string> Name{mConfirmed};
+    Property<bool> Fixed{mConfirmed};
+    Property<bool> ProjectIndepended{mConfirmed};
+    // Returns if the SType triggers an action on the Server or on the client.
+    // @return false = the action is triggered on the client The client waits for the server to play objects of this SType
+    // true = the action is triggered on the server. The server waits for the client to play objects of this SType.
+    Property<bool> ServerRemote{mConfirmed};
+    Property<uint64_t> DefaultDelay{mConfirmed};
+    Property<uint64_t> DefaultDuration{mConfirmed};
+    // Virtual construct - means ActionAssigned for STypes is is not implemented in SPITProtocol.
+    // This can used to setActionAssigned to all SPITObjects with this SType.
+    // This may be used in the case when the same action should be done for every SPITObject with this SType associated.
+    // @return true = the user has associated an action with this SType.
+    Property<bool> ActionAssigned{mConfirmed};
+
+    // Sets confirmed = false for all STypes.
+    // This should be called when the client has loaded a project.
+    static void setConfirmedFalse(SpitRepo<SType> &repo) {
+        auto &entries = repo.getRepo();
+        for (auto i = entries.begin(); i != entries.end(); i++) {
+            i->second->setConfirmed(false);
+        }
+    }
+    static void eventProjectClosed(SpitRepo<SType> &repo, SpitRepo<SType> &remoteRepo) {
+        auto &entries = repo.getRepo();
+        for (auto i = entries.begin(); i != entries.end();) {
+            SType *ptrSType = i->second.get();
+            if (ptrSType->getCreatedByClient() == true) {
+                i++;
+                continue;
+            }
+            i = entries.erase(i);
+        }
+        // Remote
+        remoteRepo.clearEntries();
+    }
+
+    SType(string iD) {
+        mID = iD;
+    }
+    SType(string iD, string grpName, string name, bool fixed, bool projectIndependent, uint64_t delay, uint64_t duration) {
+        mConfirmed = false;
+        mID = iD;
+        ActionAssigned.set(false);
+        GroupName.set(grpName);
+        Name.set(name);
+        Fixed.set(fixed);
+        ProjectIndepended.set(projectIndependent);
+        DefaultDelay.set(delay);
+        DefaultDuration.set(duration);
+    }
+
+  private:
+    bool mConfirmed{};
+    string mID;
+    bool mCreatedByClient; // flag true = the SPITTyype is created by the client
+                            // false = the SType is received from the server
+
+  public:
+    string getID() const { return mID; }
+
+    // This is used by the server and client to tell if the other side has registered the changes.
+    // @return true = other side has registered the changes.
+    bool getConfirmed() const { return mConfirmed; }
+    bool getCreatedByClient() const { return mCreatedByClient; }
+    void setCreatedByClient(bool createdByClient) { mCreatedByClient = createdByClient; }
+
+    // Set the content of the SType as received from the server
+    // @param p_ReportSType
+    // @return true = the SType is changed
+    // false = the SType is NOT changed, because it is not allowed to change.
+    bool setMessageOP(Message::ReportType &message) {
+        bool changeAllowed;
+
+        if ((mCreatedByClient == true) && (Fixed.get() == true)) {
+            changeAllowed = false;
+        } else {
+            changeAllowed = true;
+        }
+
+        // Confirmation should be changeable
+        if (mCreatedByClient) {
+            // Server reports a client created SType -> the type is confirmed
+            mConfirmed = true;
+        } else {
+            // type is NOT client created -> the client has to confirm the SPITtype
+            mConfirmed = message.getConfirmed();
+        }
+
+        if (changeAllowed == false) {
+            return false;
+        }
+        bool changed = false;
+
+        if (DefaultDelay.mValue != message.getDelay()) {
+            DefaultDelay.mValue = message.getDelay();
+            changed = true;
+        }
+        if (DefaultDuration.mValue != message.getDuration()) {
+            DefaultDuration.mValue = message.getDuration();
+            changed = true;
+        }
+        if (Fixed.mValue != message.getFixed()) {
+            Fixed.mValue = message.getFixed();
+            changed = true;
+        }
+        if (GroupName.mValue != message.getGroupName()) {
+            GroupName.mValue = message.getGroupName();
+            changed = true;
+        }
+        if (mID != message.getID()) {
+            mID = message.getID();
+            changed = true;
+        }
+        if (Name.mValue != message.getName()) {
+            Name.mValue = message.getName();
+            changed = true;
+        }
+        if (ProjectIndepended.mValue != message.getServerProjectIndepended()) {
+            ProjectIndepended.mValue = message.getServerProjectIndepended();
+            changed = true;
+        }
+        if (ServerRemote.mValue != message.getServerRemote()) {
+            ServerRemote.mValue = message.getServerRemote();
+            changed = true;
+        }
+        return changed;
+    }
+    void fillMessageOP(Message::ReportType &message) const {
+        message.setConfirmed(mConfirmed);
+        message.setDelay(DefaultDelay.mValue);
+        message.setDuration(DefaultDuration.mValue);
+        message.setFixed(Fixed.mValue);
+        message.setGroupName(GroupName.mValue);
+        message.setID(mID);
+        message.setName(Name.mValue);
+        message.setServerProjectIndepended(ProjectIndepended.mValue);
+        message.setServerRemote(ServerRemote.mValue);
+    }
+    void fillMessageOP(Message::RemoveType &message) const {
+        message.setID(mID);
+    }
+
+    // This is used by the server and client to tell if the other side has registered the changes.
+    // @param confirmed
+    // @return if mConfirmed has changed
+    bool setConfirmed(bool confirmed) {
+        if (mConfirmed == confirmed)
+            return false;
+        mConfirmed = confirmed;
+        return true;
+    }
+};
+
+}
\ No newline at end of file
diff --git a/components/spit/src/SPITObject.cpp b/components/spit/src/SPITObject.cpp
deleted file mode 100644
index d07313b..0000000
--- a/components/spit/src/SPITObject.cpp
+++ /dev/null
@@ -1,364 +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.
- */
-
-/*
- * SPITObject describes a SPIT Object
- * File:   SPITObject.cpp
- * Author: Hagi
- *
- * Created on 9. April 2019, 12:11
- */
-
-#include "SPITObject.h"
-#include "SPITSocket.h"
-#include "esp_log.h"
-
-/**
- * clears all unconfirmed SPITObjects not created by this SPIT_Client.
- */
-void SPITObject::clearUnconfirmedSPITObjects(SpitRepo<SPITObject> &repo) {
-    auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end();) {
-        SPITObject *ptrSPITObject = i->second.get();
-        if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) {
-            i = entries.erase(i);
-        } else {
-            i++;
-        }
-    }
-}
-
-void SPITObject::eventProjectClosed(SpitRepo<SPITObject> &repo, SpitRepo<SPITObject> &remoteRepo) {
-    auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); ) {
-        SPITObject *ptrSPITObject = i->second.get();
-        if (ptrSPITObject->getCreatedByClient() == true) {
-            i++;
-            continue;
-        }
-        i = entries.erase(i);
-    }
-    // Remote
-    remoteRepo.clearEntries();
-}
-/**
- * sets confirmed = false for all SPITObjects.
- * This should be called when the client has loaded a project.
- */
-void SPITObject::setConfirmedFalse(SpitRepo<SPITObject> &repo) {
-    auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); i++) {
-        i->second->setConfirmed(false);
-    }
-}
-
-SPITObject::SPITObject(string p_ID) {
-    m_ID = p_ID;
-}
-
-bool SPITObject::setMessageOP(Message::ReportObject *p_ReportSPITObject) {
-    bool boolChangeAllowed;
-    bool boolChanged = false;
-
-    if (m_CreatedByClient == true && m_Fixed == true) {
-        boolChangeAllowed = false;
-    } else {
-        boolChangeAllowed = true;
-    }
-
-    // Confirmation should be changable
-    if (m_CreatedByClient) {
-        // 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
-        m_Confirmed = p_ReportSPITObject->getConfirmed();
-    }
-
-    if (m_Delay != p_ReportSPITObject->getDelay()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Delay = p_ReportSPITObject->getDelay();
-        boolChanged = true;
-    }
-    if (m_Duration != p_ReportSPITObject->getDuration()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Duration = p_ReportSPITObject->getDuration();
-        boolChanged = true;
-    }
-    if (m_Fixed != p_ReportSPITObject->getFixed()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Fixed = p_ReportSPITObject->getFixed();
-        boolChanged = true;
-    }
-    if (m_FrameFadeInLength != p_ReportSPITObject->getFrameFadeInLength()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_FrameFadeInLength = p_ReportSPITObject->getFrameFadeInLength();
-        boolChanged = true;
-    }
-    if (m_FrameFadeOutLength != p_ReportSPITObject->getFrameFadeOutLength()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_FrameFadeOutLength = p_ReportSPITObject->getFrameFadeOutLength();
-        boolChanged = true;
-    }
-    if (m_FrameLength != p_ReportSPITObject->getFrameLength()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_FrameLength = p_ReportSPITObject->getFrameLength();
-        boolChanged = true;
-    }
-    if (m_FrameStart != p_ReportSPITObject->getFrameStart()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_FrameStart = p_ReportSPITObject->getFrameStart();
-        boolChanged = true;
-    }
-    if (m_Remark != p_ReportSPITObject->getRemark()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Remark = p_ReportSPITObject->getRemark();
-        boolChanged = true;
-    }
-    if (m_ID != p_ReportSPITObject->getID()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ID = p_ReportSPITObject->getID();
-        boolChanged = true;
-    }
-    if (m_Name != p_ReportSPITObject->getName()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Name = p_ReportSPITObject->getName();
-        boolChanged = true;
-    }
-    if (m_SPITTypeID != p_ReportSPITObject->getSPITTypeID()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_SPITTypeID = p_ReportSPITObject->getSPITTypeID();
-        boolChanged = true;
-    }
-    if (m_ServerParams != p_ReportSPITObject->getServerParams()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ServerParams = p_ReportSPITObject->getServerParams();
-        boolChanged = true;
-    }
-    if (m_ServerRemote != p_ReportSPITObject->getServerRemote()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ServerRemote = p_ReportSPITObject->getServerRemote();
-        boolChanged = true;
-    }
-    if (m_Track != p_ReportSPITObject->getTrack()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Track = p_ReportSPITObject->getTrack();
-        boolChanged = true;
-    }
-    if (m_ValueFactor != p_ReportSPITObject->getValueFactor()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ValueFactor = p_ReportSPITObject->getValueFactor();
-        boolChanged = true;
-    }
-    if (m_ValueUse != p_ReportSPITObject->getValueUse()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ValueUse = p_ReportSPITObject->getValueUse();
-        boolChanged = true;
-    }
-    return boolChanged;
-}
-
-void SPITObject::fillMessageOP(Message::ReportObject &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);
-    p_ReportSPITObject.setFixed(m_Fixed);
-    p_ReportSPITObject.setFrameFadeInLength(m_FrameFadeInLength);
-    p_ReportSPITObject.setFrameFadeOutLength(m_FrameFadeOutLength);
-    p_ReportSPITObject.setFrameLength(m_FrameLength);
-    p_ReportSPITObject.setFrameStart(m_FrameStart);
-    p_ReportSPITObject.setID(m_ID);
-    p_ReportSPITObject.setName(m_Name);
-    p_ReportSPITObject.setRemark(m_Remark);
-    p_ReportSPITObject.setSPITTypeID(m_SPITTypeID);
-    p_ReportSPITObject.setServerParams(m_ServerParams);
-    p_ReportSPITObject.setServerRemote(m_ServerRemote);
-    p_ReportSPITObject.setTrack(m_Track);
-    p_ReportSPITObject.setValueFactor(m_ValueFactor);
-    p_ReportSPITObject.setValueUse(m_ValueUse);
-}
-void SPITObject::fillMessageOP(Message::RemoveObject &p_RemoveSPITObject) {
-    p_RemoveSPITObject.setID(m_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 SPITObject::setConfirmed(bool p_Confirmed) {
-    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;
-    m_Name = p_Name;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setRemark(string p_Remark) {
-    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;
-    m_ServerParams = p_ServerParams;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setSPITTypeID(string p_SPITTypeID) {
-    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;
-    m_ServerRemote = p_BelongstoServer;
-    m_Confirmed = false;
-    return true;
-}
-/**
- * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
- * This is used when an action is associated with a SPITType.
- * 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;
-    bool boolOldActionAssigend;
-    boolOldActionAssigend = getActionAssigned();
-    m_ActionAssignedType = p_ActionAssigned;
-    if (getActionAssigned() == boolOldActionAssigend)
-        return false;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setActionAssigned(bool p_ActionAssigned) {
-    if (m_ActionAssigned == p_ActionAssigned)
-        return false;
-    bool boolOldActionAssigend;
-    boolOldActionAssigend = getActionAssigned();
-    m_ActionAssigned = p_ActionAssigned;
-    if (getActionAssigned() == boolOldActionAssigend)
-        return false;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setFixed(bool p_Fixed) {
-    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;
-    m_FrameStart = p_FrameStart;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setFrameLength(long long p_FrameLength) {
-    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;
-    m_FrameFadeInLength = p_FrameFadeInLength;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setFrameFadeOutLength(long long p_FrameFadeOutLength) {
-    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;
-    m_ValueUse = p_ValueUse;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setValueFactor(int p_ValueFactor) {
-    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;
-    m_Track = p_Track;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITObject::setDelay(long long p_Delay) {
-    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;
-    m_Duration = p_Duration;
-    m_Confirmed = false;
-    return true;
-}
diff --git a/components/spit/src/SPITPlayer.cpp b/components/spit/src/SPITPlayer.cpp
deleted file mode 100644
index 97e6bda..0000000
--- a/components/spit/src/SPITPlayer.cpp
+++ /dev/null
@@ -1,102 +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.
- */
-
-/*
- * SPITPlayer describes a virtual SPIT Player.
- * File:   SPITPLayer.cpp
- * Author: Hagi
- *
- * Created on 30. April 2019, 11:44
- */
-
-#include "SPITPlayer.h"
-#include "esp_log.h"
-#include <memory>
-#include <vector>
-
-using namespace std;
-
-unordered_map<string, unique_ptr<SPITPlayer>> SPITPlayer::s_SPITPlayers;
-
-SPITPlayer &SPITPlayer::getSPITPlayer(string p_PlayerID) {
-    auto i = s_SPITPlayers.find(p_PlayerID);
-    if (i == s_SPITPlayers.end()) {
-        s_SPITPlayers[p_PlayerID] = make_unique<SPITPlayer>(p_PlayerID);
-    }
-    return *s_SPITPlayers.at(p_PlayerID);
-}
-
-SPITPlayer::SPITPlayer(string p_PlayerID) {
-    m_ID = p_PlayerID;
-}
-
-SPITPlayer::~SPITPlayer() {
-    m_PlaySPITTypes.clear();
-}
-
-/**
- *
- * @param p_SPITObjectID
- * @return true = new PlayObject added<br>
- * false = PlayObject exists
- */
-SPITPlayer::PlaySPITType *SPITPlayer::addSPITType_Playing(string p_SPITTypeID) {
-    PlaySPITType *ptrPlaySPITType;
-    auto i = m_PlaySPITTypes.find(p_SPITTypeID);
-    if (i == m_PlaySPITTypes.end()) {
-        auto playSpitType = make_unique<PlaySPITType>(this, p_SPITTypeID);
-        ptrPlaySPITType = playSpitType.get();
-        m_PlaySPITTypes[p_SPITTypeID] = move(playSpitType);
-    } else {
-        ptrPlaySPITType = i->second.get();
-    }
-    ptrPlaySPITType->setIsPlayed(true);
-    return ptrPlaySPITType;
-}
-
-void SPITPlayer::startPlaySequence() {
-    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
-        PlaySPITType *ptrPlaySPITType = i->second.get();
-        ptrPlaySPITType->startPlaySequence();
-    }
-}
-
-void SPITPlayer::endPlaySequence() {
-    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end();) {
-        if (i->second.get()->getIsPlayed() == false) {
-            i = m_PlaySPITTypes.erase(i);
-        } else {
-            ++i;
-        }
-    }
-}
-
-SPITPlayer::PlaySPITType::PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITTypeID) {
-    m_IsNew = true;
-
-    m_SPITTypeID = p_SPITTypeID;
-    m_PlayerID = p_SPITPlayer->getID();
-    m_PlayerName = p_SPITPlayer->getName();
-    startPlaySequence();
-    m_IsNew = true;
-}
-SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType &orig) {
-    m_SPITTypeID = orig.getSPITTypeID();
-    m_IsPlayed = orig.getIsPlayed();
-    m_IsNew = orig.getIsNew();
-
-    m_PlayerID = orig.getPlayerID();
-    m_PlayerName = orig.getPlayerName();
-    m_PlayerRuns = orig.getPlayerIsRunning();
-
-    m_Value = orig.getValue();
-}
-void SPITPlayer::PlaySPITType::startPlaySequence() {
-    m_IsPlayed = false;
-    m_IsNew = false;
-
-    m_Value = 0;
-}
\ No newline at end of file
diff --git a/components/spit/src/SPITType.cpp b/components/spit/src/SPITType.cpp
deleted file mode 100644
index 8cef385..0000000
--- a/components/spit/src/SPITType.cpp
+++ /dev/null
@@ -1,239 +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.
- */
-
-/*
- * SPITType describes a SPIT Type
- * File:   SPITType.cpp
- * Author: Hagi
- *
- * Created on 8. April 2019, 08:40
- */
-
-#include "SPITType.h"
-#include "esp_log.h"
-
-using namespace spit;
-
-static const char *TAG = "SPIT";
-
-void SPITType::eventProjectClosed(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo) {
-    auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end();) {
-        SPITType *ptrSPITType = i->second.get();
-        if (ptrSPITType->getCreatedByClient() == true) {
-            i++;
-            continue;
-        }
-        i = entries.erase(i);
-    }
-    // Remote
-    remoteRepo.clearEntries();
-}
-
-/**
- * Sets confirmed = false for all SPITTypes.
- * This should be called when the client has loaded a project.
- */
-void SPITType::setConfirmedFalse(SpitRepo<SPITType> &repo) {
-    auto &entries = repo.getRepo();
-    for (auto i = entries.begin(); i != entries.end(); i++) {
-        i->second->setConfirmed(false);
-    }
-}
-
-SPITType::SPITType(string p_ID) {
-    m_ID = p_ID;
-}
-
-SPITType::SPITType(string id, string grpName, string name, bool fixed, bool projectIndependent, long long defaultDelay, long long defaultDuration) {
-    m_ActionAssigned = false;
-    m_Confirmed = false;
-    m_ID = id;
-    m_GroupName = grpName;
-    m_Name = name;
-    m_Fixed = fixed;
-    m_ServerProjectIndepended = projectIndependent;
-    m_DefaultDelay = defaultDelay;
-    m_DefaultDuration = defaultDuration;
-}
-
-void SPITType::setCreatedByClient(bool p_CreatedByClient) {
-    m_CreatedByClient = p_CreatedByClient;
-}
-
-/**
- * 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;
-    m_Confirmed = p_Confirmed;
-    return true;
-}
-
-bool SPITType::setGroupName(const string &p_GroupName) {
-    if (m_GroupName == p_GroupName)
-        return false;
-    m_GroupName = p_GroupName;
-    m_Confirmed = false;
-    return true;
-}
-bool SPITType::setName(const 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;
-    m_ServerRemote = p_BelongstoServer;
-    m_Confirmed = false;
-    return true;
-}
-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;
-    m_Fixed = p_Fixed;
-    m_Confirmed = false;
-    return true;
-}
-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;
-    m_DefaultDuration = p_Duration;
-    m_Confirmed = false;
-    return true;
-}
-
-/**
- * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
- * This can used to setActionAssigned to all SPITObjects with this SPITType.
- * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
- * @return true = the m_ActionAssigned has changed.
- */
-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
- * false = the SPITType is NOT changed, because it is not allowed to change.
- */
-bool SPITType::setMessageOP(Message::ReportType &reportSpitType) {
-    bool boolChangeAllowed;
-    bool boolChanged = false;
-
-    if (m_CreatedByClient == true && m_Fixed == true) {
-        boolChangeAllowed = false;
-    } else {
-        boolChangeAllowed = true;
-    }
-
-    // Confirmation should be changeable
-    if (m_CreatedByClient) {
-        // 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
-        m_Confirmed = reportSpitType.getConfirmed();
-    }
-    if (m_DefaultDelay != reportSpitType.getDelay()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_DefaultDelay = reportSpitType.getDelay();
-        boolChanged = true;
-    }
-    if (m_DefaultDuration != reportSpitType.getDuration()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_DefaultDuration = reportSpitType.getDuration();
-        boolChanged = true;
-    }
-    if (m_Fixed != reportSpitType.getFixed()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Fixed = reportSpitType.getFixed();
-        boolChanged = true;
-    }
-    if (m_GroupName != reportSpitType.getGroupName()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_GroupName = reportSpitType.getGroupName();
-        boolChanged = true;
-    }
-    if (m_ID != reportSpitType.getID()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ID = reportSpitType.getID();
-        boolChanged = true;
-    }
-    if (m_Name != reportSpitType.getName()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_Name = reportSpitType.getName();
-        boolChanged = true;
-    }
-    if (m_ServerProjectIndepended != reportSpitType.getServerProjectIndepended()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ServerProjectIndepended = reportSpitType.getServerProjectIndepended();
-        boolChanged = true;
-    }
-    if (m_ServerRemote != reportSpitType.getServerRemote()) {
-        if (boolChangeAllowed == false) {
-            return false;
-        }
-        m_ServerRemote = reportSpitType.getServerRemote();
-        boolChanged = true;
-    }
-    return boolChanged;
-}
-
-void SPITType::fillMessageOP(Message::ReportType &smReportSpitType) const {
-    smReportSpitType.setConfirmed(m_Confirmed);
-    smReportSpitType.setDelay(m_DefaultDelay);
-    smReportSpitType.setDuration(m_DefaultDuration);
-    smReportSpitType.setFixed(m_Fixed);
-    smReportSpitType.setGroupName(m_GroupName);
-    smReportSpitType.setID(m_ID);
-    smReportSpitType.setName(m_Name);
-    smReportSpitType.setServerProjectIndepended(m_ServerProjectIndepended);
-    smReportSpitType.setServerRemote(m_ServerRemote);
-}
-void SPITType::fillMessageOP(Message::RemoveType &smRemoveSpitType) const {
-    smRemoveSpitType.setID(m_ID);
-}
diff --git a/components/spit/src/SPIT_Client.cpp b/components/spit/src/spit_client.cpp
similarity index 57%
rename from components/spit/src/SPIT_Client.cpp
rename to components/spit/src/spit_client.cpp
index 41bb50f..bbe8769 100644
--- a/components/spit/src/SPIT_Client.cpp
+++ b/components/spit/src/spit_client.cpp
@@ -1,59 +1,47 @@
-/*
- * 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.
- */
 
-/*
- * SPIt_Client handles the Message transfer and
- * fires eventxxx functions to the SPIT_ClientInterface (implemented by the user app).
- *
- * File:   SPIT_Client.cpp
- * Author: Hagi
- *
- * Created on 7. April 2019, 08:50
- */
-
-#include "SPIT_Client.h"
+#include "spit_client.hpp"
 #include "esp_log.h"
 
+namespace spit {
 static const char *TAG = "SPIT";
 
 /**
  * Create a new SPIT_client instance, should be done once by the user app.
  * @param p_SPITClientInterface the user app should implement the SPIT_ClientInterface.
  */
-SPIT_Client::SPIT_Client(string name, string projName, Callbacks calls)
-    : I_SAD_Client(), mCallbacks(calls), m_Name(name), m_ProjName(projName) {
-    m_ID = createGUID();
-    m_ComputerName = getClientHostName();
-    auto ip = SPITSocket::getAdaptersInfo();
-    mSPITSocket = new SPITSocket(ip);
+SClient::SClient(string name, string projName, ISocket &socket, Callbacks calls)
+    : ISadClient(), 
+      mCallbacks(calls), 
+      mName(name), 
+      mProjName(projName), 
+      mSocket(socket) {
+    mID = createGUID();
+    mComputerName = getClientHostName();
 }
 
-SPIT_Client::~SPIT_Client() {
+SClient::~SClient() {
     stopServerAutoDetect();
     disconnectInternal(Connection::None);
 }
 
-void SPIT_Client::clientProjectClose() {
-    if (m_ConnectionStatus == Connection::Ok) {
+void SClient::clientProjectClose() {
+    if (mConnectionStatus == Connection::Ok) {
         ESP_LOGI(TAG, " ... tidy up ressources");
-        Message::CloseProject closeSPITProject(m_ProjName);
+        Message::CloseProject closeSPITProject(mProjName);
         if (sendSPITMessage(closeSPITProject) < 0) {
-            ESP_LOGD(TAG, "SPIT_Client could not send Client's ReportProject");
+            ESP_LOGD(TAG, "Client could not send Client's ReportProject");
         }
     }
 }
 
-void SPIT_Client::clientProjectLoaded() {
+void SClient::clientProjectLoaded() {
     // set confirmed = false for all SPITTypes and SPITObjects
-    SPITType::setConfirmedFalse(mSpitTypes);
-    SPITObject::setConfirmedFalse(mSpitObjects);
+    SType::setConfirmedFalse(mSpitTypes);
+    SObject::setConfirmedFalse(mSpitObjects);
 
-    if (m_ConnectionStatus == Connection::Ok) {
+    if (mConnectionStatus == Connection::Ok) {
         // send ReportProject to the server
-        Message::ReportProject reportSPITProject(m_ProjName, m_ProjName);
+        Message::ReportProject reportSPITProject(mProjName, mProjName);
         reportSPITProject.setFramesPerSecond(0);
         if (sendSPITMessage(reportSPITProject) < 0) {
             ESP_LOGD(TAG, "SPIT_CLient::clientProjectLoaded could not send Client's ReportProject");
@@ -68,23 +56,22 @@ void SPIT_Client::clientProjectLoaded() {
 }
 
 /**
- * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
+ * Virtual construct - means actionAssigned for SPITTypes is is not implemented in SPITProtocol.
  * This can used to setActionAssigned to all SPITObjects with this SPITType.
  * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
  * This tells the server not what action is done, but it tells the server that there is an action.
  * @param typeId the id of the SPITType
- * @param p_ActionAssigned
+ * @param actionAssigned
  */
-void SPIT_Client::setActionSPITType(string typeId, bool p_ActionAssigned) {
-    SPITType *spitType = mSpitTypes.getEntry(typeId);
+void SClient::setActionSPITType(string typeId, bool actionAssigned) {
+    SType *spitType = mSpitTypes.getEntry(typeId);
     if (spitType == nullptr)
         return;
-    if (spitType->setActionAssigned(p_ActionAssigned)) {
+    if (spitType->ActionAssigned.set(actionAssigned)) {
         sendSPITTypeInternal(*spitType);
-
         for (auto& [key, value] : mSpitObjects.getRepo()) {
-            if (value->getSPITTypeID() == spitType->getID()) {
-                if (value->setActionAssignedType(p_ActionAssigned) == true) {
+            if (value->SPITTypeID.get() == spitType->getID()) {
+                if (value->setActionAssignedType(actionAssigned) == true) {
                     sendSPITObjectInternal(value.get());
                 }
             }
@@ -93,8 +80,8 @@ void SPIT_Client::setActionSPITType(string typeId, bool p_ActionAssigned) {
 }
 
 /** This should be called if the user wants to associate/remove an action with a SPITObject. */
-void SPIT_Client::setActionSPITObject(string spitObjId, bool actionAssigned) {
-    SPITObject *spitObject = mSpitObjects.getEntry(spitObjId);
+void SClient::setActionSPITObject(string spitObjId, bool actionAssigned) {
+    SObject *spitObject = mSpitObjects.getEntry(spitObjId);
     if (spitObject == nullptr)
         return;
     if (spitObject->setActionAssigned(actionAssigned) == true) {
@@ -106,22 +93,21 @@ void SPIT_Client::setActionSPITObject(string spitObjId, bool actionAssigned) {
 /** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before.
  * If a SPITServer is detected in the locale network an eventServerDetected occurs.
  */
-void SPIT_Client::startServerAutoDetect() {
-    if (m_DisconnectedByServer == true) {
+void SClient::startServerAutoDetect() {
+    if (mDisconnectedByServer == true) {
         // Server has previously disconnected -> do not start ServerAutodetect directly
         fos::Task::delayMs(1000); // sleep a little to give the SPITServer time to clean up its stuff
     }
-
-    SAD_DetectedServer::clearDetectedServers();
+    SadDetectedServer::clearDetectedServers();
     if (!sThread) {
-        sThread = new fos::TaskT<SPIT_Client &>(SPIT_Client::processSocketTask, *this, "spitSock", fos::Task::DefaultStackSize * 2);
+        sThread = new fos::TaskT<SClient &>(SClient::processSocketTask, *this, "spitSock", fos::Task::DefaultStackSize * 2);
     }
     mAbortSearch = false;
     sStartSad.give();
 }
 
 /** Stops the auto detection of SPIT servers. */
-void SPIT_Client::stopServerAutoDetect() {
+void SClient::stopServerAutoDetect() {
     mAbortSearch = true;
 }
 /**
@@ -129,11 +115,11 @@ void SPIT_Client::stopServerAutoDetect() {
  * To do so the SAD_Client ServerAutoDetect has to be startet - see SAD_Client::startServerAutoDetect.
  * If a server can be reached via several IP addresses, the IP address is selected according to the following preference:
  */
-void SPIT_Client::eventServerDetected(SAD_DetectedServer &server) {
+void SClient::eventServerDetected(SadDetectedServer &server) {
     mCallbacks.onServerEvent(ServerEvent::Detect, server);
     // If a connection has been established and the connection is lost -> reconnect
     if (_doReconnect) {
-        if (m_ServerID == server.getID()) {
+        if (mServerID == server.getID()) {
             stopServerAutoDetect();
             ESP_LOGI(TAG, "reconnect to %s / %s", server.getIP().data(), server.getPort().data());
             if (connect(server.getIP(), server.getPort(), server.getClientIP(), "0")) {
@@ -141,7 +127,6 @@ void SPIT_Client::eventServerDetected(SAD_DetectedServer &server) {
             }
         }
     }
-
     // Stop auto detection because a suitable server was found
     stopServerAutoDetect();
     ESP_LOGI(TAG, "connect to %s / %s", server.getIP().data(), server.getPort().data());
@@ -155,16 +140,16 @@ void SPIT_Client::eventServerDetected(SAD_DetectedServer &server) {
  * 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.
  */
-void SPIT_Client::eventServerLost(SAD_DetectedServer &server) {
+void SClient::eventServerLost(SadDetectedServer &server) {
     mCallbacks.onServerEvent(ServerEvent::Lost, server);
 }
 
-void SPIT_Client::eventServerChanged(SAD_DetectedServer &server) {
+void SClient::eventServerChanged(SadDetectedServer &server) {
     mCallbacks.onServerEvent(ServerEvent::Changed, server);
-    // tryConnection(p_DetectedServer);
+    // tryConnection(detectedServer);
 }
 
-// void MyApp::tryConnection(const SAD_DetectedServer &detected) {
+// void MyApp::tryConnection(const SadDetectedServer &detected) {
 //     // fetch the infoemations from the detected
 //     bool boolSuccess = false;
 //     bool boolPossibleConnect = checkPossibleConnection(detected);
@@ -177,7 +162,7 @@ void SPIT_Client::eventServerChanged(SAD_DetectedServer &server) {
 //     // OPTION 1 Use the first server found
 //     // OPTION 2 Use the first server found that fulfills specific conditions
 //     // OPTION 3 take a copy of the detected and do connection later
-//     //		SAD_DetectedServer o_DetectedServer = detected;	//this will call the copy constructor
+//     //		SadDetectedServer o_DetectedServer = detected;	//this will call the copy constructor
 //     // ---------------------------------------
 
 //     // Excample use the first detected LOOPBACK server, means the server runs on the same computer as this client
@@ -186,17 +171,17 @@ void SPIT_Client::eventServerChanged(SAD_DetectedServer &server) {
 //     boolSuccess = false;
 //     // Stop auto detection because a suitable server was found
 //     stopServerAutoDetect();
-//     if (m_SPIT_Client != nullptr) {
-//         m_ServerProjectName = detected.getProjectName();
-//         m_ServerIP = detected.getIP();
+//     if (mSPIT_Client != nullptr) {
+//         mServerProjectName = detected.getProjectName();
+//         mServerIP = detected.getIP();
 
 // #if defined(DEBUGOUTPUT)
 //         ESP_LOGD(TAG, "MySPITApp: connect to %s ", detected.getIP().data());
 // #endif
-//         // Use the m_BoardNumber as login name
+//         // Use the mBoardNumber as login name
 //         string stringLoginName = "";
 //         string stringLoginPassword = "";
-//         boolSuccess = m_SPIT_Client->connect(detected.getIP(), detected.getPort(), detected.getClientIP(), stringLoginName, stringLoginPassword); // ClientPort = "0" meeans use any port
+//         boolSuccess = mSPIT_Client->connect(detected.getIP(), detected.getPort(), detected.getClientIP(), stringLoginName, stringLoginPassword); // ClientPort = "0" meeans use any port
 //     }
 //     if (boolSuccess == false) {
 //         // connection message could not be sent
@@ -211,13 +196,13 @@ void SPIT_Client::eventServerChanged(SAD_DetectedServer &server) {
 //     //	} //Excample
 // }
 
-int SPIT_Client::sendSPITMessage(Message::OPPart &opPart) {
-    if (m_MessageNumber_Send == 255)
-        m_MessageNumber_Send = 1;
+int SClient::sendSPITMessage(Message::OPPart &opPart) {
+    if (mMessageNumberSend == 255)
+        mMessageNumberSend = 1;
     else
-        m_MessageNumber_Send++;
-    opPart.setMessageNumber(m_MessageNumber_Send);
-    opPart.setServerInfoInHeader(m_ID, m_ServerID);
+        mMessageNumberSend++;
+    opPart.setMessageNumber(mMessageNumberSend);
+    opPart.setServerInfoInHeader(mID, mServerID);
 
     int opFlag = opPart.getHeader()->getType();
     try {
@@ -225,7 +210,7 @@ int SPIT_Client::sendSPITMessage(Message::OPPart &opPart) {
         if (spitMessage.empty()) {
             return -1;
         }
-        int intResult = mSPITSocket->sendMessage(spitMessage.data(), spitMessage.size());
+        int intResult = mSocket.sendMessage(spitMessage.data(), spitMessage.size());
         if (intResult < 0) {
             ESP_LOGD(TAG, "client could not send message OPFlage: %d", opFlag);
         }
@@ -236,74 +221,73 @@ int SPIT_Client::sendSPITMessage(Message::OPPart &opPart) {
     return -1;
 }
 
-bool SPIT_Client::startReceiveSPITMessages() {
-    if (!mSPITSocket->getIsBound())
+bool SClient::startReceiveSPITMessages() {
+    if (!mSocket.getIsBound())
         return false;
-    m_StopReceiveSPITMessages = false;
-    m_ThreadReceive = new fos::TaskT<SPIT_Client &>(receiveSPITMessage, *this, "receiveTask", fos::Task::DefaultStackSize * 4);
-
+    mStopReceiveMessages = false;
+    mThreadReceive = new fos::TaskT<SClient &>(receiveSPITMessage, *this, "receiveTask", fos::Task::DefaultStackSize * 4);
     return true;
 }
 
-void SPIT_Client::stopReceiveSPITMessages() {
-    m_StopReceiveSPITMessages = true;
+void SClient::stopReceiveSPITMessages() {
+    mStopReceiveMessages = true;
 }
 
-void SPIT_Client::receiveSPITMessage(SPIT_Client &rM) {
+void SClient::receiveSPITMessage(SClient &rM) {
     char buffer[MAXSPITMESSAGEBYTECOUNT + 1];
     int rdLen;
-    while (rM.m_StopReceiveSPITMessages == false) {
-        rdLen = rM.mSPITSocket->receiveMessage(buffer, MAXSPITMESSAGEBYTECOUNT, nullptr);
+    while (rM.mStopReceiveMessages == false) {
+        rdLen = rM.mSocket.receiveMessage(buffer, MAXSPITMESSAGEBYTECOUNT, nullptr);
         if (rdLen < 0) {
-            if (rM.m_StopReceiveSPITMessages) {
+            if (rM.mStopReceiveMessages) {
                 return;
             }
             continue;
         }
         auto vec = vector<char>(buffer, buffer + rdLen);
         auto spitMsg = make_unique<Message>(vec);
-        rM.parseSPIT_Message(move(spitMsg));
-        // rM.checkParseSPIT_Message(move(spitMsg));
+        rM.parseMessage(move(spitMsg));
+        // rM.checkParseMessage(move(spitMsg));
     }
 }
 
-void SPIT_Client::resetMessageNumberReceived() {
-    m_MessageNumber_Received = -1;
-    m_OvertakingSPIT_Messages.clear();
+void SClient::resetMessageNumberReceived() {
+    mMessageNumberReceived = -1;
+    mOvertakingMessages.clear();
 }
 
-void SPIT_Client::checkParseSPIT_Message(unique_ptr<Message> p_SPITMessage) {
+void SClient::checkParseMessage(unique_ptr<Message> p_SPITMessage) {
     answerWatchdog();
     if (!p_SPITMessage || !p_SPITMessage->getHeader() || p_SPITMessage->getOPPart()) {
-        ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message incomplete message");
+        ESP_LOGD(TAG, "Client::parseMessage incomplete message");
         return;
     }
 
     int intActualMessageNumber = (int)(p_SPITMessage->getHeader()->getMessageNumber() & 0xFF);
 
     if (intActualMessageNumber == 0) {
-        parseSPIT_Message(std::move(p_SPITMessage));
+        parseMessage(std::move(p_SPITMessage));
         return;
     }
-    if (m_MessageNumber_Received < 0) {
-        m_MessageNumber_Received = intActualMessageNumber;
-        parseSPIT_Message(std::move(p_SPITMessage));
+    if (mMessageNumberReceived < 0) {
+        mMessageNumberReceived = intActualMessageNumber;
+        parseMessage(std::move(p_SPITMessage));
         return;
     }
 
-    int intNextMessageNumber = m_MessageNumber_Received + 1;
+    int intNextMessageNumber = mMessageNumberReceived + 1;
     if (intNextMessageNumber > 255 || intNextMessageNumber < 1)
         intNextMessageNumber = 1;
 
     if (intActualMessageNumber == intNextMessageNumber) {
-        m_MessageNumber_Received = intActualMessageNumber;
-        parseSPIT_Message(std::move(p_SPITMessage));
+        mMessageNumberReceived = intActualMessageNumber;
+        parseMessage(std::move(p_SPITMessage));
 
         // check overtaking messages
-        auto it = m_OvertakingSPIT_Messages.begin();
-        while (m_OvertakingSPIT_Messages.size() > 0) {
+        auto it = mOvertakingMessages.begin();
+        while (mOvertakingMessages.size() > 0) {
 
-            intNextMessageNumber = m_MessageNumber_Received + 1;
+            intNextMessageNumber = mMessageNumberReceived + 1;
             if (intNextMessageNumber > 255 || intNextMessageNumber < 1)
                 intNextMessageNumber = 1;
 
@@ -311,11 +295,11 @@ void SPIT_Client::checkParseSPIT_Message(unique_ptr<Message> p_SPITMessage) {
             intActualMessageNumber = (int)(ptrOvertakingSPIT_Message->getHeader()->getMessageNumber() & 0xFF);
 
             if (intActualMessageNumber == intNextMessageNumber) {
-                m_MessageNumber_Received = intActualMessageNumber;
-                parseSPIT_Message(move(ptrOvertakingSPIT_Message));
-                m_OvertakingSPIT_Messages.erase(it);
+                mMessageNumberReceived = intActualMessageNumber;
+                parseMessage(move(ptrOvertakingSPIT_Message));
+                mOvertakingMessages.erase(it);
 
-                it = m_OvertakingSPIT_Messages.begin();
+                it = mOvertakingMessages.begin();
             } else {
                 break;
             }
@@ -323,143 +307,143 @@ void SPIT_Client::checkParseSPIT_Message(unique_ptr<Message> p_SPITMessage) {
 
     } else {
         // p_SPITMessage has overtaken another message
-        addOvertakingSPIT_Message(move(p_SPITMessage));
+        addOvertakingMessage(move(p_SPITMessage));
     }
 }
 
-void SPIT_Client::addOvertakingSPIT_Message(unique_ptr<Message> p_SPIT_Message) {
-    if (!p_SPIT_Message) {
+void SClient::addOvertakingMessage(unique_ptr<Message> message) {
+    if (!message) {
         return;
     }
-    if (m_OvertakingSPIT_Messages.size() > MAX_OVERTAKING_SPIT_MESSAGES) {
-        ESP_LOGD(TAG, "SPIT_Client receiveing: perhaps message lost !!!!!");
+    if (mOvertakingMessages.size() > MAX_OVERTAKING_SPIT_MESSAGES) {
+        ESP_LOGD(TAG, "Client receiveing: perhaps message lost !!!!!");
     }
 
-    int intMessageNumber = (int)(p_SPIT_Message->getHeader()->getMessageNumber() & 0xFF);
-    for (auto it = m_OvertakingSPIT_Messages.begin(); it != m_OvertakingSPIT_Messages.end(); ++it) {
+    int intMessageNumber = (int)(message->getHeader()->getMessageNumber() & 0xFF);
+    for (auto it = mOvertakingMessages.begin(); it != mOvertakingMessages.end(); ++it) {
         const auto &overtaking = *it;
         int intOvertakingMessageNumber = (int)(overtaking->getHeader()->getMessageNumber() & 0xFF);
         if (intMessageNumber < intOvertakingMessageNumber) {
-            m_OvertakingSPIT_Messages.insert(it, move(p_SPIT_Message));
+            mOvertakingMessages.insert(it, move(message));
             return;
         }
     }
-    m_OvertakingSPIT_Messages.push_back(move(p_SPIT_Message));
+    mOvertakingMessages.push_back(move(message));
 }
 
-void SPIT_Client::parseSPIT_Message(unique_ptr<Message> p_SPITMessage) {
+void SClient::parseMessage(unique_ptr<Message> message) {
     answerWatchdog();
-    if (!p_SPITMessage || !p_SPITMessage->getHeader() || !p_SPITMessage->getOPPart()) {
-        ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message incomplete message");
+    if (!message || !message->getHeader() || !message->getOPPart()) {
+        ESP_LOGD(TAG, "Client::parseMessage incomplete message");
         return;
     }
 
-    switch (p_SPITMessage->getType()) {
+    switch (message->getType()) {
     //----- Connection -----
     case Message::ConnectAnswer::OPFLAG:
-        parseConnectAnswer(p_SPITMessage->getAs<Message::ConnectAnswer>());
+        parseConnectAnswer(message->getAs<Message::ConnectAnswer>());
         break;
     case Message::Disconnect::OPFLAG:
-        parseDisconnect(p_SPITMessage->getAs<Message::Disconnect>());
+        parseDisconnect(message->getAs<Message::Disconnect>());
         break;
     case Message::ReportProject::OPFLAG:
-        parseReportSPITProject(p_SPITMessage->getAs<Message::ReportProject>());
+        parseReportProject(message->getAs<Message::ReportProject>());
         break;
     case Message::Watchdog::OPFLAG:
-        parseWatchdog(p_SPITMessage->getAs<Message::Watchdog>());
+        parseWatchdog(message->getAs<Message::Watchdog>());
         break;
     case Message::WatchdogAnswer::OPFLAG:
-        parseWatchdogAnswer(p_SPITMessage->getAs<Message::WatchdogAnswer>());
+        parseWatchdogAnswer(message->getAs<Message::WatchdogAnswer>());
         break;
     //----- SPIT Project -----
     case Message::StartProjectTransfer::OPFLAG:
-        parseStartProjectTransfer(p_SPITMessage->getAs<Message::StartProjectTransfer>());
+        parseStartProjectTransfer(message->getAs<Message::StartProjectTransfer>());
         break;
     case Message::CloseProject::OPFLAG:
-        parseCloseSPITProject(p_SPITMessage->getAs<Message::CloseProject>());
+        parseCloseProject(message->getAs<Message::CloseProject>());
         break;
     case Message::RequestProjectTransfer::OPFLAG:
-        parseRequestProjectTransfer(p_SPITMessage->getAs<Message::RequestProjectTransfer>());
+        parseRequestProjectTransfer(message->getAs<Message::RequestProjectTransfer>());
         break;
     case Message::EndProjectTransfer::OPFLAG:
-        parseEndProjectTransfer(p_SPITMessage->getAs<Message::EndProjectTransfer>());
+        parseEndProjectTransfer(message->getAs<Message::EndProjectTransfer>());
         break;
     //----- SPIT Types ------
     case Message::ReportType::OPFLAG:
-        parseReportSPITType(p_SPITMessage->getAs<Message::ReportType>());
+        parseReportSPITType(message->getAs<Message::ReportType>());
         break;
     case Message::RemoveType::OPFLAG:
-        parseRemoveSPITType(p_SPITMessage->getAs<Message::RemoveType>());
+        parseRemoveSPITType(message->getAs<Message::RemoveType>());
         //----- SPIT Objects ------
         break;
     case Message::ReportObject::OPFLAG:
-        parseReportSPITObject(p_SPITMessage->getAs<Message::ReportObject>());
+        parseReportSPITObject(message->getAs<Message::ReportObject>());
         break;
     case Message::RemoveObject::OPFLAG:
-        parseRemoveSPITObject(p_SPITMessage->getAs<Message::RemoveObject>());
+        parseRemoveSPITObject(message->getAs<Message::RemoveObject>());
         break;
         //----- Play SPIT Objects ------
     case Message::PlayStart::OPFLAG:
-        parsePlaySPITStart(p_SPITMessage->getAs<Message::PlayStart>());
+        parsePlaySPITStart(message->getAs<Message::PlayStart>());
         break;
     case Message::PlayObject::OPFLAG:
-        parsePlaySPITObject(p_SPITMessage->getAs<Message::PlayObject>());
+        parsePlaySPITObject(message->getAs<Message::PlayObject>());
         break;
     case Message::PlayEnd::OPFLAG:
-        parsePlaySPITEnd(p_SPITMessage->getAs<Message::PlayEnd>());
+        parsePlaySPITEnd(message->getAs<Message::PlayEnd>());
         break;
     case Message::ReportPlayStatus::OPFLAG:
-        parseReportPlayStatus(p_SPITMessage->getAs<Message::ReportPlayStatus>());
+        parseReportPlayStatus(message->getAs<Message::ReportPlayStatus>());
         break;
     default:
-        ESP_LOGD(TAG, "SPIT_Client::parseSPIT_Message: Unknown Message");
+        ESP_LOGD(TAG, "Client::parseMessage: Unknown Message");
     }
 }
 
 //----- Connection ------
 /**
  * Tries to connect to a SPITServer.
- * @param p_ServerIP the ip address of the SPIT server
- * @param p_ServerPort the port number of the SPIT server
- * @param p_ClientIP the local IP address of the client
- * @param p_ClientPort the port number of the Client, if "0" the OS uses any possible port number
- * @param p_LoginName login user name (liveSHOW does not use this -> mayby ""
- * @param p_LoginPassword login user password (liveSHOW does not use this -> mayby ""
+ * @param serverIP the ip address of the SPIT server
+ * @param serverPort the port number of the SPIT server
+ * @param clientIP the local IP address of the client
+ * @param clientPort the port number of the Client, if "0" the OS uses any possible port number
+ * @param loginName login user name (liveSHOW does not use this -> mayby ""
+ * @param loginPassword login user password (liveSHOW does not use this -> mayby ""
  * @return false = an error has occured, true = the connect was sent to the server
  */
-bool SPIT_Client::connect(string p_ServerIP, string p_ServerPort, string p_ClientIP, string p_ClientPort, string p_LoginName, string p_LoginPassword) {
+bool SClient::connect(string serverIP, string serverPort, string clientIP, string clientPort, string loginName, string loginPassword) {
     disconnect();
-    mSPITSocket->setConnectionParams(p_ServerIP, p_ServerPort, p_ClientIP, p_ClientPort);
-    if (mSPITSocket->bindSocket(p_ClientIP, p_ClientPort) < 0) {
-        m_StopReceiveSPITMessages = true;
+    mSocket.setConnectionParams(serverIP, serverPort, clientIP, clientPort);
+    if (mSocket.bindSocket(clientIP, clientPort) < 0) {
+        mStopReceiveMessages = true;
         return false;
     }
-    Message::Connect sMConnect(m_ComputerName, m_Name);
-    sMConnect.setLoginName(p_LoginName);
-    sMConnect.setLoginPassword(p_LoginPassword);
-    sMConnect.setServerIP(p_ServerIP);
-    if (p_ServerPort.length() <= 0) {
-        p_ServerPort = "0";
+    Message::Connect sMConnect(mComputerName, mName);
+    sMConnect.setLoginName(loginName);
+    sMConnect.setLoginPassword(loginPassword);
+    sMConnect.setServerIP(serverIP);
+    if (serverPort.length() <= 0) {
+        serverPort = "0";
     }
-    int intServerPort = stoi(p_ServerPort);
+    int intServerPort = stoi(serverPort);
     sMConnect.setServerPort(intServerPort);
 
     if (startReceiveSPITMessages() == false) {
-        m_StopReceiveSPITMessages = true;
+        mStopReceiveMessages = true;
         return false;
     }
     resetMessageNumberReceived();
-    Connection intOldConnectionStatus = m_ConnectionStatus;
+    Connection intOldConnectionStatus = mConnectionStatus;
 
-    m_ConnectionStatus = Connection::TryConnection;
-    mCallbacks.onConnectionStatus(m_ServerID, m_ServerComputerName, m_ServerName, m_ServerStepTime,
-                                  m_ConnectionStatus, intOldConnectionStatus);
+    mConnectionStatus = Connection::TryConnection;
+    mCallbacks.onConnectionStatus(mServerID, mServerComputerName, mServerName, mServerStepTime,
+                                  mConnectionStatus, intOldConnectionStatus);
 
     // sleep a little to make sure that the reception of the messages is started
     fos::Task::delayMs(500);
     if (sendSPITMessage(sMConnect) < 0) {
-        m_ConnectionStatus = Connection::None;
-        m_StopReceiveSPITMessages = true;
+        mConnectionStatus = Connection::None;
+        mStopReceiveMessages = true;
         return false;
     }
     return true;
@@ -468,15 +452,15 @@ bool SPIT_Client::connect(string p_ServerIP, string p_ServerPort, string p_Clien
 /**
  * Terminates the connection to the SPITServer.
  */
-void SPIT_Client::disconnect() {
+void SClient::disconnect() {
     disconnectInternal(Connection::None);
 }
 
-void SPIT_Client::disconnectInternal(Connection p_Cause) {
-    Connection intOldConnectionStatus = m_ConnectionStatus;
+void SClient::disconnectInternal(Connection cause) {
+    Connection intOldConnectionStatus = mConnectionStatus;
 
-    m_ConnectionStatus = p_Cause;
-    switch (m_ConnectionStatus) {
+    mConnectionStatus = cause;
+    switch (mConnectionStatus) {
     case Connection::Lost:
         break;
     case Connection::None: {
@@ -490,26 +474,26 @@ void SPIT_Client::disconnectInternal(Connection p_Cause) {
     }
 
     stopReceiveSPITMessages();
-    mCallbacks.onConnectionStatus(m_ServerID, m_ServerComputerName, m_ServerName, m_ServerStepTime,
-                                  m_ConnectionStatus, intOldConnectionStatus);
+    mCallbacks.onConnectionStatus(mServerID, mServerComputerName, mServerName, mServerStepTime,
+                                  mConnectionStatus, intOldConnectionStatus);
 
     if (intOldConnectionStatus != Connection::None && intOldConnectionStatus != Connection::NoneServer) {
-        ESP_LOGI(TAG, "eventConnectionStatus %d ", (int)m_ConnectionStatus);
-        switch (m_ConnectionStatus) {
-        case SPIT_Client::Connection::None:
+        ESP_LOGI(TAG, "eventConnectionStatus %d ", (int)mConnectionStatus);
+        switch (mConnectionStatus) {
+        case SClient::Connection::None:
             ESP_LOGD(TAG, "not connected");
             break;
-        case SPIT_Client::Connection::NoneServer:
+        case SClient::Connection::NoneServer:
             ESP_LOGD(TAG, "connection terminated by server");
             // call eventProjectClosed because this may not be sended by the server,
             // when the connection is closed
-            mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, m_ServerProjectID);
+            mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, mServerProjectID);
 
             // Server has terminated the connection -> start a new game
             // _doReconnect = false;
             startServerAutoDetect();
             break;
-        case SPIT_Client::Connection::Lost:
+        case SClient::Connection::Lost:
             ESP_LOGD(TAG, "connection lost");
             // Maybe you want to reconnect, see eventServerDetected(...)
             // We have lost the connection -> set the flag to true and start the autodetection to reconnect at eventServerDetected(...)
@@ -522,25 +506,25 @@ void SPIT_Client::disconnectInternal(Connection p_Cause) {
     }
 }
 
-void SPIT_Client::parseConnectAnswer(Message::ConnectAnswer &p_ConnectAnswer) {
-    if (p_ConnectAnswer.getClientID() != m_ID)
+void SClient::parseConnectAnswer(Message::ConnectAnswer &message) {
+    if (message.getClientID() != mID)
         return;
 
-    m_ServerID = p_ConnectAnswer.getServerID();
-    m_ServerComputerName = p_ConnectAnswer.getServerComputerName();
-    m_ServerName = p_ConnectAnswer.getServerName();
-    m_ServerStepTime = p_ConnectAnswer.getStepTime();
+    mServerID = message.getServerID();
+    mServerComputerName = message.getServerComputerName();
+    mServerName = message.getServerName();
+    mServerStepTime = message.getStepTime();
 
-    if (p_ConnectAnswer.getConnected() == false) {
+    if (message.getConnected() == false) {
         disconnectInternal(Connection::NoneServer);
     } else {
-        p_ConnectAnswer.getStepTime();
-        m_ConnectionStatus = Connection::Ok;
-        m_DisconnectedByServer = false;
+        message.getStepTime();
+        mConnectionStatus = Connection::Ok;
+        mDisconnectedByServer = false;
         ESP_LOGD(TAG, "connection established");
         stopServerAutoDetect(); // normally you should stop the autodetection before you try a connection
                                 // This is redundand
-        m_StopReceiveSPITMessages = false;
+        mStopReceiveMessages = false;
 
         // Maybe you want to reconnect, see eventServerDetected(...)
         // Here the connection is established -> don't reconnect at eventServerDetected(...)
@@ -550,16 +534,16 @@ void SPIT_Client::parseConnectAnswer(Message::ConnectAnswer &p_ConnectAnswer) {
 
 /**
  * The SPIT server was closed
- * @param p_Disconnect
+ * @param message
  */
-void SPIT_Client::parseDisconnect(Message::Disconnect &p_Disconnect) {
+void SClient::parseDisconnect(Message::Disconnect &message) {
     Connection intCauseDisconnect = Connection::NoneServer;
     /*
-    function<void()> o_Callable = bind(&SPIT_Client::disconnectInternal, this, intCauseDisconnect);
+    function<void()> o_Callable = bind(&SClient::disconnectInternal, this, intCauseDisconnect);
     SPIT_Handler::addCallable(o_Callable);
     */
-    m_DisconnectedByServer = true;
-    SPIT_Client::disconnectInternal(intCauseDisconnect);
+    mDisconnectedByServer = true;
+    SClient::disconnectInternal(intCauseDisconnect);
 }
 
 //----- Watchdog ------
@@ -567,9 +551,9 @@ void SPIT_Client::parseDisconnect(Message::Disconnect &p_Disconnect) {
  * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
  * Conversely, the client also sends a watchdog message at regular intervals and waits for a WatchdogAnswer message.
  * This is used to check if the other side is still present.
- * @param p_Watchdog
+ * @param message
  */
-void SPIT_Client::parseWatchdog(Message::Watchdog &p_Watchdog) {
+void SClient::parseWatchdog(Message::Watchdog &message) {
     // ESP_LOGD(TAG, "parse Watchdog ");
     Message::WatchdogAnswer o_WatchdogAnswer;
     sendSPITMessage(o_WatchdogAnswer);
@@ -578,21 +562,21 @@ void SPIT_Client::parseWatchdog(Message::Watchdog &p_Watchdog) {
  * The SPIT server sends a watchdog message at regular intervals. The client responds immediately with WatchdogAnswer
  * Conversely, the client also sends a watchdog message at regular intervals and waits for a WatchdogAnswer message.
  * This is used to check if the other side is still present.
- * @param p_Watchdog
+ * @param message
  */
-void SPIT_Client::parseWatchdogAnswer(Message::WatchdogAnswer &p_WatchdogAnswer) {
-    answerWatchdog(); // is also done by parseSPIT_Message
+void SClient::parseWatchdogAnswer(Message::WatchdogAnswer &message) {
+    answerWatchdog(); // is also done by parseMessage
 }
-void SPIT_Client::sendWatchdog() {
+void SClient::sendWatchdog() {
     int intResult;
-    Message::Watchdog sMWatchdog;
-    intResult = sendSPITMessage(sMWatchdog);
+    Message::Watchdog message;
+    intResult = sendSPITMessage(message);
     if (intResult < 0) {
         ESP_LOGW("WDT", "Failed to send Watchdog msg");
     }
 }
-void SPIT_Client::eventWatchdogLost() {
-    if (m_ConnectionStatus == Connection::TryConnection) {
+void SClient::eventWatchdogLost() {
+    if (mConnectionStatus == Connection::TryConnection) {
         disconnectInternal(Connection::NoneServer);
     } else {
         disconnectInternal(Connection::Lost);
@@ -600,43 +584,43 @@ void SPIT_Client::eventWatchdogLost() {
 }
 
 //----- SPIT Project ------
-void SPIT_Client::parseReportSPITProject(Message::ReportProject &p_ReportSPITProject) {
+void SClient::parseReportProject(Message::ReportProject &message) {
     ESP_LOGD(TAG, "parse ReportProject");
-    m_ServerProjectID = p_ReportSPITProject.getProjectID();
-    m_ServerProjectName = p_ReportSPITProject.getProjectName();
-    m_ServerFramesPerSecond = p_ReportSPITProject.getFramesPerSecond();
-    mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, m_ServerProjectID);
+    mServerProjectID = message.getProjectID();
+    mServerProjectName = message.getProjectName();
+    mServerFramesPerSecond = message.getFramesPerSecond();
+    mCallbacks.onProjectUpdate(ProjUpdate::ServerLoaded, mServerProjectID);
 
     // Set all SPITTypes and SPITObjects confirmed = false
-    SPITType::setConfirmedFalse(mSpitTypes);
-    SPITObject::setConfirmedFalse(mSpitObjects);
+    SType::setConfirmedFalse(mSpitTypes);
+    SObject::setConfirmedFalse(mSpitObjects);
 
     // Send RequestProjectTransfer
     Message::RequestProjectTransfer sMRequestProjectTransfer;
     if (sendSPITMessage(sMRequestProjectTransfer) < 0) {
-        ESP_LOGD(TAG, "SPIT_Client::parseReportSPITProject could not send RequestProjectTransfer");
+        ESP_LOGD(TAG, "Client::parseReportProject could not send RequestProjectTransfer");
     }
 
     // todo Don't send the ReportProject here it should be sended after parseEndProjectTransfer
     // Send client's ReportProject
-    Message::ReportProject reportSPITProject(m_ProjName, m_ProjName);
-    reportSPITProject.setFramesPerSecond(0);
-    if (sendSPITMessage(reportSPITProject) < 0) {
-        ESP_LOGD(TAG, "SPIT_Client::parseReportSPITProject could not send Client's ReportProject");
+    Message::ReportProject reportProject(mProjName, mProjName);
+    reportProject.setFramesPerSecond(0);
+    if (sendSPITMessage(reportProject) < 0) {
+        ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
     }
 }
-void SPIT_Client::parseCloseSPITProject(Message::CloseProject &p_CloseSPITProject) {
+void SClient::parseCloseProject(Message::CloseProject &p_CloseSPITProject) {
     ESP_LOGD(TAG, "parse CloseProject");
     string stringProjectID;
     mCallbacks.onProjectUpdate(ProjUpdate::ServerClosed, p_CloseSPITProject.getProjectID());
-    SPITPlayer::clearPlayers();
+    SPlayer::clearPlayers();
 }
 
-string SPIT_Client::getServerProjectID() { return m_ServerProjectID; }
-string SPIT_Client::getServerProjectName() { return m_ServerProjectName; }
-int SPIT_Client::getServerFramesPerSecond() { return m_ServerFramesPerSecond; }
+string SClient::getServerProjectID() { return mServerProjectID; }
+string SClient::getServerProjectName() { return mServerProjectName; }
+int SClient::getServerFramesPerSecond() { return mServerFramesPerSecond; }
 
-void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer &p_RequestProjectTransfer) {
+void SClient::parseRequestProjectTransfer(Message::RequestProjectTransfer &message) {
     ESP_LOGD(TAG, "parse RequestProjectTransfer");
     // StartProjectTransfer
     Message::StartProjectTransfer sMStartProjectTransfer;
@@ -661,7 +645,7 @@ void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer &p
 
 /* NEW IMPLEMENTATION
 
-void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer* p_RequestProjectTransfer) {
+void SClient::parseRequestProjectTransfer(Message::RequestProjectTransfer* message) {
 //	ESP_LOGD(TAG, "parse RequestProjectTransfer");
     thread* o_ThreadSend;
     o_ThreadSend = new thread(&this->sendProject, this);
@@ -670,11 +654,11 @@ void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer* p
     // Message::EndProjectTransfer* ptrSMEndProjectTransfer;
     // int intCount;
     // SPITType* ptrSPITType;
-    // SPITObject* ptrSPITObject;
+    // SObject* ptrSPITObject;
 
 
     // //StartProjectTransfer
-    // NotifyStartProjectTransfer_Client* o_RunnableStart = new NotifyStartProjectTransfer_Client(m_SPITClientInterface);
+    // NotifyStartProjectTransfer_Client* o_RunnableStart = new NotifyStartProjectTransfer_Client(mSPITClientInterface);
     // SPIT_Handler::addRunnable(o_RunnableStart);
 
     // ptrSMStartProjectTransfer = new Message::StartProjectTransfer();
@@ -682,7 +666,7 @@ void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer* p
     // if (intResult < 0) {
     // 	return;
     // }
-    // m_Watchdog->answerWatchdog();
+    // mWatchdog->answerWatchdog();
     // {
     // 	//send all listes SPITTypes
     // 	unique_lock<recursive_mutex> o_LockType(*SPITType::getMutex());
@@ -692,20 +676,20 @@ void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer* p
     // 		if (ptrSPITType == nullptr) continue;
     // 		intResult = sendSPITTypeInternal(ptrSPITType);
     // 		if (intResult < 0) return;
-    // 		m_Watchdog->answerWatchdog();
+    // 		mWatchdog->answerWatchdog();
     // 		this_thread::sleep_for(chrono::milliseconds(7));
     // 	}
     // }
 
     // {
-    // 	unique_lock<recursive_mutex> o_LockObject(*SPITObject::getMutex());
+    // 	unique_lock<recursive_mutex> o_LockObject(*SObject::getMutex());
     // 	intCount = mSpitObjects.getEntryCount();
     // 	for (int i = 0; i < intCount; i++) {
     // 		ptrSPITObject = mSpitObjects.getEntry(i);
     // 		if (ptrSPITObject == nullptr) continue;
     // 		intResult = sendSPITObjectInternal(ptrSPITObject);
     // 		if (intResult < 0) return;
-    // 		m_Watchdog->answerWatchdog();
+    // 		mWatchdog->answerWatchdog();
     // 		this_thread::sleep_for(chrono::milliseconds(7));
     // 	}
     // }
@@ -716,21 +700,21 @@ void SPIT_Client::parseRequestProjectTransfer(Message::RequestProjectTransfer* p
     // if (intResult < 0) {
     // 	return;
     // }
-    // m_Watchdog->answerWatchdog();
-    // NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(m_SPITClientInterface);
+    // mWatchdog->answerWatchdog();
+    // NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(mSPITClientInterface);
     // SPIT_Handler::addRunnable(o_RunnableEnd);
 
     // //Send act
 }
 */
 
-void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
+void SClient::sendProject(SClient *p_PtrSPIT_Client) {
     // 	int intResult;
     // 	Message::StartProjectTransfer* ptrSMStartProjectTransfer;
     // 	Message::EndProjectTransfer* ptrSMEndProjectTransfer;
     // 	int intCount;
     // 	SPITType* ptrSPITType;
-    // 	SPITObject* ptrSPITObject;
+    // 	SObject* ptrSPITObject;
 
     // 	//StartProjectTransfer
     // 	NotifyStartProjectTransfer_Client* o_RunnableStart = new NotifyStartProjectTransfer_Client(p_PtrSPIT_Client->getSPITClientInterface());
@@ -742,7 +726,7 @@ void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
     // 		return;
     // 	}
 
-    // //	m_Watchdog->answerWatchdog();
+    // //	mWatchdog->answerWatchdog();
     // //	{
     // 		//send all listes SPITTypes
     // //		unique_lock<recursive_mutex> o_LockType(*SPITType::getMutex());
@@ -753,13 +737,13 @@ void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
     // 			if (ptrSPITType->getCreatedByClient() == false) continue;
     // 			intResult = p_PtrSPIT_Client->sendSPITTypeInternal(ptrSPITType);
     // 			if (intResult < 0) return;
-    // //			m_Watchdog->answerWatchdog();
+    // //			mWatchdog->answerWatchdog();
     // 			this_thread::sleep_for(chrono::milliseconds(7));
     // 		}
     // //	}
 
     // //	{
-    // //		unique_lock<recursive_mutex> o_LockObject(*SPITObject::getMutex());
+    // //		unique_lock<recursive_mutex> o_LockObject(*SObject::getMutex());
     // 		intCount = mSpitObjects.getEntryCount();
     // 		for (int i = 0; i < intCount; i++) {
     // 			ptrSPITObject = mSpitObjects.getEntry(i);
@@ -767,7 +751,7 @@ void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
     // 			if (ptrSPITObject->getCreatedByClient() == false) continue;
     // 			intResult = p_PtrSPIT_Client->sendSPITObjectInternal(ptrSPITObject);
     // 			if (intResult < 0) return;
-    // //			m_Watchdog->answerWatchdog();
+    // //			mWatchdog->answerWatchdog();
     // 			this_thread::sleep_for(chrono::milliseconds(7));
     // 		}
     // //	}
@@ -778,37 +762,37 @@ void SPIT_Client::sendProject(SPIT_Client *p_PtrSPIT_Client) {
     // 	if (intResult < 0) {
     // 		return;
     // 	}
-    // //	m_Watchdog->answerWatchdog();
+    // //	mWatchdog->answerWatchdog();
     // 	NotifyEndProjectTransfer_Client* o_RunnableEnd = new NotifyEndProjectTransfer_Client(p_PtrSPIT_Client->getSPITClientInterface());
     // 	SPIT_Handler::addRunnable(o_RunnableEnd);
 
     // 	//Send act
 }
 
-void SPIT_Client::parseStartProjectTransfer(Message::StartProjectTransfer &p_StartProjectTransfer) {
-    mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, m_ServerProjectID);
+void SClient::parseStartProjectTransfer(Message::StartProjectTransfer &message) {
+    mCallbacks.onProjectUpdate(ProjUpdate::StartTransfer, mServerProjectID);
 }
-void SPIT_Client::parseEndProjectTransfer(Message::EndProjectTransfer &p_EndProjectTransfer) {
-    SPITObject::clearUnconfirmedSPITObjects(mSpitObjects);
-    mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, m_ServerProjectID);
+void SClient::parseEndProjectTransfer(Message::EndProjectTransfer &message) {
+    SObject::clearUnconfirmedObjects(mSpitObjects);
+    mCallbacks.onProjectUpdate(ProjUpdate::EndTransfer, mServerProjectID);
 
-    // Send Message::ReportProject after the m_SPITClientInterface is notfied of EndProjectTransfer
-    Message::ReportProject reportSPITProject(m_ProjName, m_ProjName);
+    // Send Message::ReportProject after the mSPITClientInterface is notfied of EndProjectTransfer
+    Message::ReportProject reportSPITProject(mProjName, mProjName);
     reportSPITProject.setFramesPerSecond(0);
     if (sendSPITMessage(reportSPITProject) < 0) {
-        ESP_LOGD(TAG, "SPIT_Client::parseReportSPITProject could not send Client's ReportProject");
+        ESP_LOGD(TAG, "Client::parseReportProject could not send Client's ReportProject");
     }
 }
 
 //----- SPIT Types ------
-void SPIT_Client::parseReportSPITType(Message::ReportType &p_ReportSPITType) {
-    ESP_LOGD(TAG, "parse ReportType ID %s Name %s",p_ReportSPITType.getID().c_str(), p_ReportSPITType.getName().c_str());
-    SPITType *ptrSPITType;
+void SClient::parseReportSPITType(Message::ReportType &message) {
+    ESP_LOGD(TAG, "parse ReportType ID %s Name %s",message.getID().c_str(), message.getName().c_str());
+    SType *ptrSPITType;
     bool boolNew = false;
     bool boolChanged = false;
     {
-        if (p_ReportSPITType.getServerRemote() == false) {
-            ptrSPITType = mSpitTypes.getEntry(p_ReportSPITType.getID());
+        if (message.getServerRemote() == false) {
+            ptrSPITType = mSpitTypes.getEntry(message.getID());
             if (ptrSPITType == nullptr) {
                 // The user's app my veto the SPITType
                 bool createdByClient = false;
@@ -817,24 +801,24 @@ void SPIT_Client::parseReportSPITType(Message::ReportType &p_ReportSPITType) {
                 }
                 
                 if (mCallbacks.onCheckSpitTypeVeto(false, createdByClient) == false) {
-                    ESP_LOGW(TAG, "TypeVeto %s / %s", p_ReportSPITType.getID().c_str(), p_ReportSPITType.getName().c_str());
+                    ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
                     return;
                 }
-                auto spitType = make_unique<SPITType>(p_ReportSPITType.getID());
+                auto spitType = make_unique<SType>(message.getID());
                 ptrSPITType = spitType.get();
                 mSpitTypes.addEntry(move(spitType));
                 boolNew = true;
             }
         } else {
-            ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITType.getID());
+            ptrSPITType = mRemoteSpitTypes.getEntry(message.getID());
             if (ptrSPITType == nullptr) {
-                auto spitType = make_unique<SPITType>(p_ReportSPITType.getID());
+                auto spitType = make_unique<SType>(message.getID());
                 ptrSPITType = spitType.get();
                 mRemoteSpitTypes.addEntry(move(spitType));
                 boolNew = true;
             }
         }
-        if (!ptrSPITType->setMessageOP(p_ReportSPITType)) {
+        if (!ptrSPITType->setMessageOP(message)) {
             // SPITType is not changable -> send back to the server
             sendSPITTypeInternal(*ptrSPITType);
             return;
@@ -842,7 +826,7 @@ void SPIT_Client::parseReportSPITType(Message::ReportType &p_ReportSPITType) {
 
         auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
         // add or change SPITType
-        mCallbacks.onSpitType(eventType, ptrSPITType->getServerRemote(), *ptrSPITType);
+        mCallbacks.onSpitType(eventType, ptrSPITType->ServerRemote.get(), *ptrSPITType);
 
         if (ptrSPITType != nullptr) {
             if (ptrSPITType->setConfirmed(true) == true || boolChanged == true) {
@@ -851,12 +835,12 @@ void SPIT_Client::parseReportSPITType(Message::ReportType &p_ReportSPITType) {
         }
     }
 }
-void SPIT_Client::parseRemoveSPITType(Message::RemoveType &p_RemoveSPITType) {
-    ESP_LOGD(TAG, "parse RemoveType %s", p_RemoveSPITType.getID().c_str());
+void SClient::parseRemoveSPITType(Message::RemoveType &message) {
+    ESP_LOGD(TAG, "parse RemoveType %s", message.getID().c_str());
     bool boolRemote = false;
-    string stringSPITTypeID = p_RemoveSPITType.getID();
+    string stringSPITTypeID = message.getID();
 
-    SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(stringSPITTypeID);
+    SType *ptrSPITType = mRemoteSpitTypes.getEntry(stringSPITTypeID);
     if (!ptrSPITType) {
         boolRemote = true;
     } else {
@@ -869,7 +853,7 @@ void SPIT_Client::parseRemoveSPITType(Message::RemoveType &p_RemoveSPITType) {
         }
     }
 
-    if (ptrSPITType->getCreatedByClient() && ptrSPITType->getFixed()) {
+    if (ptrSPITType->getCreatedByClient() && ptrSPITType->Fixed.get()) {
         // the SPITyte is created by client himself and it is fixed -> don't remove the SPITType!!
         // Send the SPITTyp back to the server
         sendSPITTypeInternal(*ptrSPITType);
@@ -890,7 +874,7 @@ void SPIT_Client::parseRemoveSPITType(Message::RemoveType &p_RemoveSPITType) {
  * @param p_SPITType the pointer to the changed SPITType
  * @return 0 = is sended, -1 = is not sended
  */
-int SPIT_Client::sendSPITTypeInternal(SPITType &p_SPITType) {
+int SClient::sendSPITTypeInternal(SType &p_SPITType) {
     Message::ReportType sMReportSPITType;
     p_SPITType.fillMessageOP(sMReportSPITType);
     return sendSPITMessage(sMReportSPITType);
@@ -901,19 +885,19 @@ int SPIT_Client::sendSPITTypeInternal(SPITType &p_SPITType) {
  * @param p_SPITType the SPITType vont
  * @return true = changed, false = not changed maybe p_SPITType is NULL or the SPITType doesn't exists
  */
-bool SPIT_Client::changeSPITType(SPITType *p_SPITType) {
+bool SClient::changeSPITType(SType *p_SPITType) {
     if (p_SPITType == nullptr)
         return false;
-    SPITType *ptrSPITType = mSpitTypes.getEntry(p_SPITType->getID());
+    SType *ptrSPITType = mSpitTypes.getEntry(p_SPITType->getID());
     if (ptrSPITType == nullptr)
         return false;
 
-    ptrSPITType->setDefaultDelay(p_SPITType->getDefaultDelay());
-    ptrSPITType->setDefaultDuration(p_SPITType->getDefaultDuration());
-    ptrSPITType->setFixed(p_SPITType->getFixed());
-    ptrSPITType->setGroupName(p_SPITType->getGroupName());
-    ptrSPITType->setName(p_SPITType->getName());
-    ptrSPITType->setProjectIndepended(p_SPITType->getProjectIndepended());
+    ptrSPITType->DefaultDelay.set(p_SPITType->DefaultDelay.get());
+    ptrSPITType->DefaultDuration.set(p_SPITType->DefaultDuration.get());
+    ptrSPITType->Fixed.set(p_SPITType->Fixed.get());
+    ptrSPITType->GroupName.set(p_SPITType->GroupName.get());
+    ptrSPITType->Name.set(p_SPITType->Name.get());
+    ptrSPITType->ProjectIndepended.set(p_SPITType->ProjectIndepended.get());
 
     mCallbacks.onSpitType(ObjectEvent::Changed, false, *ptrSPITType);
     sendSPITTypeInternal(*ptrSPITType);
@@ -930,10 +914,10 @@ bool SPIT_Client::changeSPITType(SPITType *p_SPITType) {
  * @param p_SPITType the id of the SPITType ro remove
  * @return 0 = is sended, -1 = is not sended
  */
-int SPIT_Client::removeSPITType(string p_SPITTypeID) {
+int SClient::removeSPITType(string p_SPITTypeID) {
     if (p_SPITTypeID.length() <= 0)
         return -1;
-    SPITType *ptrSPITType;
+    SType *ptrSPITType;
     {
         ptrSPITType = mSpitTypes.getEntry(p_SPITTypeID);
         if (ptrSPITType == nullptr)
@@ -947,26 +931,26 @@ int SPIT_Client::removeSPITType(string p_SPITTypeID) {
     return -1;
 }
 
-SPITType *SPIT_Client::createSPITTypeFixed(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration) {
-    return createSPITType(p_ID, p_GroupName, p_Name, p_DefaultDelay, p_DefaultDuration, true, true);
+SType *SClient::createSPITTypeFixed(string iD, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration) {
+    return createSPITType(iD, p_GroupName, p_Name, p_DefaultDelay, p_DefaultDuration, true, true);
 }
 
-SPITType *SPIT_Client::createSPITType(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration, bool p_FIxed, bool p_ProjectIndepended) {
+SType *SClient::createSPITType(string p_ID, string p_GroupName, string p_Name, uint64_t p_DefaultDelay, uint64_t p_DefaultDuration, bool p_FIxed, bool p_ProjectIndepended) {
     bool boolNew;
-    SPITType *ptrSPITType = mSpitTypes.getEntry(p_ID);
+    SType *ptrSPITType = mSpitTypes.getEntry(p_ID);
     if (ptrSPITType == nullptr) {
-        auto spitType = make_unique<SPITType>(p_ID, p_GroupName, p_Name, p_FIxed, p_ProjectIndepended, p_DefaultDelay, p_DefaultDuration);
+        auto spitType = make_unique<SType>(p_ID, p_GroupName, p_Name, p_FIxed, p_ProjectIndepended, p_DefaultDelay, p_DefaultDuration);
         ptrSPITType = spitType.get();
         mSpitTypes.addEntry(move(spitType));
         ptrSPITType->setCreatedByClient(true);
         boolNew = true;
     } else {
-        ptrSPITType->setGroupName(p_GroupName);
-        ptrSPITType->setName(p_Name);
-        ptrSPITType->setFixed(p_FIxed);
-        ptrSPITType->setProjectIndepended(p_ProjectIndepended);
-        ptrSPITType->setDefaultDelay(p_DefaultDelay);
-        ptrSPITType->setDefaultDuration(p_DefaultDuration);
+        ptrSPITType->GroupName.set(p_GroupName);
+        ptrSPITType->Name.set(p_Name);
+        ptrSPITType->Fixed.set(p_FIxed);
+        ptrSPITType->ProjectIndepended.set(p_ProjectIndepended);
+        ptrSPITType->DefaultDelay.set(p_DefaultDelay);
+        ptrSPITType->DefaultDuration.set(p_DefaultDuration);
         boolNew = false;
     }
 
@@ -977,19 +961,19 @@ SPITType *SPIT_Client::createSPITType(string p_ID, string p_GroupName, string p_
 }
 
 //----- SPIT Objects ------
-void SPIT_Client::parseReportSPITObject(Message::ReportObject &p_ReportSPITObject) {
-    ESP_LOGD(TAG, "parse ReportObject %s", p_ReportSPITObject.getID().c_str());
-    SPITObject *ptrSPITObject;
-    SPITType *ptrSPITType;
+void SClient::parseReportSPITObject(Message::ReportObject &message) {
+    ESP_LOGD(TAG, "parse ReportObject %s", message.getID().c_str());
+    SObject *ptrSPITObject;
+    SType *ptrSPITType;
     bool boolNew = false;
     bool boolRemote = false;
     bool boolChanged = false;
     {
-        ESP_LOGD(TAG, "parse ReportObject %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
-        if (p_ReportSPITObject.getServerRemote() == false) {
+        ESP_LOGD(TAG, "parse ReportObject %s / %s", message.getID().c_str(), message.getName().c_str());
+        if (message.getServerRemote() == false) {
             boolRemote = false;
-            ptrSPITObject = mSpitObjects.getEntry(p_ReportSPITObject.getID());
-            ptrSPITType = mSpitTypes.getEntry(p_ReportSPITObject.getSPITTypeID());
+            ptrSPITObject = mSpitObjects.getEntry(message.getID());
+            ptrSPITType = mSpitTypes.getEntry(message.getSPITTypeID());
 
             if (ptrSPITType == nullptr) {
                 // No associated SPITType found
@@ -1004,10 +988,10 @@ void SPIT_Client::parseReportSPITObject(Message::ReportObject &p_ReportSPITObjec
             if (ptrSPITObject == nullptr) {
                 // The user's app my veto the SPITType
                 if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) {
-                    ESP_LOGW(TAG, "ObjectVeto %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
+                    ESP_LOGW(TAG, "ObjectVeto %s / %s", message.getID().c_str(), message.getName().c_str());
                     return;
                 }
-                auto spitObj = make_unique<SPITObject>(p_ReportSPITObject.getID());
+                auto spitObj = make_unique<SObject>(message.getID());
                 ptrSPITObject = spitObj.get();
                 mSpitObjects.addEntry(move(spitObj));
                 boolNew = true;
@@ -1016,27 +1000,27 @@ void SPIT_Client::parseReportSPITObject(Message::ReportObject &p_ReportSPITObjec
                 if (mCallbacks.onCheckSpitObjectVeto(isKnownType) == false) {
                     // SpitObject exists and User APp denied the SPITObject -> remove the SPITObject without sending a message
                     mSpitObjects.removeEntry(*ptrSPITObject);
-                    ESP_LOGW(TAG, "TypeVeto %s / %s", p_ReportSPITObject.getID().c_str(), p_ReportSPITObject.getName().c_str());
+                    ESP_LOGW(TAG, "TypeVeto %s / %s", message.getID().c_str(), message.getName().c_str());
                     return;
                 }
             }
         } else {
             boolRemote = true;
-            ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportSPITObject.getID());
-            ptrSPITType = mRemoteSpitTypes.getEntry(p_ReportSPITObject.getSPITTypeID());
+            ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
+            ptrSPITType = mRemoteSpitTypes.getEntry(message.getSPITTypeID());
             if (ptrSPITType == nullptr) {
                 // No associated SPITType found
                 return;
             }
             if (ptrSPITObject == nullptr) {
-                auto spitObj = make_unique<SPITObject>(p_ReportSPITObject.getID());
+                auto spitObj = make_unique<SObject>(message.getID());
                 ptrSPITObject = spitObj.get();
                 mRemoteSpitObjects.addEntry(move(spitObj));
                 boolNew = true;
             }
         }
 
-        if (!ptrSPITObject->setMessageOP(&p_ReportSPITObject)) {
+        if (!ptrSPITObject->setMessageOP(&message)) {
             ESP_LOGE(TAG, "Change not allowed");
             // setMessageOP error - the SPITObject can't be changed, it may be fixed and crated by this client
             sendSPITObjectInternal(ptrSPITObject);
@@ -1045,7 +1029,7 @@ void SPIT_Client::parseReportSPITObject(Message::ReportObject &p_ReportSPITObjec
 
         if (boolRemote == false) {
             // set the virtual action assignment
-            ptrSPITObject->setActionAssignedType(ptrSPITType->getActionAssigned());
+            ptrSPITObject->setActionAssignedType(ptrSPITType->ActionAssigned.get());
         }
 
         auto eventType = boolNew ? ObjectEvent::Created : ObjectEvent::Changed;
@@ -1057,22 +1041,22 @@ void SPIT_Client::parseReportSPITObject(Message::ReportObject &p_ReportSPITObjec
         }
     }
 }
-void SPIT_Client::parseRemoveSPITObject(Message::RemoveObject &p_RemoveSPITObject) {
-    ESP_LOGD(TAG, "parse RemoveObject %s", p_RemoveSPITObject.getID().c_str());
-    SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_RemoveSPITObject.getID());
+void SClient::parseRemoveSPITObject(Message::RemoveObject &message) {
+    ESP_LOGD(TAG, "parse RemoveObject %s", message.getID().c_str());
+    SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
     if (ptrSPITObject != nullptr) {
-        SPITType *ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
+        SType *ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
         if (ptrSPITType != nullptr) {
             mCallbacks.onSpitObject(ObjectEvent::Deleted, true, *ptrSPITType, *ptrSPITObject);
         }
         mRemoteSpitObjects.removeEntry(*ptrSPITObject);
     } else {
         // call removeSPITObject, this will notify the server that the object is removed
-        removeSPITObject(p_RemoveSPITObject.getID());
+        removeSPITObject(message.getID());
     }
 }
 
-int SPIT_Client::sendSPITObjectInternal(SPITObject *ptrSPITObject) {
+int SClient::sendSPITObjectInternal(SObject *ptrSPITObject) {
     if (ptrSPITObject == nullptr)
         return -1;
     Message::ReportObject sMReportSPITObject;
@@ -1084,39 +1068,39 @@ int SPIT_Client::sendSPITObjectInternal(SPITObject *ptrSPITObject) {
  * When the client changes an existing SPITObject (normally the client should not do this), then he should send the changes to the SPITServer.
  * An eventSPITObject occurs.
  * The SPITServer may discard the changes and a second eventSPITObject occurs to correct the changes.
- * @param p_SPITObject the pointer to the changed SPITObject.
+ * @param obj the pointer to the changed SPITObject.
  * CAUTION: The SPITObject must already exist.
- * @return true = SPITObject is changed, false = not changed, maybe p_SPITObject is NULL or the SPITObject doesn't exists
+ * @return true = SPITObject is changed, false = not changed, maybe obj is NULL or the SPITObject doesn't exists
  */
-bool SPIT_Client::changeSPITObject(SPITObject *p_SPITObject) {
-    if (p_SPITObject == nullptr)
+bool SClient::changeSPITObject(SObject *obj) {
+    if (obj == nullptr)
         return false;
-    SPITObject *ptrSPITObject;
-    SPITType *ptrSPITType;
+    SObject *ptrSPITObject;
+    SType *ptrSPITType;
     {
-        ptrSPITObject = mSpitObjects.getEntry(p_SPITObject->getID());
+        ptrSPITObject = mSpitObjects.getEntry(obj->getID());
         if (ptrSPITObject == nullptr)
             return false;
-        ptrSPITType = mSpitTypes.getEntry(p_SPITObject->getID());
+        ptrSPITType = mSpitTypes.getEntry(obj->getID());
         if (ptrSPITObject == nullptr)
             return false;
 
-        ptrSPITObject->setActionAssigned(p_SPITObject->getActionAssigned());
+        ptrSPITObject->setActionAssigned(obj->getActionAssigned());
         ;
-        ptrSPITObject->setDelay(p_SPITObject->getDelay());
-        ptrSPITObject->setDuration(p_SPITObject->getDelay());
-        ptrSPITObject->setFixed(p_SPITObject->getFixed());
-        ptrSPITObject->setFrameFadeInLength(p_SPITObject->getFrameFadeInLength());
-        ptrSPITObject->setFrameFadeOutLength(p_SPITObject->getFrameFadeOutLength());
-        ptrSPITObject->setFrameLength(p_SPITObject->getFrameLength());
-        ptrSPITObject->setFrameStart(p_SPITObject->getFrameStart());
-        ptrSPITObject->setName(p_SPITObject->getName());
-        ptrSPITObject->setRemark(p_SPITObject->getRemark());
-        ptrSPITObject->setSPITTypeID(p_SPITObject->getSPITTypeID());
-        ptrSPITObject->setServerParams(p_SPITObject->getServerParams());
-        ptrSPITObject->setTrack(p_SPITObject->getTrack());
-        ptrSPITObject->setValueFactor(p_SPITObject->getValueFactor());
-        ptrSPITObject->setValueUse(p_SPITObject->getValueUse());
+        ptrSPITObject->Delay.set(obj->Delay.get());
+        ptrSPITObject->Duration.set(obj->Delay.get());
+        ptrSPITObject->Fixed.set(obj->Fixed.get());
+        ptrSPITObject->FrameFadeInLength.set(obj->FrameFadeInLength.get());
+        ptrSPITObject->FrameFadeOutLength.set(obj->FrameFadeOutLength.get());
+        ptrSPITObject->FrameLength.set(obj->FrameLength.get());
+        ptrSPITObject->FrameStart.set(obj->FrameStart.get());
+        ptrSPITObject->Name.set(obj->Name.get());
+        ptrSPITObject->Remark.set(obj->Remark.get());
+        ptrSPITObject->SPITTypeID.set(obj->SPITTypeID.get());
+        ptrSPITObject->ServerParams.set(obj->ServerParams.get());
+        ptrSPITObject->Track.set(obj->Track.get());
+        ptrSPITObject->ValueFactor.set(obj->ValueFactor.get());
+        ptrSPITObject->ValueUse.set(obj->ValueUse.get());
 
         mCallbacks.onSpitObject(ObjectEvent::Changed, false, *ptrSPITType, *ptrSPITObject);
         sendSPITObjectInternal(ptrSPITObject);
@@ -1130,21 +1114,21 @@ bool SPIT_Client::changeSPITObject(SPITObject *p_SPITObject) {
  * An eventRemoveSPITType will occur.
  * If an connection to a SPITServer is established, the SPITServer may discard the deletion and an eventSPITObject occurs
  *  -> the SPITObject is listet again.
- * @param p_SPITObjectID the id of the SPITObject to remove.
- * @return 0 = sended to the SPITServer, -1 = not sended to the SPITServer or nos SPITObject with id == p_SPITObjectID exists.
+ * @param objId the id of the SPITObject to remove.
+ * @return 0 = sended to the SPITServer, -1 = not sended to the SPITServer or nos SPITObject with id == objId exists.
  */
-int SPIT_Client::removeSPITObject(string p_SPITObjectID) {
-    if (p_SPITObjectID.length() <= 0)
+int SClient::removeSPITObject(string objId) {
+    if (objId.length() <= 0)
         return -1;
-    SPITType *ptrSPITType;
-    SPITObject *ptrSPITObject;
+    SType *ptrSPITType;
+    SObject *ptrSPITObject;
     {
         Message::RemoveObject sMRemoveSPITObject;
 
-        ptrSPITObject = mSpitObjects.getEntry(p_SPITObjectID);
+        ptrSPITObject = mSpitObjects.getEntry(objId);
         if (ptrSPITObject == nullptr)
             return -1;
-        ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
+        ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
         if (ptrSPITType == nullptr)
             return -1;
         ptrSPITObject->fillMessageOP(sMRemoveSPITObject);
@@ -1157,42 +1141,42 @@ int SPIT_Client::removeSPITObject(string p_SPITObjectID) {
 
 //----- Play SPIT Objects ------
 
-void SPIT_Client::parsePlaySPITStart(Message::PlayStart &p_PlaySPITStart) {
-    ESP_LOGD(TAG, "parse PlayStart ID: %s Name: %s Running: %d", p_PlaySPITStart.getPlayerID().c_str(), p_PlaySPITStart.getPlayerName().c_str(), (int)p_PlaySPITStart.getPlayerIsRunning());
-    SPITPlayer &spitPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITStart.getPlayerID());
-    spitPlayer.setIsRunning(p_PlaySPITStart.getPlayerIsRunning());
-    spitPlayer.setName(p_PlaySPITStart.getPlayerName());
-    spitPlayer.setType(p_PlaySPITStart.getPlayerType());
-    spitPlayer.setTime(p_PlaySPITStart.getTime());
+void SClient::parsePlaySPITStart(Message::PlayStart &message) {
+    ESP_LOGD(TAG, "parse PlayStart ID: %s Name: %s Running: %d", message.getPlayerID().c_str(), message.getPlayerName().c_str(), (int)message.getPlayerIsRunning());
+    SPlayer &spitPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
+    spitPlayer.setIsRunning(message.getPlayerIsRunning());
+    spitPlayer.setName(message.getPlayerName());
+    spitPlayer.setType(message.getPlayerType());
+    spitPlayer.setTime(message.getTime());
     spitPlayer.startPlaySequence();
 
     mCallbacks.onPlay(spitPlayer.getID(), spitPlayer.getName(), spitPlayer.getType(), spitPlayer.getIsRunning(), spitPlayer.getTime());
 }
-void SPIT_Client::parsePlaySPITObject(Message::PlayObject &p_PlaySPITObject) {
+void SClient::parsePlaySPITObject(Message::PlayObject &message) {
 
-    SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITObject.getPlayerID());
-    SPITObject *ptrSPITObject = mSpitObjects.getEntry(p_PlaySPITObject.getSPITObjectID());
+    SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
+    SObject *ptrSPITObject = mSpitObjects.getEntry(message.getSPITObjectID());
 
     if (ptrSPITObject == nullptr) {
         return;
     }
-    SPITPlayer::PlaySPITType *ptrPlaySPITType = ptrSPITPlayer.addSPITType_Playing(ptrSPITObject->getSPITTypeID());
+    SPlayer::PlayType *ptrPlaySPITType = ptrSPITPlayer.addTypePlaying(ptrSPITObject->SPITTypeID.get());
     if (ptrPlaySPITType == nullptr) {
         return;
     }
     ptrPlaySPITType->setPlayerIsRunning(ptrSPITPlayer.getIsRunning());
-    ptrPlaySPITType->addValue(((double)p_PlaySPITObject.getValue() / 1000000), ((double)ptrSPITObject->getValueFactor() / 1000000));
+    ptrPlaySPITType->addValue(((double)message.getValue() / 1000000), ((double)ptrSPITObject->ValueFactor.get() / 1000000));
 }
 
-void SPIT_Client::parsePlaySPITEnd(Message::PlayEnd &p_PlaySPITEnd) {
-    SPITPlayer &ptrSPITPlayer = SPITPlayer::getSPITPlayer(p_PlaySPITEnd.getPlayerID());
+void SClient::parsePlaySPITEnd(Message::PlayEnd &message) {
+    SPlayer &ptrSPITPlayer = SPlayer::getSPITPlayer(message.getPlayerID());
 
     auto &ptrPlaySPITTypes = ptrSPITPlayer.getPlaySPITTypes();
     for (auto i = ptrPlaySPITTypes.begin(); i != ptrPlaySPITTypes.end(); i++) {
-        SPITPlayer::PlaySPITType *ptrPlaySPITType = i->second.get();
+        SPlayer::PlayType *ptrPlaySPITType = i->second.get();
         bool boolStarted = ptrPlaySPITType->getIsNew();
         bool boolStopped = (ptrPlaySPITType->getIsPlayed() == false);
-        SPITType *ptrSPITType = mSpitTypes.getEntry(ptrPlaySPITType->getSPITTypeID());
+        SType *ptrSPITType = mSpitTypes.getEntry(ptrPlaySPITType->getSPITTypeID());
         if (ptrSPITType == nullptr) {
             // set isplayed to false, the ptrPlayObject will be removed by ptrSPITPlayer.endPlaySequence()
             ptrPlaySPITType->setIsPlayed(false);
@@ -1203,26 +1187,26 @@ void SPIT_Client::parsePlaySPITEnd(Message::PlayEnd &p_PlaySPITEnd) {
     ptrSPITPlayer.endPlaySequence();
 }
 
-void SPIT_Client::parseReportPlayStatus(Message::ReportPlayStatus &p_ReportPlayStatus) {
-    SPITType *ptrSPITType = NULL;
+void SClient::parseReportPlayStatus(Message::ReportPlayStatus &message) {
+    SType *ptrSPITType = NULL;
 
-    SPITObject *ptrSPITObject = mRemoteSpitObjects.getEntry(p_ReportPlayStatus.getID());
+    SObject *ptrSPITObject = mRemoteSpitObjects.getEntry(message.getID());
     if (ptrSPITObject == nullptr) {
-        ptrSPITObject = mSpitObjects.getEntry(p_ReportPlayStatus.getID());
+        ptrSPITObject = mSpitObjects.getEntry(message.getID());
         if (ptrSPITObject == nullptr) {
             return;
         }
     }
-    if (ptrSPITObject->getServerRemote() == false) {
-        ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
+    if (ptrSPITObject->ServerRemote.get() == false) {
+        ptrSPITType = mSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
     } else {
-        ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->getSPITTypeID());
+        ptrSPITType = mRemoteSpitTypes.getEntry(ptrSPITObject->SPITTypeID.get());
     }
 
     if (ptrSPITType == nullptr) {
         return;
     }
-    mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, p_ReportPlayStatus.getFrameInsideObject(), p_ReportPlayStatus.getValue());
+    mCallbacks.onPlayRemoteObjectStatus(*ptrSPITType, *ptrSPITObject, message.getFrameInsideObject(), message.getValue());
 }
 
 //--------- Remote ----------
@@ -1233,20 +1217,20 @@ void SPIT_Client::parseReportPlayStatus(Message::ReportPlayStatus &p_ReportPlayS
  * 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
+ * @param 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:
+ * @param valueFlag indicates how the server should use valuePpm:
  * VALUEFLAG_DIRECT (0x00) The server overwrites its existing value with p_Value
- * VALUEFLAG_INCREASE (0x01) The server increases his existing value by p_Valueppm
- * VALUEFLAG_DECREASE (0x01) The server decreases his existing value by p_Valueppm
+ * VALUEFLAG_INCREASE (0x01) The server increases his existing value by valuePpm
+ * VALUEFLAG_DECREASE (0x01) The server decreases his existing value by valuePpm
  */
-void SPIT_Client::sendRemoteObject(string p_SPITObjectID, int p_Valueppm, char p_ValueFlag) {
-    SPITObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID);
+void SClient::sendRemoteObject(string p_SPITObjectID, int valuePpm, char valueFlag) {
+    SObject *ptrRemoteSPITObject = mRemoteSpitObjects.getEntry(p_SPITObjectID);
     if (ptrRemoteSPITObject == nullptr)
         return;
 
-    Message::PlayStart playSPITStart(m_ID, m_ProjName, PLAYERTYPE_DISCRETE);
+    Message::PlayStart playSPITStart(mID, mProjName, PLAYERTYPE_DISCRETE);
     playSPITStart.setPlayerIsRunning(false);
     playSPITStart.setTime(0);
     sendSPITMessage(playSPITStart);
@@ -1254,19 +1238,19 @@ void SPIT_Client::sendRemoteObject(string p_SPITObjectID, int p_Valueppm, char p
     Message::PlayObject playSPITObject;
     playSPITObject.setID(ptrRemoteSPITObject->getID());
     playSPITObject.setPlayPrePosition(false);
-    playSPITObject.setPlayerID(m_ID);
-    playSPITObject.setValue(p_Valueppm);
-    playSPITObject.setValueFlag(p_ValueFlag);
+    playSPITObject.setPlayerID(mID);
+    playSPITObject.setValue(valuePpm);
+    playSPITObject.setValueFlag(valueFlag);
     sendSPITMessage(playSPITObject);
 
-    Message::PlayEnd playSPITEnd(m_ID);
+    Message::PlayEnd playSPITEnd(mID);
     sendSPITMessage(playSPITEnd);
 }
 
-fos::Semaphore SPIT_Client::sStartSad;
-unordered_map<string, unique_ptr<SAD_DetectedServer>> SAD_DetectedServer::sKnownServers;
+fos::Semaphore SClient::sStartSad;
+unordered_map<string, unique_ptr<SadDetectedServer>> SadDetectedServer::sKnownServers;
 
-void SPIT_Client::processSocketTask(SPIT_Client &instance) {
+void SClient::processSocketTask(SClient &instance) {
     ESP_LOGI(TAG, "Starting Socket managing");
     static const string SERVERAUTODETECT_PRECODE = "#SAD#";
     static const string SERVERAUTODETECT_SEPERATOR = "#,#";
@@ -1277,16 +1261,16 @@ void SPIT_Client::processSocketTask(SPIT_Client &instance) {
     while (true) {
         sStartSad.take();
         bool searching = true;
-        instance.mSPITSocket->setBroadcast(true);
+        instance.mSocket.setBroadcast(true);
         string stringDatagram = SERVERAUTODETECT_PRECODE + SERVERAUTODETECT_SEPERATOR + SERVERAUTODETECT_TASKID;
         int intDatagramLength = stringDatagram.length();
         while (searching) {
             if (instance.mAbortSearch)
                 break;
 
-            SAD_DetectedServer::resetServerFlags();
-            string stringBroadcastIP4 = instance.mSPITSocket->mOwnIp.getBroadcastIP4();
-            instance.mSPITSocket->sendMessageTo(stringBroadcastIP4, SERVERAUTODETECT_PORT, stringDatagram.data(), intDatagramLength);
+            SadDetectedServer::resetServerFlags();
+            string stringBroadcastIP4 = instance.mSocket.mOwnIp.getBroadcastIP4();
+            instance.mSocket.sendMessageTo(stringBroadcastIP4, SERVERAUTODETECT_PORT, stringDatagram.data(), intDatagramLength);
             {
                 // wait for 3000 milliseconds or
                 fos::Task::delayMs(3000);
@@ -1300,7 +1284,7 @@ void SPIT_Client::processSocketTask(SPIT_Client &instance) {
                 constexpr int SIZE = 512;
                 char buffer[SIZE + 1];
                 string stringServerIP;
-                int intReceivedByteCount = instance.mSPITSocket->receiveMessage(buffer, SIZE, &stringServerIP);
+                int intReceivedByteCount = instance.mSocket.receiveMessage(buffer, SIZE, &stringServerIP);
                 if (intReceivedByteCount <= 0) {
                     break;
                 }
@@ -1315,7 +1299,7 @@ void SPIT_Client::processSocketTask(SPIT_Client &instance) {
                 string stringPart;
                 string strParts[10];
 
-                while (intIndex < SAD_DetectedServer::PARAMINDEX_IP) {
+                while (intIndex < SadDetectedServer::PARAM_IP) {
                     int intPos = stringMessage.find(SERVERAUTODETECT_SEPERATOR.data(), intOldPos);
                     if (intPos == string::npos) {
                         stringPart = "";
@@ -1327,26 +1311,26 @@ void SPIT_Client::processSocketTask(SPIT_Client &instance) {
                     intIndex++;
                 }
 
-                auto server = make_unique<SAD_DetectedServer>(
-                    strParts[SAD_DetectedServer::PARAMINDEX_NAME],
-                    strParts[SAD_DetectedServer::PARAMINDEX_ID],
-                    strParts[SAD_DetectedServer::PARAMINDEX_COMPUTERNAME],
+                auto server = make_unique<SadDetectedServer>(
+                    strParts[SadDetectedServer::PARAM_NAME],
+                    strParts[SadDetectedServer::PARAM_ID],
+                    strParts[SadDetectedServer::PARAM_COMPUTERNAME],
                     stringServerIP,
-                    strParts[SAD_DetectedServer::PARAMINDEX_PORT],
-                    strParts[SAD_DetectedServer::PARAMINDEX_CLIENTIP],
-                    strParts[SAD_DetectedServer::PARAMINDEX_ADDITIONS],
-                    strParts[SAD_DetectedServer::PARAMINDEX_SERVERPROJECTNAME]);
+                    strParts[SadDetectedServer::PARAM_PORT],
+                    strParts[SadDetectedServer::PARAM_CLIENTIP],
+                    strParts[SadDetectedServer::PARAM_ADDITIONS],
+                    strParts[SadDetectedServer::PARAM_SERVERPROJECTNAME]);
 
-                SAD_DetectedServer::addDetectedServer(move(server));
+                SadDetectedServer::addDetectedServer(move(server));
             }
             fos::Task::delayMs(100);
-            SAD_DetectedServer::evaluateDetectedServers(instance);
+            SadDetectedServer::evaluateDetectedServers(instance);
 
             instance.mAbortSearch = false;
-            // if(instance.m_ConnectionStatus == Connection::Ok) break;
+            // if(instance.mConnectionStatus == Connection::Ok) break;
             fos::Task::delayMs(1000);
         }
-        instance.mSPITSocket->setBroadcast(false);
+        instance.mSocket.setBroadcast(false);
 
         ESP_LOGW(TAG, "Finished searching");
         ESP_LOGW(TAG, "Start working");
@@ -1369,8 +1353,10 @@ void SPIT_Client::processSocketTask(SPIT_Client &instance) {
             //     nextWdCheck = nextWdTrigger + WATCHDOGTIME;
             // }
             fos::Task::delayMs(25);
-            // if (instance.m_StopReceiveSPITMessages)
+            // if (instance.mStopReceiveMessages)
             //     break;
         }
     }
+}
+
 }
\ No newline at end of file
diff --git a/components/spit/src/spit_message.cpp b/components/spit/src/spit_message.cpp
index 07b393d..3729786 100644
--- a/components/spit/src/spit_message.cpp
+++ b/components/spit/src/spit_message.cpp
@@ -1,18 +1,3 @@
-/*
- * 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.
- */
-
-/*
- * Message contains all SPIT messages.
- * A Message contains a Header and an OPPart.
- *
- * File:   Message.cpp
- * Author: Hagi
- *
- * Created on 3. April 2019, 08:51
- */
 
 #include "spit_message.hpp"
 
@@ -47,76 +32,76 @@ bool Message::parse(std::vector<char> message) {
     // parse OP
     switch (header->getType()) {
     case Message::Connect::OPFLAG: { // Connection
-        m_OPPart = make_unique<Connect>(move(header));
+        oPPart = make_unique<Connect>(move(header));
     } break;
     case Message::ConnectAnswer::OPFLAG: {
-        m_OPPart = make_unique<ConnectAnswer>(move(header));
+        oPPart = make_unique<ConnectAnswer>(move(header));
     } break;
     case Disconnect::OPFLAG: {
-        m_OPPart = make_unique<Disconnect>(move(header));
+        oPPart = make_unique<Disconnect>(move(header));
     } break;
     case Watchdog::OPFLAG: {
-        m_OPPart = make_unique<Watchdog>(move(header));
+        oPPart = make_unique<Watchdog>(move(header));
     } break;
     case WatchdogAnswer::OPFLAG: {
-        m_OPPart = make_unique<WatchdogAnswer>(move(header));
+        oPPart = make_unique<WatchdogAnswer>(move(header));
     } break;
     case ReportProject::OPFLAG: { // SpitProject
-        m_OPPart = make_unique<ReportProject>(move(header));
+        oPPart = make_unique<ReportProject>(move(header));
     } break;
     case CloseProject::OPFLAG: {
-        m_OPPart = make_unique<CloseProject>(move(header));
+        oPPart = make_unique<CloseProject>(move(header));
     } break;
     case RequestProjectTransfer::OPFLAG: {
-        m_OPPart = make_unique<RequestProjectTransfer>(move(header));
+        oPPart = make_unique<RequestProjectTransfer>(move(header));
     } break;
     case StartProjectTransfer::OPFLAG: {
-        m_OPPart = make_unique<StartProjectTransfer>(move(header));
+        oPPart = make_unique<StartProjectTransfer>(move(header));
     } break;
     case EndProjectTransfer::OPFLAG: {
-        m_OPPart = make_unique<EndProjectTransfer>(move(header));
+        oPPart = make_unique<EndProjectTransfer>(move(header));
     } break;
     case ReportType::OPFLAG: { // SpitType
-        m_OPPart = make_unique<ReportType>(move(header));
+        oPPart = make_unique<ReportType>(move(header));
     } break;
     case RemoveType::OPFLAG: {
-        m_OPPart = make_unique<RemoveType>(move(header));
+        oPPart = make_unique<RemoveType>(move(header));
     } break;
     case ReportObject::OPFLAG: { // SpitObject
-        m_OPPart = make_unique<ReportObject>(move(header));
+        oPPart = make_unique<ReportObject>(move(header));
     } break;
     case RemoveObject::OPFLAG: {
-        m_OPPart = make_unique<RemoveObject>(move(header));
+        oPPart = make_unique<RemoveObject>(move(header));
     } break;
     case PlayStart::OPFLAG: { // PlaySpitObjects
-        m_OPPart = make_unique<PlayStart>(move(header));
+        oPPart = make_unique<PlayStart>(move(header));
     } break;
     case PlayObject::OPFLAG: {
-        m_OPPart = make_unique<PlayObject>(move(header));
+        oPPart = make_unique<PlayObject>(move(header));
     } break;
     case PlayEnd::OPFLAG: {
-        m_OPPart = make_unique<PlayEnd>(move(header));
+        oPPart = make_unique<PlayEnd>(move(header));
     } break;
     case ReportPlayStatus::OPFLAG: {
-        m_OPPart = make_unique<ReportPlayStatus>(move(header));
+        oPPart = make_unique<ReportPlayStatus>(move(header));
     } break;
     default:
         return false;
     }
 
-    return m_OPPart->parse(message);
+    return oPPart->parse(message);
 }
 
 //---------- Send ----------
-std::vector<char> Message::createMessage(OPPart &p_OPPart) {
-    if (!p_OPPart.getHeader()) {
+std::vector<char> Message::createMessage(OPPart &oPPart) {
+    if (!oPPart.getHeader()) {
         return {};
     }
 
     try {
-        int totalSize = Header::BYTESLENGTH + p_OPPart.getBytesCount();
+        int totalSize = Header::BYTESLENGTH + oPPart.getBytesCount();
         std::vector<char> msgByts(totalSize);
-        p_OPPart.fillBytes(msgByts);
+        oPPart.fillBytes(msgByts);
         return msgByts;
     } catch (...) {
         ESP_LOGE(TAG, "Failed to allocate memory");
@@ -128,8 +113,8 @@ std::vector<char> Message::createMessage(OPPart &p_OPPart) {
 Message::Header::Header(const Header &orig) {
     mID = &SPITID[0];
     mMessageNumber = orig.getMessageNumber();
-    mServerID = orig.getServerID();
-    mClientID = orig.getClientID();
+    mServerId = orig.getServerID();
+    mClientId = orig.getClientID();
 }
 
 Message::Header::Header() {
@@ -152,8 +137,8 @@ bool Message::Header::parse(const std::vector<char> &message) {
         if (mBytesCount < 0) {
             return false;
         }
-        mServerID = getString(message, mParseOffset, 41).value();
-        mClientID = getString(message, mParseOffset, 41).value();
+        mServerId = getString(message, mParseOffset, 41).value();
+        mClientId = getString(message, mParseOffset, 41).value();
         mOpFlag = message[mParseOffset++] & 0xFF;
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse Header");
@@ -176,8 +161,8 @@ bool Message::Header::fillBytes(std::vector<char> &message) {
         mParseOffset += setInt(SPITVERSION, message, mParseOffset);
         mParseOffset += setByte(mMessageNumber, message, mParseOffset);
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(mServerID, message, mParseOffset, 41);
-        mParseOffset += setString(mClientID, message, mParseOffset, 41);
+        mParseOffset += setString(mServerId, message, mParseOffset, 41);
+        mParseOffset += setString(mClientId, message, mParseOffset, 41);
         mParseOffset += setByte(mOpFlag, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create Header");
@@ -226,12 +211,12 @@ bool Message::Connect::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_ClientComputerName = getString(message, mParseOffset, 64).value();
-        m_ClientName = getString(message, mParseOffset, 64).value();
-        m_LoginName = getString(message, mParseOffset, 64).value();
-        m_LoginPassword = getString(message, mParseOffset, 64).value();
-        m_ServerIP = getString(message, mParseOffset, 40).value();
-        m_ServerPort = getInt(message, mParseOffset).value();
+        mClientComputerName = getString(message, mParseOffset, 64).value();
+        mClientName = getString(message, mParseOffset, 64).value();
+        mLoginName = getString(message, mParseOffset, 64).value();
+        mLoginPassword = getString(message, mParseOffset, 64).value();
+        mServerIp = getString(message, mParseOffset, 40).value();
+        mServerPort = getInt(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse Connect message");
         return false;
@@ -240,17 +225,17 @@ bool Message::Connect::parse(const std::vector<char> &message) {
 }
 
 // Send
-Message::Connect::Connect(string p_ComputerName, string p_ClientName)
+Message::Connect::Connect(string pComputerName, string pClientName)
     : OPPart(BYTESLENGTH),
-      m_ClientComputerName(p_ComputerName),
-      m_ClientName(p_ClientName) {
+      mClientComputerName(pComputerName),
+      mClientName(pClientName) {
     setHeader(OPFLAG);
     mParseOffset = Header::BYTESLENGTH;
 }
 void Message::Connect::setServerPort(int p_ServerPort) {
     if (p_ServerPort < 0 || p_ServerPort > 65535)
         p_ServerPort = 0;
-    m_ServerPort = p_ServerPort;
+    mServerPort = p_ServerPort;
 }
 bool Message::Connect::fillBytes(std::vector<char> &message) {
     if (!mHeader) {
@@ -261,12 +246,12 @@ bool Message::Connect::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_ClientComputerName, message, mParseOffset, 64);
-        mParseOffset += setString(m_ClientName, message, mParseOffset, 64);
-        mParseOffset += setString(m_LoginName, message, mParseOffset, 64);
-        mParseOffset += setString(m_LoginPassword, message, mParseOffset, 64);
-        mParseOffset += setString(m_ServerIP, message, mParseOffset, 40);
-        mParseOffset += setInt(m_ServerPort, message, mParseOffset);
+        mParseOffset += setString(mClientComputerName, message, mParseOffset, 64);
+        mParseOffset += setString(mClientName, message, mParseOffset, 64);
+        mParseOffset += setString(mLoginName, message, mParseOffset, 64);
+        mParseOffset += setString(mLoginPassword, message, mParseOffset, 64);
+        mParseOffset += setString(mServerIp, message, mParseOffset, 40);
+        mParseOffset += setInt(mServerPort, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create Connect message");
         return false;
@@ -289,10 +274,10 @@ bool Message::ConnectAnswer::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_ServerComputerName = getString(message, mParseOffset, 64).value();
-        m_ServerName = getString(message, mParseOffset, 64).value();
-        m_StepTime = getInt(message, mParseOffset).value();
-        m_Connected = getBoolean(message, mParseOffset).value();
+        mServerComputerName = getString(message, mParseOffset, 64).value();
+        mServerName = getString(message, mParseOffset, 64).value();
+        mStepTime = getInt(message, mParseOffset).value();
+        mConnected = getBoolean(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse ConnectAnswer message");
         return false;
@@ -309,7 +294,7 @@ Message::ConnectAnswer::ConnectAnswer()
 void Message::ConnectAnswer::setStepTime(int p_StepTime_ms) {
     if (p_StepTime_ms < 0)
         p_StepTime_ms = 1;
-    m_StepTime = p_StepTime_ms;
+    mStepTime = p_StepTime_ms;
 }
 bool Message::ConnectAnswer::fillBytes(std::vector<char> &message) {
     if (!mHeader) {
@@ -320,10 +305,10 @@ bool Message::ConnectAnswer::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_ServerComputerName, message, mParseOffset, 64);
-        mParseOffset += setString(m_ServerName, message, mParseOffset, 64);
-        mParseOffset += setInt(m_StepTime, message, mParseOffset);
-        mParseOffset += setBoolean(m_Connected, message, mParseOffset);
+        mParseOffset += setString(mServerComputerName, message, mParseOffset, 64);
+        mParseOffset += setString(mServerName, message, mParseOffset, 64);
+        mParseOffset += setInt(mStepTime, message, mParseOffset);
+        mParseOffset += setBoolean(mConnected, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create ConnectAnswer message");
         return false;
@@ -478,9 +463,9 @@ bool Message::ReportProject::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_ProjectID = getString(message, mParseOffset, 41).value();
-        m_ProjectName = getString(message, mParseOffset, 64).value();
-        m_FramesPerSecond = getInt(message, mParseOffset).value();
+        mProjectID = getString(message, mParseOffset, 41).value();
+        mProjectName = getString(message, mParseOffset, 64).value();
+        mFramesPerSecond = getInt(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse ReportProject message");
         return false;
@@ -490,8 +475,8 @@ bool Message::ReportProject::parse(const std::vector<char> &message) {
 // Send
 Message::ReportProject::ReportProject(string p_ProjectID, string p_ProjectName)
     : OPPart(BYTESLENGTH),
-      m_ProjectID(p_ProjectID),
-      m_ProjectName(p_ProjectName) {
+      mProjectID(p_ProjectID),
+      mProjectName(p_ProjectName) {
     setHeader(OPFLAG);
     mParseOffset = Header::BYTESLENGTH;
 }
@@ -505,9 +490,9 @@ bool Message::ReportProject::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_ProjectID, message, mParseOffset, 41);
-        mParseOffset += setString(m_ProjectName, message, mParseOffset, 64);
-        mParseOffset += setInt(m_FramesPerSecond, message, mParseOffset);
+        mParseOffset += setString(mProjectID, message, mParseOffset, 41);
+        mParseOffset += setString(mProjectName, message, mParseOffset, 64);
+        mParseOffset += setInt(mFramesPerSecond, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create ReportProject message");
         return false;
@@ -531,7 +516,7 @@ bool Message::CloseProject::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_ProjectID = getString(message, mParseOffset, 41).value();
+        mProjectID = getString(message, mParseOffset, 41).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse CloseProject message");
         return false;
@@ -541,7 +526,7 @@ bool Message::CloseProject::parse(const std::vector<char> &message) {
 // Send
 Message::CloseProject::CloseProject(string projectID)
     : OPPart(BYTESLENGTH),
-      m_ProjectID(projectID) {
+      mProjectID(projectID) {
     setHeader(OPFLAG);
     mParseOffset = Header::BYTESLENGTH;
 }
@@ -555,7 +540,7 @@ bool Message::CloseProject::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_ProjectID, message, mParseOffset, 41);
+        mParseOffset += setString(mProjectID, message, mParseOffset, 41);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create CloseProject message");
         return false;
@@ -714,15 +699,15 @@ bool Message::ReportType::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_Confirmed = getBoolean(message, mParseOffset).value();
-        m_SPITTypeID = getString(message, mParseOffset, 41).value();
-        m_Fixed = getBoolean(message, mParseOffset).value();
-        m_ServerRemote = getBoolean(message, mParseOffset).value();
-        m_ServerProjectIndepended = getBoolean(message, mParseOffset).value();
-        m_SPITTypeGroupName = getString(message, mParseOffset, 39).value();
-        m_SPITTypeName = getString(message, mParseOffset, 64).value();
-        m_Delay = getLong(message, mParseOffset).value();
-        m_Duration = getLong(message, mParseOffset).value();
+        mConfirmed = getBoolean(message, mParseOffset).value();
+        mSPITTypeID = getString(message, mParseOffset, 41).value();
+        mFixed = getBoolean(message, mParseOffset).value();
+        mServerRemote = getBoolean(message, mParseOffset).value();
+        mServerProjectIndepended = getBoolean(message, mParseOffset).value();
+        mTypeGroupName = getString(message, mParseOffset, 39).value();
+        mSPITTypeName = getString(message, mParseOffset, 64).value();
+        mDelay = getLong(message, mParseOffset).value();
+        mDuration = getLong(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse ReportType message");
         return false;
@@ -745,15 +730,15 @@ bool Message::ReportType::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = mHeader->BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setBoolean(m_Confirmed, message, mParseOffset);
-        mParseOffset += setString(m_SPITTypeID, message, mParseOffset, 41);
-        mParseOffset += setBoolean(m_Fixed, message, mParseOffset);
-        mParseOffset += setBoolean(m_ServerRemote, message, mParseOffset);
-        mParseOffset += setBoolean(m_ServerProjectIndepended, message, mParseOffset);
-        mParseOffset += setString(m_SPITTypeGroupName, message, mParseOffset, 39);
-        mParseOffset += setString(m_SPITTypeName, message, mParseOffset, 64);
-        mParseOffset += setLong(m_Delay, message, mParseOffset);
-        mParseOffset += setLong(m_Duration, message, mParseOffset);
+        mParseOffset += setBoolean(mConfirmed, message, mParseOffset);
+        mParseOffset += setString(mSPITTypeID, message, mParseOffset, 41);
+        mParseOffset += setBoolean(mFixed, message, mParseOffset);
+        mParseOffset += setBoolean(mServerRemote, message, mParseOffset);
+        mParseOffset += setBoolean(mServerProjectIndepended, message, mParseOffset);
+        mParseOffset += setString(mTypeGroupName, message, mParseOffset, 39);
+        mParseOffset += setString(mSPITTypeName, message, mParseOffset, 64);
+        mParseOffset += setLong(mDelay, message, mParseOffset);
+        mParseOffset += setLong(mDuration, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create ReportType message");
         return false;
@@ -777,7 +762,7 @@ bool Message::RemoveType::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_SPITTypeID = getString(message, mParseOffset, 41).value();
+        mSPITTypeID = getString(message, mParseOffset, 41).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse RemoveType message");
         return false;
@@ -800,7 +785,7 @@ bool Message::RemoveType::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_SPITTypeID, message, mParseOffset, 41);
+        mParseOffset += setString(mSPITTypeID, message, mParseOffset, 41);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create RemoveType message");
         return false;
@@ -825,24 +810,24 @@ bool Message::ReportObject::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_Confirmed = getBoolean(message, mParseOffset).value();
-        m_SPITObjectID = getString(message, mParseOffset, 41).value();
-        m_Fixed = getBoolean(message, mParseOffset).value();
-        m_ServerRemote = getBoolean(message, mParseOffset).value();
-        m_SPITObjectName = getString(message, mParseOffset, 64).value();
-        m_SPITTypeID = getString(message, mParseOffset, 41).value();
-        m_ServerParams = getString(message, mParseOffset, 64).value();
-        m_FrameStart = getLong(message, mParseOffset).value();
-        m_FrameLength = getLong(message, mParseOffset).value();
-        m_FrameFadeInLength = getLong(message, mParseOffset).value();
-        m_FrameFadeOutLength = getLong(message, mParseOffset).value();
-        m_ValueFactor = getInt(message, mParseOffset).value();
-        m_ValueUse = getByte(message, mParseOffset).value();
-        m_Track = getInt(message, mParseOffset).value();
-        m_Remark = getString(message, mParseOffset, 64).value();
-        m_Delay = getLong(message, mParseOffset).value();
-        m_Duration = getLong(message, mParseOffset).value();
-        m_ActionAssigned = getBoolean(message, mParseOffset).value();
+        mConfirmed = getBoolean(message, mParseOffset).value();
+        mSPITObjectID = getString(message, mParseOffset, 41).value();
+        mFixed = getBoolean(message, mParseOffset).value();
+        mServerRemote = getBoolean(message, mParseOffset).value();
+        mSPITObjectName = getString(message, mParseOffset, 64).value();
+        mSPITTypeID = getString(message, mParseOffset, 41).value();
+        mServerParams = getString(message, mParseOffset, 64).value();
+        mFrameStart = getLong(message, mParseOffset).value();
+        mFrameLength = getLong(message, mParseOffset).value();
+        mFrameFadeInLength = getLong(message, mParseOffset).value();
+        mFrameFadeOutLength = getLong(message, mParseOffset).value();
+        mValueFactor = getInt(message, mParseOffset).value();
+        mValueUse = getByte(message, mParseOffset).value();
+        mTrack = getInt(message, mParseOffset).value();
+        mRemark = getString(message, mParseOffset, 64).value();
+        mDelay = getLong(message, mParseOffset).value();
+        mDuration = getLong(message, mParseOffset).value();
+        mActionAssigned = getBoolean(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse ReportObject message");
         return false;
@@ -858,12 +843,12 @@ Message::ReportObject::ReportObject() : OPPart(BYTESLENGTH) {
 void Message::ReportObject::setDelay(uint64_t p_Delay) {
     if (p_Delay < 0)
         p_Delay = 0;
-    m_Delay = p_Delay;
+    mDelay = p_Delay;
 }
 void Message::ReportObject::setDuration(uint64_t p_Duration) {
     if (p_Duration < 0)
         p_Duration = 0;
-    m_Duration = p_Duration;
+    mDuration = p_Duration;
 }
 
 bool Message::ReportObject::fillBytes(std::vector<char> &message) {
@@ -875,24 +860,24 @@ bool Message::ReportObject::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setBoolean(m_Confirmed, message, mParseOffset);
-        mParseOffset += setString(m_SPITObjectID, message, mParseOffset, 41);
-        mParseOffset += setBoolean(m_Fixed, message, mParseOffset);
-        mParseOffset += setBoolean(m_ServerRemote, message, mParseOffset);
-        mParseOffset += setString(m_SPITObjectName, message, mParseOffset, 64);
-        mParseOffset += setString(m_SPITTypeID, message, mParseOffset, 41);
-        mParseOffset += setString(m_ServerParams, message, mParseOffset, 64);
-        mParseOffset += setLong(m_FrameStart, message, mParseOffset);
-        mParseOffset += setLong(m_FrameLength, message, mParseOffset);
-        mParseOffset += setLong(m_FrameFadeInLength, message, mParseOffset);
-        mParseOffset += setLong(m_FrameFadeOutLength, message, mParseOffset);
-        mParseOffset += setInt(m_ValueFactor, message, mParseOffset);
-        mParseOffset += setByte(m_ValueUse, message, mParseOffset);
-        mParseOffset += setInt(m_Track, message, mParseOffset);
-        mParseOffset += setString(m_Remark, message, mParseOffset, 64);
-        mParseOffset += setLong(m_Delay, message, mParseOffset);
-        mParseOffset += setLong(m_Duration, message, mParseOffset);
-        mParseOffset += setBoolean(m_ActionAssigned, message, mParseOffset);
+        mParseOffset += setBoolean(mConfirmed, message, mParseOffset);
+        mParseOffset += setString(mSPITObjectID, message, mParseOffset, 41);
+        mParseOffset += setBoolean(mFixed, message, mParseOffset);
+        mParseOffset += setBoolean(mServerRemote, message, mParseOffset);
+        mParseOffset += setString(mSPITObjectName, message, mParseOffset, 64);
+        mParseOffset += setString(mSPITTypeID, message, mParseOffset, 41);
+        mParseOffset += setString(mServerParams, message, mParseOffset, 64);
+        mParseOffset += setLong(mFrameStart, message, mParseOffset);
+        mParseOffset += setLong(mFrameLength, message, mParseOffset);
+        mParseOffset += setLong(mFrameFadeInLength, message, mParseOffset);
+        mParseOffset += setLong(mFrameFadeOutLength, message, mParseOffset);
+        mParseOffset += setInt(mValueFactor, message, mParseOffset);
+        mParseOffset += setByte(mValueUse, message, mParseOffset);
+        mParseOffset += setInt(mTrack, message, mParseOffset);
+        mParseOffset += setString(mRemark, message, mParseOffset, 64);
+        mParseOffset += setLong(mDelay, message, mParseOffset);
+        mParseOffset += setLong(mDuration, message, mParseOffset);
+        mParseOffset += setBoolean(mActionAssigned, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create ReportObject message");
         return false;
@@ -915,7 +900,7 @@ bool Message::RemoveObject::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_SPITObjectID = getString(message, mParseOffset, 41).value();
+        mSPITObjectID = getString(message, mParseOffset, 41).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse RemoveObject message");
         return false;
@@ -938,7 +923,7 @@ bool Message::RemoveObject::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_SPITObjectID, message, mParseOffset, 41);
+        mParseOffset += setString(mSPITObjectID, message, mParseOffset, 41);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create RemoveObject message");
         return false;
@@ -963,11 +948,11 @@ bool Message::PlayStart::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_PlayerID = getString(message, mParseOffset, 41).value();
-        m_PlayerName = getString(message, mParseOffset, 64).value();
-        m_PlayerType = getByte(message, mParseOffset).value();
-        m_PlayerIsRunning = getBoolean(message, mParseOffset).value();
-        m_Time = getLong(message, mParseOffset).value();
+        mPlayerID = getString(message, mParseOffset, 41).value();
+        mPlayerName = getString(message, mParseOffset, 64).value();
+        mPlayerType = getByte(message, mParseOffset).value();
+        mPlayerIsRunning = getBoolean(message, mParseOffset).value();
+        mTime = getLong(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse PlayStart message");
         return false;
@@ -978,9 +963,9 @@ bool Message::PlayStart::parse(const std::vector<char> &message) {
 // Send
 Message::PlayStart::PlayStart(string p_PlayerID, string p_PlayerName, char p_PlayerType)
     : OPPart(BYTESLENGTH),
-      m_PlayerID(p_PlayerID),
-      m_PlayerName(p_PlayerName),
-      m_PlayerType(p_PlayerType) {
+      mPlayerID(p_PlayerID),
+      mPlayerName(p_PlayerName),
+      mPlayerType(p_PlayerType) {
     setHeader(OPFLAG);
     mParseOffset = Header::BYTESLENGTH;
 }
@@ -994,11 +979,11 @@ bool Message::PlayStart::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_PlayerID, message, mParseOffset, 41);
-        mParseOffset += setString(m_PlayerName, message, mParseOffset, 64);
-        mParseOffset += setByte(m_PlayerType, message, mParseOffset);
-        mParseOffset += setBoolean(m_PlayerIsRunning, message, mParseOffset);
-        mParseOffset += setLong(m_Time, message, mParseOffset);
+        mParseOffset += setString(mPlayerID, message, mParseOffset, 41);
+        mParseOffset += setString(mPlayerName, message, mParseOffset, 64);
+        mParseOffset += setByte(mPlayerType, message, mParseOffset);
+        mParseOffset += setBoolean(mPlayerIsRunning, message, mParseOffset);
+        mParseOffset += setLong(mTime, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create PlayStart message");
         return false;
@@ -1022,12 +1007,12 @@ bool Message::PlayObject::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_PlayerID = getString(message, mParseOffset, 41).value();
-        m_SPITObjectID = getString(message, mParseOffset, 41).value();
-        m_FrameInsideObject = getLong(message, mParseOffset).value();
-        m_PlayPrePosition = getBoolean(message, mParseOffset).value();
-        m_Value = getInt(message, mParseOffset).value();
-        m_ValueFlag = getByte(message, mParseOffset).value();
+        mPlayerID = getString(message, mParseOffset, 41).value();
+        mSPITObjectID = getString(message, mParseOffset, 41).value();
+        mFrameInsideObject = getLong(message, mParseOffset).value();
+        mPlayPrePosition = getBoolean(message, mParseOffset).value();
+        mValue = getInt(message, mParseOffset).value();
+        mValueFlag = getByte(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse PlayObject message");
         return false;
@@ -1049,12 +1034,12 @@ bool Message::PlayObject::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_PlayerID, message, mParseOffset, 41);
-        mParseOffset += setString(m_SPITObjectID, message, mParseOffset, 41);
-        mParseOffset += setLong(m_FrameInsideObject, message, mParseOffset);
-        mParseOffset += setBoolean(m_PlayPrePosition, message, mParseOffset);
-        mParseOffset += setInt(m_Value, message, mParseOffset);
-        mParseOffset += setByte(m_ValueFlag, message, mParseOffset);
+        mParseOffset += setString(mPlayerID, message, mParseOffset, 41);
+        mParseOffset += setString(mSPITObjectID, message, mParseOffset, 41);
+        mParseOffset += setLong(mFrameInsideObject, message, mParseOffset);
+        mParseOffset += setBoolean(mPlayPrePosition, message, mParseOffset);
+        mParseOffset += setInt(mValue, message, mParseOffset);
+        mParseOffset += setByte(mValueFlag, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create PlayObject message");
         return false;
@@ -1078,7 +1063,7 @@ bool Message::PlayEnd::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_PlayerID = getString(message, mParseOffset, 41).value();
+        mPlayerID = getString(message, mParseOffset, 41).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse PlayEnd message");
         return false;
@@ -1088,7 +1073,7 @@ bool Message::PlayEnd::parse(const std::vector<char> &message) {
 // Send
 Message::PlayEnd::PlayEnd(string p_PlayerID)
     : OPPart(BYTESLENGTH),
-      m_PlayerID(p_PlayerID) {
+      mPlayerID(p_PlayerID) {
     setHeader(OPFLAG);
     mParseOffset = Header::BYTESLENGTH;
 }
@@ -1102,7 +1087,7 @@ bool Message::PlayEnd::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_PlayerID, message, mParseOffset, 41);
+        mParseOffset += setString(mPlayerID, message, mParseOffset, 41);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create PlayEnd message");
         return false;
@@ -1126,9 +1111,9 @@ bool Message::ReportPlayStatus::parse(const std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mBytesCount = getInt(message, mParseOffset).value();
-        m_SPITObjectID = getString(message, mParseOffset, 41).value();
-        m_FrameInsideObject = getLong(message, mParseOffset).value();
-        m_Value = getInt(message, mParseOffset).value();
+        mSPITObjectID = getString(message, mParseOffset, 41).value();
+        mFrameInsideObject = getLong(message, mParseOffset).value();
+        mValue = getInt(message, mParseOffset).value();
     } catch (...) {
         ESP_LOGE(TAG, "failed to parse ReportPlayStatus message");
         return false;
@@ -1142,13 +1127,13 @@ Message::ReportPlayStatus::ReportPlayStatus() : OPPart(BYTESLENGTH) {
 }
 
 void Message::ReportPlayStatus::setID(string p_ID) {
-    m_SPITObjectID = p_ID;
+    mSPITObjectID = p_ID;
 }
 void Message::ReportPlayStatus::setFrameInsideObject(uint64_t p_TimeInside) {
-    m_FrameInsideObject = p_TimeInside;
+    mFrameInsideObject = p_TimeInside;
 }
 void Message::ReportPlayStatus::setValue(int p_Value) {
-    m_Value = p_Value;
+    mValue = p_Value;
 }
 bool Message::ReportPlayStatus::fillBytes(std::vector<char> &message) {
     if (!mHeader) {
@@ -1159,9 +1144,9 @@ bool Message::ReportPlayStatus::fillBytes(std::vector<char> &message) {
     try {
         mParseOffset = Header::BYTESLENGTH;
         mParseOffset += setInt(mBytesCount, message, mParseOffset);
-        mParseOffset += setString(m_SPITObjectID, message, mParseOffset, 41);
-        mParseOffset += setLong(m_FrameInsideObject, message, mParseOffset);
-        mParseOffset += setInt(m_Value, message, mParseOffset);
+        mParseOffset += setString(mSPITObjectID, message, mParseOffset, 41);
+        mParseOffset += setLong(mFrameInsideObject, message, mParseOffset);
+        mParseOffset += setInt(mValue, message, mParseOffset);
     } catch (...) {
         ESP_LOGE(TAG, "failed to create ReportPlayStatus message");
         return false;
diff --git a/components/spit/src/spit_object.cpp b/components/spit/src/spit_object.cpp
new file mode 100644
index 0000000..8e6dc1b
--- /dev/null
+++ b/components/spit/src/spit_object.cpp
@@ -0,0 +1,202 @@
+
+#include "spit_object.hpp"
+#include "spit_socket.hpp"
+#include "esp_log.h"
+
+namespace spit {
+
+/**
+ * clears all unconfirmed SObjects not created by this SPIT_Client.
+ */
+void SObject::clearUnconfirmedObjects(SpitRepo<SObject> &repo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end();) {
+        SObject *ptrSObject = i->second.get();
+        if (ptrSObject->getCreatedByClient() == false && ptrSObject->getConfirmed() == false) {
+            i = entries.erase(i);
+        } else {
+            i++;
+        }
+    }
+}
+
+void SObject::eventProjectClosed(SpitRepo<SObject> &repo, SpitRepo<SObject> &remoteRepo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end(); ) {
+        SObject *ptrSObject = i->second.get();
+        if (ptrSObject->getCreatedByClient() == true) {
+            i++;
+            continue;
+        }
+        i = entries.erase(i);
+    }
+    // Remote
+    remoteRepo.clearEntries();
+}
+
+/**
+ * sets confirmed = false for all SObjects.
+ * This should be called when the client has loaded a project.
+ */
+void SObject::setConfirmedFalse(SpitRepo<SObject> &repo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end(); i++) {
+        i->second->setConfirmed(false);
+    }
+}
+
+bool SObject::setMessageOP(Message::ReportObject *message) {
+    bool changeAllowed;
+
+    if ((mCreatedByClient == true) && (Fixed.mValue == true)) {
+        changeAllowed = false;
+    } else {
+        changeAllowed = true;
+    }
+
+    // Confirmation should be changable
+    if (mCreatedByClient) {
+        // Server reports a client created SPITType -> the type is confirmed
+        mConfirmed = true;
+    } else {
+        // type is NOT client created -> the client has to confirm the SPITtype
+        mConfirmed = message->getConfirmed();
+    }
+
+    if (changeAllowed == false) {
+        return false;
+    }
+    bool changed = false;
+    if (Delay.mValue != message->getDelay()) {
+        Delay.mValue = message->getDelay();
+        changed = true;
+    }
+    if (Duration.mValue != message->getDuration()) {
+        Duration.mValue = message->getDuration();
+        changed = true;
+    }
+    if (Fixed.mValue != message->getFixed()) {
+        Fixed.mValue = message->getFixed();
+        changed = true;
+    }
+    if (FrameFadeInLength.mValue != message->getFrameFadeInLength()) {
+        FrameFadeInLength.mValue = message->getFrameFadeInLength();
+        changed = true;
+    }
+    if (FrameFadeOutLength.mValue != message->getFrameFadeOutLength()) {
+        FrameFadeOutLength.mValue = message->getFrameFadeOutLength();
+        changed = true;
+    }
+    if (FrameLength.mValue != message->getFrameLength()) {
+        FrameLength.mValue = message->getFrameLength();
+        changed = true;
+    }
+    if (FrameStart.mValue != message->getFrameStart()) {
+        FrameStart.mValue = message->getFrameStart();
+        changed = true;
+    }
+    if (Remark.mValue != message->getRemark()) {
+        Remark.mValue = message->getRemark();
+        changed = true;
+    }
+    if (mID != message->getID()) {
+        mID = message->getID();
+        changed = true;
+    }
+    if (Name.mValue != message->getName()) {
+        Name.mValue = message->getName();
+        changed = true;
+    }
+    if (SPITTypeID.mValue != message->getSPITTypeID()) {
+        SPITTypeID.mValue = message->getSPITTypeID();
+        changed = true;
+    }
+    if (ServerParams.mValue != message->getServerParams()) {
+        ServerParams.mValue = message->getServerParams();
+        changed = true;
+    }
+    if (ServerRemote.mValue != message->getServerRemote()) {
+        ServerRemote.mValue = message->getServerRemote();
+        changed = true;
+    }
+    if (Track.mValue != message->getTrack()) {
+        Track.mValue = message->getTrack();
+        changed = true;
+    }
+    if (mValueFactor != message->getValueFactor()) {
+        mValueFactor = message->getValueFactor();
+        changed = true;
+    }
+    if (mValueUse != message->getValueUse()) {
+        mValueUse = message->getValueUse();
+        changed = true;
+    }
+    return changed;
+}
+
+void SObject::fillMessageOP(Message::ReportObject &message) {
+    message.setActionAssigned(getActionAssigned()); // Action can be assigned to type or to this object
+    message.setConfirmed(mConfirmed);
+    message.setDelay(Delay.mValue);
+    message.setDuration(Duration.mValue);
+    message.setFixed(Fixed.mValue);
+    message.setFrameFadeInLength(FrameFadeInLength.mValue);
+    message.setFrameFadeOutLength(FrameFadeOutLength.mValue);
+    message.setFrameLength(FrameLength.mValue);
+    message.setFrameStart(FrameStart.mValue);
+    message.setID(mID);
+    message.setName(Name.mValue);
+    message.setRemark(Remark.mValue);
+    message.setSPITTypeID(SPITTypeID.mValue);
+    message.setServerParams(ServerParams.mValue);
+    message.setServerRemote(ServerRemote.mValue);
+    message.setTrack(Track.mValue);
+    message.setValueFactor(mValueFactor);
+    message.setValueUse(mValueUse);
+}
+
+void SObject::fillMessageOP(Message::RemoveObject &message) {
+    message.setID(mID);
+}
+
+/**
+ * This is used by the server and client to tell if the other side has registered the changes.
+ * @param p_Confirmed
+ * @return if mConfirmed has changed
+ */
+bool SObject::setConfirmed(bool p_Confirmed) {
+    if (mConfirmed == p_Confirmed)
+        return false;
+    mConfirmed = p_Confirmed;
+    return true;
+}
+
+/**
+ * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
+ * This is used when an action is associated with a SPITType.
+ * Then this action is done for every SObject with the SPITType.
+ * @return true = an action is assigned for the SPITType.
+ */
+bool SObject::setActionAssignedType(bool p_ActionAssigned) {
+    if (mActionAssignedType == p_ActionAssigned)
+        return false;
+    bool oldActionAssigend = getActionAssigned();
+    mActionAssignedType = p_ActionAssigned;
+    if (getActionAssigned() == oldActionAssigend)
+        return false;
+    mConfirmed = false;
+    return true;
+}
+
+bool SObject::setActionAssigned(bool p_ActionAssigned) {
+    if (mActionAssigned == p_ActionAssigned)
+        return false;
+    bool oldActionAssigend = getActionAssigned();
+    mActionAssigned = p_ActionAssigned;
+    if (getActionAssigned() == oldActionAssigend)
+        return false;
+    mConfirmed = false;
+    return true;
+}
+
+}
diff --git a/components/spit/src/spit_player.cpp b/components/spit/src/spit_player.cpp
new file mode 100644
index 0000000..833d438
--- /dev/null
+++ b/components/spit/src/spit_player.cpp
@@ -0,0 +1,93 @@
+
+#include "spit_player.hpp"
+#include "esp_log.h"
+#include <memory>
+#include <vector>
+
+using namespace std;
+
+namespace spit {
+
+unordered_map<string, unique_ptr<SPlayer>> SPlayer::sSpitPlayers;
+
+SPlayer &SPlayer::getSPITPlayer(string playerID) {
+    auto i = sSpitPlayers.find(playerID);
+    if (i == sSpitPlayers.end()) {
+        sSpitPlayers[playerID] = make_unique<SPlayer>(playerID);
+    }
+    return *sSpitPlayers.at(playerID);
+}
+
+SPlayer::SPlayer(string playerID) {
+    mId = playerID;
+}
+
+SPlayer::~SPlayer() {
+    mPlaySPITTypes.clear();
+}
+
+/**
+ *
+ * @param p_SPITObjectID
+ * @return true = new PlayObject added<br>
+ * false = PlayObject exists
+ */
+SPlayer::PlayType *SPlayer::addTypePlaying(string spitTypeID) {
+    PlayType *ptrPlaySPITType;
+    auto i = mPlaySPITTypes.find(spitTypeID);
+    if (i == mPlaySPITTypes.end()) {
+        auto playSpitType = make_unique<PlayType>(this, spitTypeID);
+        ptrPlaySPITType = playSpitType.get();
+        mPlaySPITTypes[spitTypeID] = move(playSpitType);
+    } else {
+        ptrPlaySPITType = i->second.get();
+    }
+    ptrPlaySPITType->setIsPlayed(true);
+    return ptrPlaySPITType;
+}
+
+void SPlayer::startPlaySequence() {
+    for (auto i = mPlaySPITTypes.begin(); i != mPlaySPITTypes.end(); i++) {
+        PlayType *ptrPlaySPITType = i->second.get();
+        ptrPlaySPITType->startPlaySequence();
+    }
+}
+
+void SPlayer::endPlaySequence() {
+    for (auto i = mPlaySPITTypes.begin(); i != mPlaySPITTypes.end();) {
+        if (i->second.get()->getIsPlayed() == false) {
+            i = mPlaySPITTypes.erase(i);
+        } else {
+            ++i;
+        }
+    }
+}
+
+SPlayer::PlayType::PlayType(SPlayer *p_SPITPlayer, string spitTypeID) {
+    mIsNew = true;
+
+    mSpitTypeID = spitTypeID;
+    mPlayerID = p_SPITPlayer->getID();
+    mPlayerName = p_SPITPlayer->getName();
+    startPlaySequence();
+    mIsNew = true;
+}
+SPlayer::PlayType::PlayType(const PlayType &orig) {
+    mSpitTypeID = orig.getSPITTypeID();
+    mIsPlayed = orig.getIsPlayed();
+    mIsNew = orig.getIsNew();
+
+    mPlayerID = orig.getPlayerID();
+    mPlayerName = orig.getPlayerName();
+    mPlayerRuns = orig.getPlayerIsRunning();
+
+    mValue = orig.getValue();
+}
+void SPlayer::PlayType::startPlaySequence() {
+    mIsPlayed = false;
+    mIsNew = false;
+
+    mValue = 0;
+}
+
+}
\ No newline at end of file
diff --git a/components/spit/src/SPITSocket.cpp b/components/spit/src/spit_socket.cpp
similarity index 70%
rename from components/spit/src/SPITSocket.cpp
rename to components/spit/src/spit_socket.cpp
index 10cd6b2..6e72f8d 100644
--- a/components/spit/src/SPITSocket.cpp
+++ b/components/spit/src/spit_socket.cpp
@@ -1,45 +1,33 @@
-/*
- * 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.
- */
-
-/*
- * Unix implementation of a SPITSocket.
- *
- * File:   UnixSocket.cpp
- * Author: Hagi
- *
- * Created on 12. April 2019, 15:58
- */
-
-#include "SPITSocket.h"
+#include "spit_socket.hpp"
 #include "Task.hpp"
 #include "esp/uuid.h"
 #include "esp_log.h"
 #include "esp_netif.h"
 #include <string>
 #include <unistd.h>
+
 using namespace std;
 
+namespace spit {
+
 /**
  * Creates socket. If there exist some, they will be closed.
  * @return
  */
-bool SPITSocket::createSocket_UDP() {
-    if (m_UDPSocketIP4 != INVALID_SOCKET) {
-        close(m_UDPSocketIP4);
-        m_UDPSocketIP4 = INVALID_SOCKET;
+bool Socket::createSocketUdp() {
+    if (mUdpSocketIp4 != INVALID_SOCKET) {
+        close(mUdpSocketIp4);
+        mUdpSocketIp4 = INVALID_SOCKET;
     }
 
-    m_UDPSocketIP4 = socket(AF_INET, SOCK_DGRAM, 0);
+    mUdpSocketIp4 = socket(AF_INET, SOCK_DGRAM, 0);
     int intResult = -1;
     bool success = true;
-    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+    if (mUdpSocketIp4 == INVALID_SOCKET) {
         success = false;
     } else {
         int intOptionValue4 = 1;
-        intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_REUSEADDR, (void *)&intOptionValue4, sizeof(intOptionValue4));
+        intResult = setsockopt(mUdpSocketIp4, SOL_SOCKET, SO_REUSEADDR, (void *)&intOptionValue4, sizeof(intOptionValue4));
     }
     if (intResult < 0) {
         success = false;
@@ -50,17 +38,17 @@ bool SPITSocket::createSocket_UDP() {
         tv.tv_sec = 1;  // seconds
         tv.tv_usec = 0; // microseconds (0.0 sec)
         // This sets the receive timeout
-        setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+        setsockopt(mUdpSocketIp4, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
-        // set the m_UDPSocketIP4 in NON BLOCKING mode because
+        // set the mUdpSocketIp4 in NON BLOCKING mode because
         // if the UDPSockets are in blocking mode the receiveMessage does not return in every constellation
         // int intFlags;
-        // intFlags = fcntl(m_UDPSocketIP4, F_GETFL);
-        // fcntl(m_UDPSocketIP4, F_SETFL, intFlags | O_NONBLOCK);
+        // intFlags = fcntl(mUdpSocketIp4, F_GETFL);
+        // fcntl(mUdpSocketIp4, F_SETFL, intFlags | O_NONBLOCK);
 
         // int intBufferSize = 2046 * 512;
-        // intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_RCVBUF, (void*)&intBufferSize, sizeof(intBufferSize));
-        // intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_SNDBUF, (void*)&intBufferSize, sizeof(intBufferSize));
+        // intResult = setsockopt(mUdpSocketIp4, SOL_SOCKET, SO_RCVBUF, (void*)&intBufferSize, sizeof(intBufferSize));
+        // intResult = setsockopt(mUdpSocketIp4, SOL_SOCKET, SO_SNDBUF, (void*)&intBufferSize, sizeof(intBufferSize));
     }
     return success;
 }
@@ -73,7 +61,7 @@ bool SPITSocket::createSocket_UDP() {
  * @return -1 id bind fails, o if bind is ok
  *
  */
-int SPITSocket::bindSocket(string clientIp, string clientPort) {
+int Socket::bindSocket(string clientIp, string clientPort) {
     string stringClientPort;
     if (clientPort.length() <= 0)
         stringClientPort = "0";
@@ -83,7 +71,7 @@ int SPITSocket::bindSocket(string clientIp, string clientPort) {
     if (getaddrinfo(clientIp.data(), clientPort.data(), nullptr, &clientAI) != 0) {
         return -1;
     }
-    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+    if (mUdpSocketIp4 == INVALID_SOCKET) {
         return -1;
     }
     auto *socketAdr = (sockaddr_in *)(clientAI->ai_addr);
@@ -94,12 +82,12 @@ int SPITSocket::bindSocket(string clientIp, string clientPort) {
     o_IP4SocketAddress.sin_addr = socketAdr->sin_addr;
     o_IP4SocketAddress.sin_family = socketAdr->sin_family;
     o_IP4SocketAddress.sin_port = socketAdr->sin_port;
-    int intResult = bind(m_UDPSocketIP4, (const sockaddr *)(socketAdr), (socklen_t)intSocklen);
+    int intResult = bind(mUdpSocketIp4, (const sockaddr *)(socketAdr), (socklen_t)intSocklen);
     if (intResult < 0) {
         return intResult;
     }
     if ((intResult == 0) &&
-        (getsockname(m_UDPSocketIP4, (sockaddr *)socketAdr, (socklen_t *)&intSocklen) != -1)) {
+        (getsockname(mUdpSocketIp4, (sockaddr *)socketAdr, (socklen_t *)&intSocklen) != -1)) {
         setBoundClientPort(to_string((int)socketAdr->sin_port));
     }
     freeaddrinfo(clientAI);
@@ -114,9 +102,9 @@ int SPITSocket::bindSocket(string clientIp, string clientPort) {
  * false = SO_BROADCAST is not set
  * @return 0 = ok, -1 = error
  */
-int SPITSocket::setBroadcast(bool broadcast) const {
+int Socket::setBroadcast(bool broadcast) const {
     int intOptionValue = broadcast ? 1 : 0;
-    int intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_BROADCAST, &intOptionValue, sizeof(int));
+    int intResult = setsockopt(mUdpSocketIp4, SOL_SOCKET, SO_BROADCAST, &intOptionValue, sizeof(int));
     return intResult;
 }
 /**
@@ -127,8 +115,8 @@ int SPITSocket::setBroadcast(bool broadcast) const {
  * @return -1 send fails
  * 0 send is done
  */
-int SPITSocket::sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) {
-    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+int Socket::sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) {
+    if (mUdpSocketIp4 == INVALID_SOCKET) {
         return -1;
     }
 
@@ -141,14 +129,14 @@ int SPITSocket::sendMessageTo(const string &ip, const string &port, const char *
 
     auto *ptrIP4SocketAddress = (sockaddr_in *)(ptrAddressInfo->ai_addr);
     int intSocklen = sizeof(*ptrIP4SocketAddress);
-    if (m_UDPSocketIP4 != INVALID_SOCKET) {
+    if (mUdpSocketIp4 != INVALID_SOCKET) {
         // copy the ptrIP4SocketAddress, may be not filled correct by getaddrinfo
         sockaddr_in o_IP4SocketAddress;
         memset(&o_IP4SocketAddress, 0, intSocklen);
         o_IP4SocketAddress.sin_addr = ptrIP4SocketAddress->sin_addr;
         o_IP4SocketAddress.sin_family = ptrIP4SocketAddress->sin_family;
         o_IP4SocketAddress.sin_port = ptrIP4SocketAddress->sin_port;
-        intResult = sendto(m_UDPSocketIP4, message, msgLength, 0, (const sockaddr *)&o_IP4SocketAddress, (socklen_t)intSocklen);
+        intResult = sendto(mUdpSocketIp4, message, msgLength, 0, (const sockaddr *)&o_IP4SocketAddress, (socklen_t)intSocklen);
         if (intResult < 0) {
             ESP_LOGE("SPIT", "sendMessageTo IP4 sendto %s FAILED %s\n", ip.data(), strerror(errno));
             ESP_LOGE("SPIT", "sendMessageTo ret=%d %s / %s / %d\n", intResult, port.data(), message, msgLength);
@@ -169,15 +157,15 @@ int SPITSocket::sendMessageTo(const string &ip, const string &port, const char *
  * if p_ServerIP is NULL - no detection of the server will be done.
  * @return
  */
-int SPITSocket::receiveMessage(char *p_Buffer, int p_BufferLength, string *serverIp) const {
+int Socket::receiveMessage(char *p_Buffer, int p_BufferLength, string *serverIp) const {
     int intResult = -1;
-    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+    if (mUdpSocketIp4 == INVALID_SOCKET) {
         return intResult;
     }
     sockaddr_in o_IP4SocketAddress;
     int 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(mUdpSocketIp4, (void *)p_Buffer, p_BufferLength, 0, (sockaddr *)&o_IP4SocketAddress, (socklen_t *)&intSocklen);
     if (intResult >= 0 && serverIp != nullptr) {
         char bufferIP4[INET_ADDRSTRLEN];
         inet_ntop(AF_INET, &(o_IP4SocketAddress.sin_addr), bufferIP4, intSocklen);
@@ -186,7 +174,7 @@ int SPITSocket::receiveMessage(char *p_Buffer, int p_BufferLength, string *serve
     return intResult;
 }
 
-SPITSocket::IPAddress SPITSocket::getAdaptersInfo() {
+ISocket::IpAddress Socket::getAdaptersInfo() {
     // iterate over active interfaces, and print out IPs
     esp_netif_t *netif = nullptr;
     if ((netif = esp_netif_next_unsafe(netif)) != nullptr) {
@@ -221,3 +209,5 @@ string getClientHostName() {
     }
     return "";
 }
+
+}
\ No newline at end of file
diff --git a/components/spit/uTest/spitClientTest.cpp b/components/spit/uTest/spitClientTest.cpp
new file mode 100644
index 0000000..55dc430
--- /dev/null
+++ b/components/spit/uTest/spitClientTest.cpp
@@ -0,0 +1,79 @@
+/**
+ * @file spitRepoTest.cpp
+ * @author Gustice
+ * @brief
+ */
+
+#include "doctest/doctest.h"
+#include <fmt/core.h>
+#include <iostream>
+
+#include "spit_client.hpp"
+
+using namespace spit;
+using namespace std;
+
+class ClientMock {
+    public:
+    void onServerEvent(SClient::ServerEvent event, const SadDetectedServer &detectedServer) {
+    }
+    void onConnectionStatus(string serverID, string serverComputerName, string serverName, int serverStepTime, SClient::Connection connectionStatus, SClient::Connection oldConnectionStatus) {
+    }
+    void onProjectUpdate(SClient::ProjUpdate state, string projectId) {
+    }
+    void onSpitType(SClient::ObjectEvent event, bool isRemote, const SType &spitType) {
+    }
+    void onSpitObject(SClient::ObjectEvent event, bool isRemote, const SType &spitType, const SObject &spitObject) {
+    }
+    void onPlay(string playerID, string playerName, char playerType, bool playerIsRunning, uint64_t timeFrames) {
+    }
+    void onPlaySpitType(string playerID, string spitTypeID, bool playerIsRunning, bool started, bool ended, double value) {
+    }
+    void onPlayRemoteObjectStatus(const SType &spitType, const SObject &spitObject, uint64_t p_FrameInsideObject, int value) {
+    }
+    bool onCheckSpitTypeVeto(bool knownType, bool createdByClient) {
+    }
+    bool onCheckSpitObjectVeto(bool knownType) {
+    }
+};
+
+class SocketMock : public ISocket {
+    public:
+    SocketMock(IpAddress ip) : ISocket(ip) {}
+
+    int sendMessage(const char *message, int length) override {
+    }
+    int receiveMessage(char *bu1ffer, int bufferLength, string *serverIp) const override {
+    }
+    void setConnectionParams(const string &serverIp, const string &serverPort, const string &clientIp, const string &clientPort) override {
+    }
+    int bindSocket(string clientIp, string clientPort) override {
+    }
+    int setBroadcast(bool broadcast) const override {
+    }
+    int sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) override {
+    }
+};
+
+class SpitClientFix {
+  protected:
+    static ClientMock client;
+    ISocket::IpAddress ip{"10.10.0.1", "255.255.255.0"};
+    SocketMock socket{ip};
+    SClient::Callbacks callbacks{
+        .onServerEvent = [&](SClient::ServerEvent event, const SadDetectedServer &detectedServer){client.onServerEvent(event, detectedServer);} ,
+        .onConnectionStatus = [&](string serverID, string serverComputerName, string serverName, int serverStepTime, SClient::Connection connectionStatus, SClient::Connection oldConnectionStatus){client.onConnectionStatus(serverID, serverComputerName, serverName, serverStepTime, connectionStatus, oldConnectionStatus);} ,
+        .onProjectUpdate = [&](SClient::ProjUpdate state, string projectId){client.onProjectUpdate(state, projectId);} ,
+        .onSpitType = [&](SClient::ObjectEvent event, bool isRemote, const SType &spitType){client.onSpitType(event, isRemote, spitType);} ,
+        .onSpitObject = [&](SClient::ObjectEvent event, bool isRemote, const SType &spitType, const SObject &spitObject){client.onSpitObject(event, isRemote, spitType, spitObject);} ,
+        .onPlay = [&](string playerID, string playerName, char playerType, bool playerIsRunning, uint64_t timeFrames){client.onPlay(playerID, playerName, playerType, playerIsRunning, timeFrames);} ,
+        .onPlaySpitType = [&](string playerID, string spitTypeID, bool playerIsRunning, bool started, bool ended, double value){client.onPlaySpitType(playerID, spitTypeID, playerIsRunning, started, ended, value);} ,
+        .onPlayRemoteObjectStatus = [&](const SType &spitType, const SObject &spitObject, uint64_t p_FrameInsideObject, int value){client.onPlayRemoteObjectStatus( spitType,  spitObject, p_FrameInsideObject, value);} ,
+        .onCheckSpitTypeVeto = [&](bool knownType, bool createdByClient){return client.onCheckSpitTypeVeto(knownType, createdByClient);} ,
+        .onCheckSpitObjectVeto = [&](bool knownType){return client.onCheckSpitObjectVeto(knownType);}
+    };
+    SClient sut{"sut", "sutProj", socket, callbacks};
+};
+
+TEST_CASE_FIXTURE(SpitClientFix, "Typical use case") {
+}
diff --git a/components/spit/uTest/spitObjectTest.cpp b/components/spit/uTest/spitObjectTest.cpp
new file mode 100644
index 0000000..137cfd1
--- /dev/null
+++ b/components/spit/uTest/spitObjectTest.cpp
@@ -0,0 +1,92 @@
+/**
+ * @file spitRepoTest.cpp
+ * @author Gustice
+ * @brief
+ */
+
+#include "doctest/doctest.h"
+#include <fmt/core.h>
+#include <iostream>
+
+#include "spit_object.hpp"
+
+using namespace spit;
+using namespace std;
+
+class SpitObjectFix {
+  protected:
+};
+
+TEST_CASE_FIXTURE(SpitObjectFix, "Typical use case") {
+    {
+        SObject sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Name.set("G123") == true);
+        CHECK(sut.Name.get() == "G123");
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Name.set("G123") == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Name.set("G321") == true);
+        CHECK(sut.Name.get() == "G321");
+        CHECK(sut.getConfirmed() == false);
+    }
+    {
+        SObject sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(true) == true);
+        CHECK(sut.Fixed.get() == true);
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(true) == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(false) == true);
+        CHECK(sut.Fixed.get() == false);
+        CHECK(sut.getConfirmed() == false);
+    }
+    {
+        SObject sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.FrameLength.set(123) == true);
+        CHECK(sut.FrameLength.get() == 123);
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.FrameLength.set(123) == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.FrameLength.set(321) == true);
+        CHECK(sut.FrameLength.get() == 321);
+        CHECK(sut.getConfirmed() == false);
+    }
+    // ...
+
+    // {
+    //     SObject sut("#Id#123", "grp123", "name123", true, false, 1234, 4321);
+    //     CHECK(sut.getID() == "#Id#123");
+    //     CHECK(sut.GroupName.get() == "grp123");
+    //     CHECK(sut.Name.get() == "name123");
+    //     CHECK(sut.Fixed.get() == true);
+    //     CHECK(sut.ProjectIndepended.get() == false);
+
+    //     CHECK(sut.DefaultDelay.get() == 1234);
+    //     CHECK(sut.DefaultDuration.get() == 4321);
+    // }
+}
+
+
+
+
diff --git a/components/spit/uTest/spitTypeTest.cpp b/components/spit/uTest/spitTypeTest.cpp
new file mode 100644
index 0000000..2764ff9
--- /dev/null
+++ b/components/spit/uTest/spitTypeTest.cpp
@@ -0,0 +1,88 @@
+/**
+ * @file spitRepoTest.cpp
+ * @author Gustice
+ * @brief
+ */
+
+#include "doctest/doctest.h"
+#include <fmt/core.h>
+#include <iostream>
+
+#include "spit_type.hpp"
+
+using namespace spit;
+using namespace std;
+
+class SpitTypetFix {
+  protected:
+};
+
+TEST_CASE_FIXTURE(SpitTypetFix, "check confirmend behaviour") {
+    {
+        SType sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.GroupName.set("G123") == true);
+        CHECK(sut.GroupName.get() == "G123");
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.GroupName.set("G123") == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.GroupName.set("G321") == true);
+        CHECK(sut.GroupName.get() == "G321");
+        CHECK(sut.getConfirmed() == false);
+    }
+    {
+        SType sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(true) == true);
+        CHECK(sut.Fixed.get() == true);
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(true) == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.Fixed.set(false) == true);
+        CHECK(sut.Fixed.get() == false);
+        CHECK(sut.getConfirmed() == false);
+    }
+    {
+        SType sut("#Id#123");
+        CHECK(sut.getID() == "#Id#123");
+
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.DefaultDelay.set(123) == true);
+        CHECK(sut.DefaultDelay.get() == 123);
+        CHECK(sut.getConfirmed() == false);
+        sut.setConfirmed(true);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.DefaultDelay.set(123) == false);
+        CHECK(sut.getConfirmed() == true);
+        CHECK(sut.DefaultDelay.set(321) == true);
+        CHECK(sut.DefaultDelay.get() == 321);
+        CHECK(sut.getConfirmed() == false);
+    }
+    // ...
+
+    {
+        SType sut("#Id#123", "grp123", "name123", true, false, 1234, 4321);
+        CHECK(sut.getID() == "#Id#123");
+        CHECK(sut.GroupName.get() == "grp123");
+        CHECK(sut.Name.get() == "name123");
+        CHECK(sut.Fixed.get() == true);
+        CHECK(sut.ProjectIndepended.get() == false);
+
+        CHECK(sut.DefaultDelay.get() == 1234);
+        CHECK(sut.DefaultDuration.get() == 4321);
+    }
+}
diff --git a/main/watchMain.cpp b/main/watchMain.cpp
index 38efde6..5f20861 100644
--- a/main/watchMain.cpp
+++ b/main/watchMain.cpp
@@ -14,6 +14,8 @@
 #include "watchMain.hpp"
 #include "interconConfig.hpp"
 
+using namespace spit;
+
 string ClientName = "CatasWatchDev";
 string ProjectName = "CatastrphicProj";
 
@@ -580,9 +582,9 @@ struct LocalSpitObj {
 std::map<string, MoveCommand> ProvidedSpitActions;
 std::map<string, string> ExpectedObjects;
 
-void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_DetectedServer) {
+void onServerEvent(SClient::ServerEvent event, const SadDetectedServer &p_DetectedServer) {
     switch (event) {
-    case SPIT_Client::ServerEvent::Detect:
+    case SClient::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());
@@ -592,11 +594,11 @@ void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_D
         ESP_LOGI(TAG, " Addition: %s", p_DetectedServer.getAdditions().data());
         ESP_LOGI(TAG, " ClientIP: %s", p_DetectedServer.getClientIP().data());
         break;
-    case SPIT_Client::ServerEvent::Lost:
+    case SClient::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:
+    case SClient::ServerEvent::Changed:
         ESP_LOGW(TAG, "Server lost Name: %s  IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
         break;
 
@@ -606,25 +608,25 @@ void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_D
 }
 
 void onConnectionStatus(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime,
-                        SPIT_Client::Connection p_ConnectionStatus, SPIT_Client::Connection p_OldConnectionStatus) {
+                        SClient::Connection p_ConnectionStatus, SClient::Connection p_OldConnectionStatus) {
     ESP_LOGI(TAG, "MySPITApp: eventConnectionStatus %d->%d ", (int)p_OldConnectionStatus, (int)p_ConnectionStatus);
 }
 
 // The transfer of the server's SPITTypes and SPITObjects is finished.
-void onProjectUpdate(SPIT_Client::ProjUpdate state, string projectId) {
+void onProjectUpdate(SClient::ProjUpdate state, string projectId) {
 
     switch (state) {
-    case SPIT_Client::ProjUpdate::ServerLoaded:
+    case SClient::ProjUpdate::ServerLoaded:
         ESP_LOGI(TAG, "eventProjectReport ID: %s ", projectId.data());
         break;
-    case SPIT_Client::ProjUpdate::StartTransfer:
+    case SClient::ProjUpdate::StartTransfer:
         ESP_LOGI(TAG, "eventStartProjectTransfer");
         break;
-    case SPIT_Client::ProjUpdate::EndTransfer:
+    case SClient::ProjUpdate::EndTransfer:
         ESP_LOGI(TAG, "eventEndProjectTransfer");
         spitProjectFinish.give();
         break;
-    case SPIT_Client::ProjUpdate::ServerClosed:
+    case SClient::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
@@ -657,15 +659,15 @@ bool onCheckSpitObjectVeto(bool knownType) {
 // Called when the server has created, loaded, changed or deleted a (Remote) SPITType.
 // Remote SPITType are used in Remote SPITObjects. A Remote SPITObject is used to remote control the SPITServer.
 // May also occur when the server confirms a SPITType created or changed by the client.
-void onSpitType(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType &p_SPITType) {
+void onSpitType(SClient::ObjectEvent event, bool isRemote, const SType &sType) {
     if (isRemote) {
-        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());
-            auto typeName = p_SPITType.getName();
+        if (event == SClient::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-REMOTE-Type ID: %s GroupName: %s Name: %s confirmed: %d", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data(), sType.getConfirmed());
+            auto typeName = sType.Name.get();
             if (ExpectedObjects.contains(typeName)) {
-                ExpectedObjects[typeName] = p_SPITType.getID();
+                ExpectedObjects[typeName] = sType.getID();
             }
-        } else if (event == SPIT_Client::ObjectEvent::Changed) {
+        } else if (event == SClient::ObjectEvent::Changed) {
             // we had to inform all Remote SPITObjects using the p_SPITType
             // perhaps the SPITObject uses information from the SPITType
             // SPITObject *ptrSPITObject;
@@ -677,22 +679,22 @@ void onSpitType(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType &p
             //         continue;
             //     if (ptrSPITObject->getSPITTypeID() == p_SPITType.getID()) {
             //         // call ecentSPITObjectRemote
-            //         // onSpitObjectRemote(SPIT_Client::ObjectEvent::Changed, p_SPITType, *ptrSPITObject);
+            //         // onSpitObjectRemote(SClient::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());
+            ESP_LOGI(TAG, "SPIT-REMOTE-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data(), sType.getConfirmed());
+        } else if (event == SClient::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-REMOTE-Type Removed ID: %s GroupName: %s Name: %s\n", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data());
         }
     } else {
-        if (event == SPIT_Client::ObjectEvent::Created) {
+        if (event == SClient::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());
-        } 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());
+            // call _SpitClient.setActionSPITType(sType.getID(), true);
+            ESP_LOGI(TAG, "NEW SPIT-Type ID: %s GroupName: %s Name: %s confirmed: %d", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data(), sType.getConfirmed());
+        } else if (event == SClient::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data(), sType.getConfirmed());
+        } else if (event == SClient::ObjectEvent::Deleted) {
+            ESP_LOGI(TAG, "SPIT-Type Removed ID: %s GroupName: %s Name: %s\n", sType.getID().data(), sType.GroupName.get().data(), sType.Name.get().data());
         }
     }
 }
@@ -703,35 +705,35 @@ void onSpitType(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType &p
 // 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, bool isRemote, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
+void onSpitObject(SClient::ObjectEvent event, bool isRemote, const SType &sType, const SObject &sObject) {
     if (isRemote) {
-        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());
+        if (event == SClient::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-REMOTE-Object ID: %s Name: %s -> SPITType: %s", sObject.getID().data(), sObject.Name.get().data(), sType.Name.get().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());
+        } else if (event == SClient::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-REMOTE-Object CHANGED ID: %s Name: %s -> SPITType: %s", sObject.getID().data(), sObject.Name.get().data(), sType.Name.get().data());
+        } else if (event == SClient::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-REMOTE-Object Removed ID: %s Name: %s\n", sObject.getID().data(), sObject.Name.get().data());
             // This is a remote SPITObject
             // If you have listet this prior you should remove it from the list
         }
     } else {
-        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());
+        if (event == SClient::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-Object ID: %s Name: %s -> SPITType: %s", sObject.getID().data(), sObject.Name.get().data(), sType.Name.get().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);
+            // call _SpitClient.setActionSPITObject(sObject.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());
+        } else if (event == SClient::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-Object CHANGED ID: %s Name: %s -> SPITType: %s", sObject.getID().data(), sObject.Name.get().data(), sType.Name.get().data());
+        } else if (event == SClient::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-Object Removed ID: %s Name: %s\n", sObject.getID().data(), sObject.Name.get().data());
             // Check your actions
             // take the removal of the SPITObject over in your code
 
@@ -744,18 +746,18 @@ void onSpitObject(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType
 // 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) {
+void onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, uint64_t 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:
+    case SClient::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:
+    case SClient::PLAYERTYPE_CONTINOUS:
         // The olayer is playing only single Object sequences sometime during the project
         break;
-    case SPIT_Client::PLAYERTYPE_DISCRETE:
+    case SClient::PLAYERTYPE_DISCRETE:
         // Only discrete values where submitted, e.g the fader position of remote faders.
         break;
     }
@@ -791,8 +793,8 @@ void onPlaySpitType(string p_PlayerID, string spitTypeId, bool p_PlayerIsRunning
  * @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_LOGD(TAG, "eventPlayRemoteObjectStatus RemoteSPITType: %s RemoteSPITObject: %s Position: %lld Value: %d", p_SPITType.getName().data(), p_SPITObject.getName().data(), p_FrameInsideObject, p_Value);
+void onPlayRemoteObjectStatus(const SType &sType, const SObject &sObject, uint64_t frameInsideObject, int value) {
+    ESP_EARLY_LOGD(TAG, "eventPlayRemoteObjectStatus RemoteSPITType: %s RemoteSPITObject: %s Position: %lld Value: %d", sType.Name.get().data(), sObject.Name.get().data(), frameInsideObject, value);
 }
 
 void SpitClientApp() {
@@ -810,7 +812,9 @@ void SpitClientApp() {
         ExpectedObjects[expected.inPosX[i]] = "";
     }
 
-    SPIT_Client spitClient(ClientName, ProjectName,
+    auto ip = spit::Socket::getAdaptersInfo();
+    spit::Socket socket(ip);
+    SClient spitClient(ClientName, ProjectName, socket,
                            {
                                .onServerEvent = onServerEvent,
                                .onConnectionStatus = onConnectionStatus,
@@ -825,7 +829,7 @@ void SpitClientApp() {
                            });
 
     for (auto &obj : ProvidedObj) {
-        SPITType *ptrSPITType1Fix = spitClient.createSPITTypeFixed(obj.iD, obj.groupName, obj.name, 0, 0);
+        SType *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();
diff --git a/main/watchMain.hpp b/main/watchMain.hpp
index af7ad3f..6992cba 100644
--- a/main/watchMain.hpp
+++ b/main/watchMain.hpp
@@ -54,11 +54,11 @@
 // #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 "sad_DetectedServer.hpp"
+#include "spit_object.hpp"
+#include "spit_player.hpp"
+#include "spit_type.hpp"
+#include "spit_client.hpp"
 #include <chrono>
 #include <string>
 #include <map>