ServerEntities.h

Go to the documentation of this file.

#ifndef SERVERENTITIES_H
#define SERVERENTITIES_H
 
#include "Communication/CscMessageEncryption.h"
#include "CscCommon.h"
#include "communication/phone/CscVocalPhoneCallEmitter.h"
#include <mutex>
#include <thread>
#include "ArtificialIntelligence/CscEntityReflexion.h"
#include <Communication/CscMessagingManager.h>
#include <Bridging/EnvironmentInteractionCommands/Result/CommandExecutionResult.h>
#include <Bridging/EnvironmentInteractionCommands/Command.h>
 
using namespace conscience_server::communication;
using namespace conscience_server::communication::phone;
using namespace conscience_core::communication;
using namespace conscience_core::core_objects;
using namespace conscience_core::ai;
using namespace conscience_core::bridging::commands;
using namespace conscience_core::bridging::commands::result;
 
#define ENTITY_UDP_RESPONSE_PORT 1705
#define DEFAULT_UDP_LISTEN_PORT 1703
#define DEFAULT_TCP_LISTEN_PORT 1803
 
using std::mutex, std::thread;
 
namespace conscience_core::communication {
// forward ref in order to optimize compilation
class UdpClient;
}
 
namespace conscience_server::entities {
 
struct ServerEntitySummary {
public:
    string serialNumber;
    string modelId;
    optional<string> ip;
    optional<int> port;
    string videoSource;
};
 
class ServerEntities {
public:
    struct EntityPeerInfo {
        string ip;
        unsigned int port;
 
        operator string() const;
        static EntityPeerInfo fromSerialized(const string &serializedInfo);
    };
 
    ServerEntities(CscMessagingManager* messagingManager, CscVocalPhoneCallEmitter *phoneCallEmitter);
    ~ServerEntities();
 
    ptr<CscEntityReflexion> startNewEntity(ptr<CscEntityReflexionParameters> entityParameters, optional<EntityPeerInfo> remoteEntityPeerInfo = {});
 
    void onEntityProfileReceived(const vector<string> &commandArguments, EntityPeerInfo entityPeerInfo);
 
    void onStatePlayed(const char *entitySerialNumber, double *values, unsigned long valuesSize, int duration, int delay, bool relative);
 
    bool isEntityRunningCommand(const string &entitySerialNumber, const string &commandPart) const;
 
    vector<const ServerEntitySummary *> getEntitiesSummary();
 
    vector<string> getEntitySerialNumbers();
 
    void restoreEntities();
 
private:
    void restoreEntitiesFromJson();
 
 
    CscMessagingManager* messagingManager;
    CscVocalPhoneCallEmitter *phoneCallEmitter;
 
    unique_ptr<CscLogger> logger = nullptr;
    fs::path dataFilePath;
    mutex persistEntitiesMutex;
    mutex updateEntityMutex;
    struct Entity {
        ptr<CscEntityReflexion> entityReflexion;
        optional<EntityPeerInfo> peerInfo;
        UdpClient *udpClient = nullptr;
        vector<string> currentCommands;
 
        Entity(ptr<CscEntityReflexion> entityReflexion, optional<EntityPeerInfo> peerInfo) : entityReflexion(entityReflexion), peerInfo(peerInfo) {
        }
    };
 
    map<string, Entity *> entitiesBySerialNumber;
    map<string, int> registerClientPeriodMillisBySerialNumber;
    const int registerClientIntervalTimeInMillis = 15000;
    const int getCurrentLidarPeriodMillis = 200;
    const int registerClientIntervalForLocalizationTimeInMillis = 250;
    bool registerClientLoopRunning = false;
    thread registerClientThread;
 
    void sendLiveEnvironmentUpdate(const string entitySerialNumber, const vector<ptr<const LiveEnvironmentDetectedObject>> &detectedObjects);
 
    ptr<CscEntityReflexion> updateEntity(
        ptr<CscEntityReflexionParameters> entityParameters,
        optional<EntityPeerInfo> remoteEntityPeerInfo,
        bool persistInDataFile);
 
    void installEntityListeners(Entity *entity);
    void persistEntities();
 
    void updateEntityCurrentCommands(const string &entitySerialNumber, function<void(vector<string> &commands)> update);
 
    int startEntityCurrentCommands(const string &entitySerialNumber);
 
    void addOnStatePlayedListener();
    
    const string followEntityId = "followEntity";
 
    void sendUdpMessageToEntity(const string &message, const string &serialNumber);
    void registerClientThreadLoop();
    void registerClientWithPeriodInMillis(int periodInMillis, string serialNumber);
 
    void onCommandExecutedOnEntity(ptr<CscEntityReflexion> entityReflexion, const CscCommand *command, const CscCommandExecutionResult *result);
};
}
 
#endif