DirectLinkEndpoint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Future.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "DirectLinkCommon.h"
#include "HAL/Platform.h"
#include "HAL/PlatformCrt.h"
#include "IMessageContext.h"
#include "Misc/EngineVersion.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
 
#include <atomic>
 
#define UE_API DIRECTLINK_API
 
class FMessageEndpoint;
 
namespace DirectLink
{
class ISceneGraphNode;
 
 
enum class ECommunicationStatus{
    NoIssue                      = 0,
    ModuleNotLoaded_Messaging    = 1<<0,
    ModuleNotLoaded_UdpMessaging = 1<<1,
    ModuleNotLoaded_Networking   = 1<<2,
};
ENUM_CLASS_FLAGS(ECommunicationStatus)
DIRECTLINK_API ECommunicationStatus ValidateCommunicationStatus();
 
struct FRawInfo
{
    struct FDataPointId
    {
        FString Name;
        FGuid Id;
        bool bIsPublic = false;
    };
 
    struct FEndpointInfo
    {
        FEndpointInfo() = default;
        FString Name;
        FEngineVersion Version; // Unreal version. This field is empty when the client predates 4.27.0
        TArray<FDataPointId> Destinations;
        TArray<FDataPointId> Sources;
        FString UserName;
        FString ExecutableName;
        FString ComputerName;
        bool bIsLocal = false;
        uint32 ProcessId = 0;
    };
 
    struct FDataPointInfo
    {
        FMessageAddress EndpointAddress;
        FString Name;
        bool bIsSource = false; // as opposed to a destination
        bool bIsOnThisEndpoint = false;
        bool bIsPublic = false; // if public, can be displayed as candidate for connection
    };
 
    struct FStreamInfo
    {
        FStreamPort StreamId = InvalidStreamPort;
        FGuid Source;
        FGuid Destination;
        EStreamConnectionState ConnectionState;
        FCommunicationStatus CommunicationStatus;
    };
    FMessageAddress ThisEndpointAddress;
    TMap<FMessageAddress, FEndpointInfo> EndpointsInfo;
    TMap<FGuid, FDataPointInfo> DataPointsInfo;
    TArray<FStreamInfo> StreamsInfo;
};
 
 
class IEndpointObserver
{
public:
    virtual ~IEndpointObserver() = default;
 
    virtual void OnStateChanged(const FRawInfo& RawInfo) {}
};
 
 
using FSourceHandle = FGuid;
using FDestinationHandle = FGuid;
 
 
 
class FEndpoint
    : public FNoncopyable
{
public:
    enum class EOpenStreamResult
    {
        Opened,
        AlreadyOpened,
        SourceAndDestinationNotFound,
        RemoteEndpointNotFound,
        Unsuppported,
        CannotConnectToPrivate,
    };
 
public:
    UE_API FEndpoint(const FString& InName);
    UE_API ~FEndpoint();
 
    UE_API void SetVerbose(bool bVerbose=true);
 
    UE_API FSourceHandle AddSource(const FString& Name, EVisibility Visibility=EVisibility::Public);
 
    UE_API void RemoveSource(const FSourceHandle& Source);
 
    UE_API void SetSourceRoot(const FSourceHandle& Source, ISceneGraphNode* InRoot, bool bSnapshot);
 
    UE_API void SnapshotSource(const FSourceHandle& Source);
 
 
    UE_API FDestinationHandle AddDestination(const FString& Name, EVisibility Visibility, const TSharedPtr<class IConnectionRequestHandler>& ConnectionRequestHandler);
 
    UE_API void RemoveDestination(const FDestinationHandle& Destination);
 
    UE_API FRawInfo GetRawInfoCopy() const;
 
    UE_API void AddEndpointObserver(IEndpointObserver* Observer);
 
    UE_API void RemoveEndpointObserver(IEndpointObserver* Observer);
 
    UE_API EOpenStreamResult OpenStream(const FSourceHandle& SourceId, const FDestinationHandle& DestinationId);
 
    UE_API void CloseStream(const FSourceHandle& SourceId, const FDestinationHandle& DestinationId);
 
private:
    TUniquePtr<class FSharedState> SharedStatePtr;
    class FSharedState& SharedState;
 
    TUniquePtr<class FInternalThreadState> InternalPtr;
    class FInternalThreadState& Internal;
};
 
} // namespace DirectLink
 
#undef UE_API