GenericPlatformChunkInstall.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
/*=============================================================================================
    GenericPlatformChunkInstall.h: Generic platform chunk based install classes.
==============================================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/UnrealString.h"
#include "Templates/Function.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "Logging/LogMacros.h"
#include "Modules/ModuleInterface.h"
#include "UObject/NameTypes.h"
 
class IPlatformChunkInstall;
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogChunkInstaller, Log, All);
 
#ifndef ENABLE_PLATFORM_CHUNK_INSTALL
    #define ENABLE_PLATFORM_CHUNK_INSTALL (1)
#endif
 
namespace EChunkLocation
{
    enum Type
    {
        // note: higher quality locations should have higher enum values, we sort by these in AssetRegistry.cpp
        DoesNotExist,   // chunk does not exist
        NotAvailable,   // chunk has not been installed yet
        LocalSlow,      // chunk is on local slow media (optical)
        LocalFast,      // chunk is on local fast media (HDD)
 
        BestLocation=LocalFast
    };
}
 
 
namespace EChunkInstallSpeed
{
    enum Type
    {
        Paused,                 // chunk installation is paused
        Slow,                   // installation is lower priority than Game IO
        Fast                    // installation is higher priority than Game IO
    };
}
 
namespace EChunkPriority
{
    enum Type
    {
        Immediate,  // Chunk install is of highest priority, this can cancel lower priority installs.
        High     ,  // Chunk is probably required soon so grab is as soon as possible.
        Low      ,  // Install this chunk only when other chunks are not needed.
    };
}
 
namespace EChunkProgressReportingType
{
    enum Type
    {
        ETA,                    // time remaining in seconds
        PercentageComplete      // percentage complete in 99.99 format
    };
}
 
struct FNamedChunkCompleteCallbackParam
{
    FName NamedChunk;
    EChunkLocation::Type Location;
    bool bIsInstalled;
    bool bHasSucceeded;
};
 
class IPlatformChunkInstallModule : public IModuleInterface
{
public:
 
    virtual IPlatformChunkInstall* GetPlatformChunkInstall() = 0;
};
 
class IPlatformChunkInstallManifest
{
public:
    virtual bool HasManifest() const = 0;
    virtual int32 GetChunkIDFromPakchunkIndex(int32 PakchunkIndex) const = 0;
    virtual TArray<FString> GetPakFilesInChunk(int32 ChunkID) const = 0;
};
 
 
DECLARE_DELEGATE_TwoParams(FPlatformChunkInstallDelegate, uint32, bool);
DECLARE_MULTICAST_DELEGATE_TwoParams(FPlatformChunkInstallMultiDelegate, uint32, bool);
 
DECLARE_DELEGATE_OneParam(FPlatformNamedChunkCompleteDelegate, const FNamedChunkCompleteCallbackParam&);
DECLARE_MULTICAST_DELEGATE_OneParam(FPlatformNamedChunkCompleteMultiDelegate, const FNamedChunkCompleteCallbackParam&);
 
enum class ENamedChunkType : uint8
{
    Invalid,
    OnDemand,
    Language,
};
 
struct FChunkInstallationStatusDetail
{
    uint64 CurrentInstallSize;
    uint64 FullInstallSize;
    bool bIsInstalled;
};
 
class IPlatformChunkInstall
{
public:
 
    virtual ~IPlatformChunkInstall() {}
 
    virtual void AsyncInit( TFunction<void(bool/*bSuccess*/)> OnInitComplete ) = 0;
 
    virtual bool IsAvailable() const = 0;
 
    virtual EChunkLocation::Type GetPakchunkLocation( int32 PakchunkIndex) = 0;
 
    virtual bool GetProgressReportingTypeSupported(EChunkProgressReportingType::Type ReportType) = 0;       
 
    virtual float GetChunkProgress( uint32 ChunkID, EChunkProgressReportingType::Type ReportType ) = 0;
 
    virtual EChunkInstallSpeed::Type GetInstallSpeed() = 0;
    virtual bool SetInstallSpeed( EChunkInstallSpeed::Type InstallSpeed ) = 0;
    
    virtual bool PrioritizePakchunk( int32 PakchunkIndex, EChunkPriority::Type Priority ) = 0;
 
    virtual bool DebugStartNextChunk() = 0;
 
    virtual void ExternalNotifyChunkAvailable(uint32 InChunkID) = 0;
 
    virtual FDelegateHandle AddChunkInstallDelegate( FPlatformChunkInstallDelegate Delegate ) = 0;
 
    virtual void RemoveChunkInstallDelegate( FDelegateHandle Delegate ) = 0;
 
 
    virtual bool SupportsNamedChunkInstall() const = 0;
 
    virtual bool IsNamedChunkInProgress(const FName NamedChunk) = 0;
 
    virtual bool InstallNamedChunk(const FName NamedChunk) = 0;
 
    virtual bool UninstallNamedChunk(const FName NamedChunk) = 0;
 
    virtual bool InstallNamedChunks(const TArrayView<const FName>& NamedChunks) = 0;
 
    virtual bool UninstallNamedChunks(const TArrayView<const FName>& NamedChunks) = 0;
 
    virtual EChunkLocation::Type GetNamedChunkLocation(const FName NamedChunk) = 0;
 
    virtual float GetNamedChunkProgress(const FName NamedChunk, EChunkProgressReportingType::Type ReportType) = 0;
 
    virtual bool PrioritizeNamedChunk(const FName NamedChunk, EChunkPriority::Type Priority) = 0;
 
    virtual ENamedChunkType GetNamedChunkType(const FName NamedChunk) const = 0;
 
    virtual TArray<FName> GetNamedChunksByType(ENamedChunkType NamedChunkType) const = 0;
 
    virtual FDelegateHandle AddNamedChunkCompleteDelegate( FPlatformNamedChunkCompleteDelegate Delegate ) = 0;
 
    virtual void RemoveNamedChunkCompleteDelegate( FDelegateHandle Delegate ) = 0;
 
 
 
    virtual bool SupportsBundleSource() const = 0;
 
    virtual bool SetAutoPakMountingEnabled( bool bEnabled ) = 0;
    
    virtual bool GetPakFilesInNamedChunk( const FName NamedChunk, TArray<FString>& OutFilesInChunk) const = 0;
 
    virtual bool GetNamedChunkInstallationStatus( const FName NamedChunk, FChunkInstallationStatusDetail& OutChunkStatusDetail ) const = 0;
 
    virtual bool IsNamedChunkForCurrentLocale( const FName NamedChunk ) const = 0;
    
 
protected:
        virtual EChunkLocation::Type GetChunkLocation(uint32 ChunkID) = 0;
 
        virtual bool PrioritizeChunk(uint32 ChunkID, EChunkPriority::Type Priority) = 0;
 
};
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
class FGenericPlatformChunkInstall : public IPlatformChunkInstall
{
public:
    CORE_API virtual void AsyncInit( TFunction<void(bool/*bSuccess*/)> OnInitComplete ) override;
 
    virtual bool IsAvailable() const
    {
        return true;
    }
 
    virtual EChunkLocation::Type GetPakchunkLocation( int32 PakchunkIndex ) override
    {
        return GetChunkLocation(PakchunkIndex);
    }
 
    virtual bool PrioritizePakchunk(int32 PakchunkIndex, EChunkPriority::Type Priority)
    {
        return PrioritizeChunk(PakchunkIndex, Priority);
    }
 
    virtual bool GetProgressReportingTypeSupported(EChunkProgressReportingType::Type ReportType) override
    {
        if (ReportType == EChunkProgressReportingType::PercentageComplete)
        {
            return true;
        }
 
        return false;
    }
 
    virtual float GetChunkProgress( uint32 ChunkID, EChunkProgressReportingType::Type ReportType ) override
    {
        if (ReportType == EChunkProgressReportingType::PercentageComplete)
        {
            return 100.0f;
        }       
        return 0.0f;
    }
 
    virtual EChunkInstallSpeed::Type GetInstallSpeed() override
    {
        return EChunkInstallSpeed::Paused;
    }
 
    virtual bool SetInstallSpeed( EChunkInstallSpeed::Type InstallSpeed ) override
    {
        return false;
    }
    
    virtual bool PrioritizeChunk( uint32 ChunkID, EChunkPriority::Type Priority ) override
    {
        return false;
    }
 
    virtual bool DebugStartNextChunk() override
    {
        return true;
    }
 
    virtual void ExternalNotifyChunkAvailable(uint32 InChunkID) override
    {
        InstallDelegate.Broadcast(InChunkID, true);
    }
 
    virtual FDelegateHandle AddChunkInstallDelegate(FPlatformChunkInstallDelegate Delegate) override
    {
        return InstallDelegate.Add(Delegate);
    }
 
    virtual void RemoveChunkInstallDelegate(FDelegateHandle Delegate) override
    {
        InstallDelegate.Remove(Delegate);
    }
 
    virtual bool SupportsNamedChunkInstall() const override
    {
        return false;
    }
 
    virtual bool IsNamedChunkInProgress(const FName NamedChunk) override
    {
        return false;
    }
 
    virtual bool InstallNamedChunk(const FName NamedChunk) override
    {
        return InstallNamedChunks(MakeArrayView(&NamedChunk,1));
    }
 
    virtual bool UninstallNamedChunk(const FName NamedChunk) override
    {
        return UninstallNamedChunks(MakeArrayView(&NamedChunk,1));
    }
 
    virtual bool InstallNamedChunks(const TArrayView<const FName>& NamedChunks) override
    {
        return false;
    }
 
    virtual bool UninstallNamedChunks(const TArrayView<const FName>& NamedChunks) override
    {
        return false;
    }
 
    virtual EChunkLocation::Type GetNamedChunkLocation(const FName NamedChunk) override
    {
        return EChunkLocation::NotAvailable;
    }
 
    virtual float GetNamedChunkProgress(const FName NamedChunk, EChunkProgressReportingType::Type ReportType) override
    {
        return 0.0f;
    }
 
    virtual bool PrioritizeNamedChunk(const FName NamedChunk, EChunkPriority::Type Priority) override
    {
        return false;
    }
 
    virtual ENamedChunkType GetNamedChunkType(const FName NamedChunk) const override
    {
        return ENamedChunkType::Invalid;
    }
 
    virtual TArray<FName> GetNamedChunksByType(ENamedChunkType NamedChunkType) const override
    {
        return TArray<FName>();
    }
 
    virtual void RemoveNamedChunkCompleteDelegate(FDelegateHandle Delegate) override
    {
        NamedChunkCompleteDelegate.Remove(Delegate);
    }
 
    virtual FDelegateHandle AddNamedChunkCompleteDelegate(FPlatformNamedChunkCompleteDelegate Delegate) override
    {
        return NamedChunkCompleteDelegate.Add(Delegate);
    }
 
 
    virtual bool SupportsBundleSource() const override 
    { 
        return false; 
    }
 
    virtual bool SetAutoPakMountingEnabled( bool bEnabled ) 
    { 
        return false; 
    }
 
    virtual bool GetPakFilesInNamedChunk( const FName NamedChunk, TArray<FString>& OutFilesInChunk) const override 
    { 
        return false; 
    }
 
    virtual bool GetNamedChunkInstallationStatus( const FName NamedChunk, FChunkInstallationStatusDetail& OutChunkStatusDetail ) const override 
    { 
        return false; 
    }
 
    virtual bool IsNamedChunkForCurrentLocale( const FName NamedChunk ) const 
    { 
        return true; 
    }
 
protected:
 
    CORE_API void DoNamedChunkCompleteCallbacks( const FName NamedChunk, EChunkLocation::Type Location, bool bHasSucceeded ) const;
    CORE_API void DoNamedChunkCompleteCallbacks( const TArrayView<const FName>& NamedChunks, EChunkLocation::Type Location, bool bHasSucceeded ) const;
 
    FPlatformChunkInstallMultiDelegate InstallDelegate;
    FPlatformNamedChunkCompleteMultiDelegate NamedChunkCompleteDelegate;
 
    virtual EChunkLocation::Type GetChunkLocation(uint32 ChunkID) override
    {
        return EChunkLocation::LocalFast;
    }
};
 
 
 
PRAGMA_ENABLE_DEPRECATION_WARNINGS