CareTaker.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <thread>
#include <mutex>
#include <atomic>
#include <memory>
#include <map>
#include <set>
#include <chrono>
#include <functional>
 
#include "HermesCallbackTypes.hpp"
 
#include "grpc++/grpc++.h"
#include "protodefinitions/Devices.pb.h"
#include "protodefinitions/Hermes.pb.h"
#include "protodefinitions/Pipeline.pb.h"
#include "protodefinitions/Landscape.pb.h"
#include "protodefinitions/Session.pb.h"
#include "protodefinitions/ParameterSet.pb.h"
#include "protodefinitions/Hermes.grpc.pb.h"
 
namespace zmq
{
    class context_t;
    class socket_t;
};
 
namespace HermesSDK
{
    // Set up a Doxygen group.
    class CareTaker
    {
        Hermes::Protocol::Version m_version;
        std::atomic<bool> m_isRunning;
 
 
        std::wstring CareTaker::GetVersionDir();
 
        void DeviceDataSubscriberThreadFunction();
        void DeviceLandscapeSubscriberThreadFunction();
        void PolygonDataSubscriberThreadFunction();
        void TrackingDataSubscriberThreadFunction();
        void HeartbeatThreadFunction();
        void RestartThreadFunction();
 
        bool Login();
        bool Logout();
        uint32_t Heartbeat();
 
        bool initHapticsSocket();
 
        static std::vector<uint8_t> Decompress( const std::vector<uint8_t> &in );
        static size_t LzfDecompress( const std::vector<uint8_t> &in, std::vector<uint8_t> &out );
 
        std::shared_ptr<grpc::Channel> m_Channel;
        std::unique_ptr<Hermes::Protocol::Hermes::Stub> m_Stub;
 
        const std::string m_clientName;
        const std::string m_clientDescription;
 
        Hermes::Protocol::Session m_Session;
        Hermes::Protocol::Pipeline m_Pipeline;
        Hermes::Protocol::ServiceRoute m_Coordinator;
 
        std::unique_ptr<std::thread> m_deviceDataThread;
        std::unique_ptr<std::thread> m_deviceLandscapeThread;
        std::unique_ptr<std::thread> m_polygonDataThread;
        std::unique_ptr<std::thread> m_trackingDataThread;
        std::unique_ptr<std::thread> m_heartbeatThread;
 
        std::unique_ptr<std::thread> m_RestartThread;
 
        deviceDataCallback &m_dataCallback;
        deviceLandscapeCallback &m_landscapeCallback;
        polygonDataCallback &m_polygonDataCallback;
        trackingDataCallback &m_trackingDataCallback;
        filterSetupCallback &m_filterPipelineCallback;
        errorMessageCallback &m_errorCallback;
        connectedToCoreCallback& m_onConnectedToCoreCallback;
        disconnectedFromCoreCallback& m_onDisconnectedFromCoreCallback;
 
    public:
 
        CareTaker( const std::string &clientName,
            const std::string &clientInfo,
            filterSetupCallback &_onFilterSetup,
            deviceDataCallback &_onDeviceData,
            deviceLandscapeCallback &_onDeviceLandscape,
            polygonDataCallback &_onPolygonData,
            trackingDataCallback &_onTrackingData,
            errorMessageCallback &onError,
            connectedToCoreCallback& _onConnectedToCore,
            disconnectedFromCoreCallback& _onDisconnectedFromCore);
        ~CareTaker();
 
        void Connect( const Hermes::Protocol::ServiceRoute& _coordinatorRoute );
        void Stop();
 
        bool                        Rumble( uint32_t deviceId, float unitStrength, uint16_t durationInMilliseconds );
        bool                        SendHapticData( uint32_t _dongleId, Hermes::Protocol::HandType _handType, const std::array<float, 5>& _powers );
        bool                        GetFilterInventory( Hermes::Protocol::FilterInventory &inventory ) const;
        Hermes::Protocol::Pipeline *GetActivePipeline();
        bool                        SetPipeline( Hermes::Protocol::Pipeline *pipeline );
        bool                        IsRunning();
        bool                        GetCoreVersion( Hermes::Protocol::Version& version );
 
        bool                        GetAllUsers( Hermes::Protocol::UserCollection &UserCollection );
 
        bool                        UpdateTrackers(const Hermes::Protocol::TrackerData& TrackerData);
 
        bool                        AddSkeleton( Hermes::Protocol::Polygon::Skeleton &Skeleton );
        bool                        RemoveSkeleton( Hermes::Protocol::Polygon::RemoveSkeletonArgs &_Args );
        bool                        SetSkeletonTarget( Hermes::Protocol::Polygon::SetTargetArgs& _Args );
        bool                        SetSkeletonSettings( Hermes::Protocol::Polygon::Retargeting::SettingsArgs& _Args );
        bool                        AddTargetSkeleton( Hermes::Protocol::Polygon::TargetSkeleton &_Skeleton );
        bool                        RemoveTargetSkeleton( std::string &_Name );
        void                        UpdateTargetSkeleton( Hermes::Protocol::Polygon::TargetSkeleton &_Skeleton );
 
        Hermes::Protocol::Polygon::Version GetCompatiblePolygonVersion();
        Hermes::Protocol::ServiceRoute* GetGRPCPresetPort();
        int GetHivePort();
    };
 
    // Close the Doxygen group.
}