HttpModule.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/PlatformMath.h"
#include "Interfaces/IHttpRequest.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CoreMisc.h"
#include "Modules/ModuleInterface.h"
#include "Templates/SharedPointer.h"
 
class FHttpManager;
class FOutputDevice;
class IHttpRequest;
class UWorld;
 
class FHttpModule : 
    public IModuleInterface, public FSelfRegisteringExec
{
 
protected:
 
    // FSelfRegisteringExec
 
    HTTP_API virtual bool Exec_Runtime(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
 
public:
 
    bool HandleHTTPCommand( const TCHAR* Cmd, FOutputDevice& Ar );
 
    // FHttpModule
 
    HTTP_API static FHttpModule& Get();
 
    HTTP_API void UpdateConfigs();
 
    HTTP_API virtual TSharedRef<IHttpRequest, ESPMode::ThreadSafe> CreateRequest();
 
    inline FHttpManager& GetHttpManager()
    {
        check(HttpManager != NULL);
        return *HttpManager;
    }
 
    inline float GetHttpTotalTimeout() const
    {
        return HttpTotalTimeout;
    }
 
    inline float GetHttpConnectionTimeout() const
    {
        return HttpConnectionTimeout;
    }
 
    inline float GetHttpActivityTimeout() const
    {
        return HttpActivityTimeout;
    }
 
    inline int32 GetHttpMaxConnectionsPerServer() const
    {
        return HttpMaxConnectionsPerServer;
    }
 
    inline int32 GetMaxReadBufferSize() const
    {
        return MaxReadBufferSize;
    }
 
    inline void SetMaxReadBufferSize(int32 SizeInBytes)
    {
        MaxReadBufferSize = SizeInBytes;
    }
 
    inline bool IsHttpEnabled() const
    {
        return bEnableHttp;
    }
 
    inline void ToggleNullHttp(bool bEnabled)
    {
        bUseNullHttp = bEnabled;
    }
 
    inline bool IsNullHttpEnabled() const
    {
        return bUseNullHttp;
    }
 
    inline float GetHttpDelayTime() const
    {
        return HttpDelayTime;
    }
 
    inline void SetHttpDelayTime(float InHttpDelayTime)
    {
        HttpDelayTime = InHttpDelayTime;
    }
 
    inline float GetHttpThreadActiveFrameTimeInSeconds() const
    {
        return HttpThreadActiveFrameTimeInSeconds;
    }
 
    inline void SetHttpThreadActiveFrameTimeInSeconds(float InHttpThreadActiveFrameTimeInSeconds)
    {
        HttpThreadActiveFrameTimeInSeconds = InHttpThreadActiveFrameTimeInSeconds;
    }
 
    inline float GetHttpThreadActiveMinimumSleepTimeInSeconds() const
    {
        return HttpThreadActiveMinimumSleepTimeInSeconds;
    }
 
    inline void SetHttpThreadActiveMinimumSleepTimeInSeconds(float InHttpThreadActiveMinimumSleepTimeInSeconds)
    {
        HttpThreadActiveMinimumSleepTimeInSeconds = InHttpThreadActiveMinimumSleepTimeInSeconds;
    }
 
    inline float GetHttpThreadIdleFrameTimeInSeconds() const
    {
        return HttpThreadIdleFrameTimeInSeconds;
    }
 
    inline void SetHttpThreadIdleFrameTimeInSeconds(float InHttpThreadIdleFrameTimeInSeconds)
    {
        HttpThreadIdleFrameTimeInSeconds = InHttpThreadIdleFrameTimeInSeconds;
    }
 
    inline float GetHttpThreadIdleMinimumSleepTimeInSeconds() const
    {
        return HttpThreadIdleMinimumSleepTimeInSeconds;
    }
 
    inline void SetHttpThreadIdleMinimumSleepTimeInSeconds(float InHttpThreadIdleMinimumSleepTimeInSeconds)
    {
        HttpThreadIdleMinimumSleepTimeInSeconds = InHttpThreadIdleMinimumSleepTimeInSeconds;
    }
 
    inline float GetHttpEventLoopThreadTickIntervalInSeconds() const
    {
        return HttpEventLoopThreadTickIntervalInSeconds;
    }
 
    const TMap<FString, FString>& GetDefaultHeaders() const { return DefaultHeaders; }
 
    void AddDefaultHeader(const FString& HeaderName, const FString& HeaderValue) { DefaultHeaders.Emplace(HeaderName, HeaderValue); }
 
    inline const FString& GetProxyAddress() const
    {
        return ProxyAddress;
    }
 
    inline void SetProxyAddress(const FString& InProxyAddress)
    {
        ProxyAddress = InProxyAddress;
    }
 
    inline const FString& GetHttpNoProxy() const
    {
        return HttpNoProxy;
    }
 
    inline bool SupportsDynamicProxy() const
    {
        return bSupportsDynamicProxy;
    }
 
    // IModuleInterface
 
    HTTP_API virtual void StartupModule() override;
 
    HTTP_API virtual void PostLoadCallback() override;
    
    HTTP_API virtual void PreUnloadCallback() override;
 
    HTTP_API virtual void ShutdownModule() override;
 
protected:
    float HttpConnectionTimeout;
    float HttpTotalTimeout;
    float HttpActivityTimeout;
 
private:
    void OnConfigSectionsChanged(const FString& IniFilename, const TSet<FString>& SectionNames);
 
    FHttpManager* HttpManager = nullptr;
    float HttpReceiveTimeout;
    float HttpSendTimeout;
    float HttpDelayTime;
    float HttpThreadActiveFrameTimeInSeconds;
    float HttpThreadActiveMinimumSleepTimeInSeconds;
    float HttpThreadIdleFrameTimeInSeconds;
    float HttpThreadIdleMinimumSleepTimeInSeconds;
    float HttpEventLoopThreadTickIntervalInSeconds;
    int32 HttpMaxConnectionsPerServer;
    int32 MaxReadBufferSize;
    bool bEnableHttp;
    bool bUseNullHttp;
    TMap<FString, FString> DefaultHeaders;
    static FHttpModule* Singleton;
    FString ProxyAddress;
    FString HttpNoProxy;
    bool bSupportsDynamicProxy;
    TArray<FString> AllowedDomains;
};