NetworkReplayStreaming.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
// Dependencies.
 
#include "AnalyticsEventAttribute.h"
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "Misc/CoreMisc.h"
#include "Misc/DateTime.h"
#include "Misc/NetworkVersion.h"
#include "Modules/ModuleInterface.h"
#include "Modules/ModuleManager.h"
#include "Net/Core/Connection/NetResult.h"
#include "Net/Core/Connection/NetResultManager.h"
#include "Serialization/JsonSerializerMacros.h"
#include "Templates/PimplPtr.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
 
class FArchive;
class FOutputDevice;
class IAnalyticsProvider;
class UWorld;
struct FAnalyticsEventAttribute;
 
class FReplayEventListItem : public FJsonSerializable
{
public:
    FReplayEventListItem() : Time1(0), Time2(0) {}
    virtual ~FReplayEventListItem() {}
 
    FString     ID;
    FString     Group;
    FString     Metadata;
    uint32      Time1;
    uint32      Time2;
 
    // FJsonSerializable
    BEGIN_JSON_SERIALIZER
        JSON_SERIALIZE("id", ID);
        JSON_SERIALIZE("group", Group);
        JSON_SERIALIZE("meta", Metadata);
        JSON_SERIALIZE("time1", Time1);
        JSON_SERIALIZE("time2", Time2);
    END_JSON_SERIALIZER
};
 
class FReplayEventList : public FJsonSerializable
{
public:
    FReplayEventList()
    {}
    virtual ~FReplayEventList() {}
 
    TArray< FReplayEventListItem > ReplayEvents;
 
    // FJsonSerializable
    BEGIN_JSON_SERIALIZER
        JSON_SERIALIZE_ARRAY_SERIALIZABLE("events", ReplayEvents, FReplayEventListItem);
    END_JSON_SERIALIZER
};
 
struct FNetworkReplayStreamInfo
{
    FNetworkReplayStreamInfo() : Timestamp( 0 ), SizeInBytes( 0 ), LengthInMS( 0 ), NumViewers( 0 ), Changelist( 0 ), bIsLive(false), bShouldKeep( false ) {}
 
    FString Name;
 
    FString FriendlyName;
 
    FDateTime Timestamp;
 
    int64 SizeInBytes;
    
    int32 LengthInMS;
 
    int32 NumViewers;
 
    int32 Changelist;
 
    bool bIsLive;
 
    bool bShouldKeep;
};
 
namespace ENetworkReplayError
{
    enum UE_DEPRECATED(5.1, "No longer used") Type
    {
        None,
 
        ServiceUnavailable,
    };
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    inline const TCHAR* ToString( const ENetworkReplayError::Type FailureType )
    {
        switch ( FailureType )
        {
            case None:
                return TEXT( "None" );
            case ServiceUnavailable:
                return TEXT( "ServiceUnavailable" );
        }
        return TEXT( "Unknown ENetworkReplayError error" );
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
DECLARE_DELEGATE_TwoParams( FOnStreamReadyDelegate, const bool, const bool );
 
DECLARE_DELEGATE_TwoParams( FOnCheckpointReadyDelegate, const bool, const int64 );
 
DECLARE_DELEGATE_OneParam( FOnDeleteFinishedStreamComplete, const bool );
 
DECLARE_DELEGATE_OneParam( FOnEnumerateStreamsComplete, const TArray<FNetworkReplayStreamInfo>& );
 
DECLARE_DELEGATE_TwoParams(FEnumerateEventsCompleteDelegate, const FReplayEventList&, bool);
 
DECLARE_DELEGATE_TwoParams(FOnRequestEventDataComplete, const TArray<uint8>&, bool)
 
 
DECLARE_DELEGATE_OneParam(FOnDownloadHeaderComplete, const bool);
 
enum class EStreamingOperationResult
{
    Success,        
    Unsupported,    
    ReplayNotFound, 
    ReplayCorrupt,  
    NotEnoughSpace, 
    NotEnoughSlots, 
    Unspecified,    
    UnfinishedTask, 
    EventNotFound,  
    DecryptFailure, 
};
 
struct FStreamingResultBase
{
    EStreamingOperationResult Result = EStreamingOperationResult::Unspecified;
 
    virtual ~FStreamingResultBase() {}
 
    bool WasSuccessful() const
    {
        return EStreamingOperationResult::Success == Result;
    }
};
 
struct FStartStreamingResult : public FStreamingResultBase
{
    bool bRecording = false;
};
 
DECLARE_DELEGATE_OneParam(FStartStreamingCallback, const FStartStreamingResult&);
 
static inline FStartStreamingCallback UpgradeStartStreamingDelegate(const FOnStreamReadyDelegate& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FStartStreamingCallback::CreateLambda([OldDelegate](const FStartStreamingResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.WasSuccessful(), Result.bRecording);
        });
    }
    else
    {
        return FStartStreamingCallback();
    }
}
struct FReplayCheckpointInfo
{
    static constexpr uint32 INVALID_CHECKPOINT = -2;
 
    static constexpr uint32 NO_CHECKPOINT = -1;
 
    uint32 CheckpointStartTime = INVALID_CHECKPOINT;
    uint32 CheckpointIndex = INVALID_CHECKPOINT;
};
 
struct FGotoResult : public FStreamingResultBase
{
    int64 ExtraTimeMS = -1;
 
    FReplayCheckpointInfo CheckpointInfo;
};
 
DECLARE_DELEGATE_OneParam(FGotoCallback, const FGotoResult&);
 
static inline FGotoCallback UpgradeGotoDelegate(const FOnCheckpointReadyDelegate& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FGotoCallback::CreateLambda([OldDelegate](const FGotoResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.WasSuccessful(), Result.ExtraTimeMS);
        });
    }
    else
    {
        return FGotoCallback();
    }
}
struct FDeleteFinishedStreamResult : public FStreamingResultBase
{
};
 
DECLARE_DELEGATE_OneParam(FDeleteFinishedStreamCallback, const FDeleteFinishedStreamResult&);
 
static inline FDeleteFinishedStreamCallback UpgradeDeleteFinishedStreamDelegate(const FOnDeleteFinishedStreamComplete& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FDeleteFinishedStreamCallback::CreateLambda([OldDelegate](const FDeleteFinishedStreamResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.WasSuccessful());
        });
    }
    else
    {
        return FDeleteFinishedStreamCallback();
    }
}
struct FEnumerateStreamsResult : public FStreamingResultBase
{
    TArray<FNetworkReplayStreamInfo> FoundStreams;
 
    TArray<FString> CorruptedStreams;
};
 
DECLARE_DELEGATE_OneParam(FEnumerateStreamsCallback, const FEnumerateStreamsResult&);
 
static inline FEnumerateStreamsCallback UpgradeEnumerateStreamsDelegate(const FOnEnumerateStreamsComplete& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FEnumerateStreamsCallback::CreateLambda([OldDelegate](const FEnumerateStreamsResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.FoundStreams);
        });
    }
    else
    {
        return FEnumerateStreamsCallback();
    }
}
struct FEnumerateEventsResult : public FStreamingResultBase
{
    FReplayEventList ReplayEventList;
};
 
DECLARE_DELEGATE_OneParam(FEnumerateEventsCallback, const FEnumerateEventsResult&);
 
static inline FEnumerateEventsCallback UpgradeEnumerateEventsDelegate(const FEnumerateEventsCompleteDelegate& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FEnumerateEventsCallback::CreateLambda([OldDelegate](const FEnumerateEventsResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.ReplayEventList, Result.WasSuccessful());
        });
    }
    else
    {
        return FEnumerateEventsCallback();
    }
}
struct FRequestEventDataResult : public FStreamingResultBase
{
    TArray<uint8> ReplayEventListItem;
};
 
DECLARE_DELEGATE_OneParam(FRequestEventDataCallback, const FRequestEventDataResult&);
 
static inline FRequestEventDataCallback UpgradeRequestEventDelegate(const FOnRequestEventDataComplete& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FRequestEventDataCallback::CreateLambda([OldDelegate](const FRequestEventDataResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.ReplayEventListItem, Result.WasSuccessful());
        });
    }
    else
    {
        return FRequestEventDataCallback();
    }
}
struct FRequestEventGroupDataResult : public FStreamingResultBase
{
    TArray<FReplayEventListItem> ReplayEventListItems;
    TArray<FRequestEventDataResult> ReplayEventListResults;
};
 
DECLARE_DELEGATE_OneParam(FRequestEventGroupDataCallback, const FRequestEventGroupDataResult&);
struct FDownloadHeaderResult : public FStreamingResultBase
{
};
 
DECLARE_DELEGATE_OneParam(FDownloadHeaderCallback, const FDownloadHeaderResult&);
 
static inline FDownloadHeaderCallback UpgradeDownloadHeaderDelegate(const FOnDownloadHeaderComplete& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FDownloadHeaderCallback::CreateLambda([OldDelegate](const FDownloadHeaderResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.WasSuccessful());
        });
    }
    else
    {
        return FDownloadHeaderCallback();
    }
}
struct FSearchEventsResult : public FStreamingResultBase
{
    // An array containing information about the streams that were found.
    TArray<FNetworkReplayStreamInfo> FoundStreams;
 
    TArray<FString> CorruptedStreams;
};
 
DECLARE_DELEGATE_OneParam(FSearchEventsCallback, const FSearchEventsResult&);
 
static inline FSearchEventsCallback UpgradeSearchEventsDelegate(const FOnEnumerateStreamsComplete& OldDelegate)
{
    if (OldDelegate.IsBound())
    {
        return FSearchEventsCallback::CreateLambda([OldDelegate](const FSearchEventsResult& Result)
        {
            OldDelegate.ExecuteIfBound(Result.FoundStreams);
        });
    }
    else
    {
        return FSearchEventsCallback();
    }
}
struct FKeepReplayResult : public FStreamingResultBase
{
    FString NewReplayName;
 
    int64 RequiredSpace = 0;
};
 
DECLARE_DELEGATE_OneParam(FKeepReplayCallback, const FKeepReplayResult&);
struct FRenameReplayResult : public FStreamingResultBase
{
};
 
DECLARE_DELEGATE_OneParam(FRenameReplayCallback, const FRenameReplayResult&);
enum class EReplayCheckpointType : uint8
{
    Full,
    Delta
};
 
struct FStartStreamingParameters
{
    FString CustomName;
    FString FriendlyName;
    FString DemoURL;
    TArray<int32> UserIndices;
    FNetworkReplayVersion ReplayVersion;
    bool bRecord;
};
 
enum class EReplayStreamerState : uint8
{
    Idle,                   // The streamer is idle. Either we haven't started activity yet, or we are done
    Recording,              // We are in the process of recording a replay
    Playback,               // We are in the process of playing a replay
};
 
FString NETWORKREPLAYSTREAMING_API LexToString(const EReplayStreamerState State);
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnReplayGetAnalyticsAttributes, const class INetworkReplayStreamer* /*Streamer*/, TArray<FAnalyticsEventAttribute>& /*Attributes*/);
 
class INetworkReplayStreamer 
{
public:
    NETWORKREPLAYSTREAMING_API INetworkReplayStreamer();
    NETWORKREPLAYSTREAMING_API virtual ~INetworkReplayStreamer();
 
    virtual void StartStreaming(const FStartStreamingParameters& Params, const FStartStreamingCallback& Delegate) = 0;
 
    virtual void StopStreaming() = 0;
    virtual FArchive* GetHeaderArchive() = 0;
    virtual FArchive* GetStreamingArchive() = 0;
    virtual FArchive* GetCheckpointArchive() = 0;
    virtual void FlushCheckpoint(const uint32 TimeInMS) = 0;
 
    virtual void GotoCheckpointIndex(const int32 CheckpointIndex, const FGotoCallback& Delegate, EReplayCheckpointType CheckpointType) = 0;
 
    virtual void GotoTimeInMS(const uint32 TimeInMS, const FGotoCallback& Delegate, EReplayCheckpointType CheckpointType) = 0;
 
    virtual bool IsCheckpointTypeSupported(EReplayCheckpointType CheckpointType) const = 0;
 
    virtual void UpdateTotalDemoTime(uint32 TimeInMS) = 0;
    virtual void UpdatePlaybackTime(uint32 TimeInMS) = 0;
 
    virtual uint32 GetTotalDemoTime() const = 0;
 
    virtual bool IsDataAvailable() const = 0;
    virtual void SetHighPriorityTimeRange(const uint32 StartTimeInMS, const uint32 EndTimeInMS) = 0;
    virtual bool IsDataAvailableForTimeRange(const uint32 StartTimeInMS, const uint32 EndTimeInMS) = 0;
    virtual bool IsLoadingCheckpoint() const = 0;
    virtual void AddEvent(const uint32 TimeInMS, const FString& Group, const FString& Meta, const TArray<uint8>& Data) = 0;
    virtual void AddOrUpdateEvent(const FString& Name, const uint32 TimeInMS, const FString& Group, const FString& Meta, const TArray<uint8>& Data) = 0;
 
    virtual void EnumerateEvents(const FString& Group, const FEnumerateEventsCallback& Delegate) = 0;
 
    virtual void EnumerateEvents(const FString& ReplayName, const FString& Group, const FEnumerateEventsCallback& Delegate) = 0;
    virtual void EnumerateEvents( const FString& ReplayName, const FString& Group, const int32 UserIndex, const FEnumerateEventsCallback& Delegate ) = 0;
 
    virtual void RequestEventData(const FString& EventID, const FRequestEventDataCallback& Delegate) = 0;
    virtual void RequestEventData(const FString& ReplayName, const FString& EventID, const FRequestEventDataCallback& Delegate) = 0;
    virtual void RequestEventData(const FString& ReplayName, const FString& EventID, const int32 UserIndex, const FRequestEventDataCallback& Delegate) = 0;
 
    virtual void RequestEventGroupData(const FString& Group, const FRequestEventGroupDataCallback& Delegate) = 0;
    virtual void RequestEventGroupData(const FString& ReplayName, const FString& Group, const FRequestEventGroupDataCallback& Delegate) = 0;
    virtual void RequestEventGroupData(const FString& ReplayName, const FString& Group, const int32 UserIndex, const FRequestEventGroupDataCallback& Delegate) = 0;
 
    virtual void SearchEvents(const FString& EventGroup, const FSearchEventsCallback& Delegate) = 0;
    virtual void RefreshHeader() = 0;
 
    virtual void DownloadHeader(const FDownloadHeaderCallback& Delegate) = 0;
 
    virtual void KeepReplay(const FString& ReplayName, const bool bKeep, const FKeepReplayCallback& Delegate) = 0;
    virtual void KeepReplay(const FString& ReplayName, const bool bKeep, const int32 UserIndex, const FKeepReplayCallback& Delegate) = 0;
 
    virtual void RenameReplayFriendlyName(const FString& ReplayName, const FString& NewFriendlyName, const FRenameReplayCallback& Delegate) = 0;
    virtual void RenameReplayFriendlyName(const FString& ReplayName, const FString& NewFriendlyName, const int32 UserIndex, const FRenameReplayCallback& Delegate) = 0;
 
    virtual void RenameReplay(const FString& ReplayName, const FString& NewName, const FRenameReplayCallback& Delegate) = 0;
    virtual void RenameReplay(const FString& ReplayName, const FString& NewName, const int32 UserIndex, const FRenameReplayCallback& Delegate) = 0;
 
    virtual bool IsLive() const = 0;
 
    virtual FString GetReplayID() const = 0;
 
    virtual EReplayStreamerState GetReplayStreamerState() const { return EReplayStreamerState::Idle; };
 
    virtual void DeleteFinishedStream(const FString& StreamName, const FDeleteFinishedStreamCallback& Delegate) = 0;
    virtual void DeleteFinishedStream(const FString& StreamName, const int32 UserIndex, const FDeleteFinishedStreamCallback& Delegate) = 0;
 
    virtual void EnumerateStreams(const FNetworkReplayVersion& ReplayVersion, const int32 UserIndex, const FString& MetaString, const TArray< FString >& ExtraParms, const FEnumerateStreamsCallback& Delegate) = 0;
 
    virtual void EnumerateRecentStreams(const FNetworkReplayVersion& ReplayVersion, const int32 UserIndex, const FEnumerateStreamsCallback& Delegate) = 0;
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.1, "Deprecated in favor of HasError and HandleLastError")
    NETWORKREPLAYSTREAMING_API virtual ENetworkReplayError::Type GetLastError() const;
    NETWORKREPLAYSTREAMING_API PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    virtual bool HasError() const;
 
    NETWORKREPLAYSTREAMING_API virtual UE::Net::EHandleNetResult HandleLastError(UE::Net::FNetResultManager& ResultManager);
 
    NETWORKREPLAYSTREAMING_API virtual void SetExtendedError(UE::Net::FNetResult&& Result);
 
    virtual void AddUserToReplay( const FString& UserString ) = 0;
 
    virtual void SetTimeBufferHintSeconds(const float InTimeBufferHintSeconds) = 0;
 
    virtual uint32 GetMaxFriendlyNameSize() const = 0;
 
    virtual EStreamingOperationResult SetDemoPath(const FString& DemoPath) = 0;
 
    virtual EStreamingOperationResult GetDemoPath(FString& DemoPath) const = 0;
 
    virtual void SetAnalyticsProvider(TSharedPtr<IAnalyticsProvider>& InProvider) {}
 
    NETWORKREPLAYSTREAMING_API virtual TArray<FAnalyticsEventAttribute> AppendCommonReplayAttributes(TArray<FAnalyticsEventAttribute>&& Attrs) const;
 
    virtual void Exec(const TCHAR* Cmd, FOutputDevice& Ar) {}
 
    static NETWORKREPLAYSTREAMING_API FOnReplayGetAnalyticsAttributes OnReplayGetAnalyticsAttributes;
 
private:
    TPimplPtr<UE::Net::FNetResult, EPimplPtrMode::DeepCopy> ExtendedError;
};
 
class INetworkReplayStreamingFactory : public IModuleInterface
{
public:
    virtual TSharedPtr<INetworkReplayStreamer> CreateReplayStreamer() = 0;
    virtual void Flush() {}
};
 
class FNetworkReplayStreaming : public IModuleInterface, public FSelfRegisteringExec
{
public:
    FNetworkReplayStreaming() {}
    virtual ~FNetworkReplayStreaming() {}
 
    static inline FNetworkReplayStreaming& Get()
    {
        return FModuleManager::LoadModuleChecked<FNetworkReplayStreaming>("NetworkReplayStreaming");
    }
 
    NETWORKREPLAYSTREAMING_API void Flush();
 
    virtual INetworkReplayStreamingFactory& GetFactory(const TCHAR* FactoryNameOverride = nullptr);
 
    virtual const FString GetAutomaticReplayPrefixExtern() const;
    virtual const int32 GetMaxNumberOfAutomaticReplaysExtern() const;
 
    // Gets the configured max value for the number of automatic replays to support.
    // 0 indicates no limit.
    static NETWORKREPLAYSTREAMING_API int32 GetMaxNumberOfAutomaticReplays();
 
    // Gets the configured automatic replay name prefix.
    // The prefix should always be a non-empty string.
    // If using streamers that store replays on disk, this must also be comprised of only valid file name characters.
    static NETWORKREPLAYSTREAMING_API FString GetAutomaticReplayPrefix();
 
    // Gets the configured value for whether or not we should use FDateTime::Now as the automatic replay postfix.
    // If false, it's up to the streamer to determine a proper postfix.
    static NETWORKREPLAYSTREAMING_API bool UseDateTimeAsAutomaticReplayPostfix();
 
    // Gets the file extension for replay streamers to use when recording replay files to the local file system.
    // Includes the "." prefix
    static NETWORKREPLAYSTREAMING_API FString GetReplayFileExtension();
 
    // FSelfRegisteringExec interface
#if UE_ALLOW_EXEC_COMMANDS
    virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
#endif
 
private:
    TSet<FName> LoadedFactories;
};