LwsWebSocket.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/Ticker.h"
#include "Containers/Queue.h"
#include "Misc/TransactionallySafeCriticalSection.h"
 
#if WITH_WEBSOCKETS && WITH_LIBWEBSOCKETS
 
#include "IWebSocket.h"
 
#if PLATFORM_WINDOWS
#   include "Windows/AllowWindowsPlatformTypes.h"
#endif
 
THIRD_PARTY_INCLUDES_START
#include "libwebsockets.h"
THIRD_PARTY_INCLUDES_END
 
#if PLATFORM_WINDOWS
#   include "Windows/HideWindowsPlatformTypes.h"
#endif
 
struct FLwsSendBuffer
{
    FLwsSendBuffer(const uint8* Data, const SIZE_T Size, const bool bInIsBinary);
 
    int32 GetPayloadSize() const;
 
    bool IsDone() const { return !HasError() && BytesWritten >= GetPayloadSize(); }
 
    bool HasError() const { return bHasError; }
 
    const bool bIsBinary;
    int32 BytesWritten;
    TArray<uint8> Payload;
    bool bHasError;
};
 
struct FLwsReceiveBufferBinary
{
    FLwsReceiveBufferBinary(const uint8* Data, const int32 Size, const int32 InBytesRemaining);
 
    TArray<uint8> Payload;
    const int32 BytesRemaining;
};
 
typedef TUniquePtr<FLwsReceiveBufferBinary> FLwsReceiveBufferBinaryPtr;
 
struct FLwsReceiveBufferBinaryFragment
{
    FLwsReceiveBufferBinaryFragment(const uint8* Data, const int32 Size, const bool bInIsLastFragment);
 
    TArray<uint8> Payload;
    const bool bIsLastFragment;
};
 
typedef TUniquePtr<FLwsReceiveBufferBinaryFragment> FLwsReceiveBufferBinaryFragmentPtr;
 
struct FLwsReceiveBufferText
{
    FLwsReceiveBufferText(FString&& InText);
 
    const FString Text;
};
 
typedef TUniquePtr<FLwsReceiveBufferText> FLwsReceiveBufferTextPtr;
 
class FLwsWebSocketsManager;
 
class FLwsWebSocket
    : public IWebSocket
    , public TSharedFromThis<FLwsWebSocket>
{
 
public:
    virtual ~FLwsWebSocket();
 
    // IWebSocket
    virtual void Connect() override;
    virtual void Close(const int32 Code = 1000, const FString& Reason = FString()) override;
 
    virtual bool IsConnected() override
    {
        return LastGameThreadState == EState::Connected || LastGameThreadState == EState::ClosingByRequest;
    }
 
    virtual void Send(const FString& Data);
    virtual void Send(const void* Data, SIZE_T Size, bool bIsBinary) override;
    virtual void SetTextMessageMemoryLimit(uint64 TextMessageMemoryLimit) override;
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketConnectedEvent, FWebSocketConnectedEvent);
    virtual FWebSocketConnectedEvent& OnConnected() override
    {
        return ConnectedEvent;
    }
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketConnectionErrorEvent, FWebSocketConnectionErrorEvent);
    virtual FWebSocketConnectionErrorEvent& OnConnectionError() override
    {
        return ConnectionErrorEvent;
    }
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketClosedEvent, FWebSocketClosedEvent);
    virtual FWebSocketClosedEvent& OnClosed() override
    {
        return ClosedEvent;
    }
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketMessageEvent, FWebSocketMessageEvent);
    virtual FWebSocketMessageEvent& OnMessage() override
    {
        return MessageEvent;
    }
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketBinaryMessageEvent, FWebSocketBinaryMessageEvent);
    virtual FWebSocketBinaryMessageEvent& OnBinaryMessage() override
    {
        return BinaryMessageEvent;
    }
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketRawMessageEvent, FWebSocketRawMessageEvent);
    virtual FWebSocketRawMessageEvent& OnRawMessage() override
    {
        return RawMessageEvent;
    }
 
 
    DECLARE_DERIVED_EVENT(FLwsWebSocket, IWebSocket::FWebSocketMessageSentEvent, FWebSocketMessageSentEvent);
    virtual FWebSocketMessageSentEvent& OnMessageSent() override
    {
        return OnMessageSentEvent;
    }
 
    int LwsCallback(lws* Instance, lws_callback_reasons Reason, void* Data, size_t Length);
 
    void GameThreadTick();
 
    void GameThreadFinalize();
 
    bool LwsThreadInitialize(struct lws_context &LwsContext);
 
    void LwsThreadTick();
 
private:
    // Private token only allows members or friends to call MakeShared
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
    friend class FLwsWebSocketsManager;
 
public:
    FLwsWebSocket(FPrivateToken, const FString& Url, const TArray<FString>& Protocols, const FString& UpgradeHeader, uint64 TextMessageMemoryLimit);
 
private:
    void ConnectInternal(struct lws_context &LwsContext);
 
    void SendFromQueue();
 
    void ClearData();
 
    bool WriteBuffer(FLwsSendBuffer& Buffer);
 
private:
 
    FTransactionallySafeCriticalSection StateLock;
 
    enum class EState : uint8
    {
        None,
        StartConnecting,
        Connecting,
        Connected,
        ClosingByRequest,
        Closed,
        Error,
    };
    
    static const TCHAR* ToString(const EState InState);
 
    struct FClosedReason
    {
        FString Reason;
        uint16 CloseStatus;
        bool bWasClean;
    };
 
    EState State;
    FClosedReason ClosedReason;
    EState LastGameThreadState;
 
    struct FCloseRequest
    {
        FCloseRequest() : Code(0), Reason(nullptr) {}
 
        int32 Code;
        ANSICHAR *Reason;
    };
 
    FCloseRequest CloseRequest;
 
    bool bWasSendQueueEmpty;
 
    // Events
    FWebSocketConnectedEvent ConnectedEvent;
    FWebSocketConnectionErrorEvent ConnectionErrorEvent;
    FWebSocketClosedEvent ClosedEvent;
    FWebSocketMessageEvent MessageEvent;
    FWebSocketBinaryMessageEvent BinaryMessageEvent;
    FWebSocketRawMessageEvent RawMessageEvent;
    FWebSocketMessageSentEvent OnMessageSentEvent;
 
    struct lws *LwsConnection;
    FString Url;
    TArray<FString> Protocols;
    FString UpgradeHeader;
 
    bool bWantsMessageEvents;
    bool bWantsRawMessageEvents;
    bool bWantsBinaryMessageEvents;
 
 
    FString ReceiveBuffer;
    TQueue<FLwsReceiveBufferBinaryPtr, EQueueMode::Spsc> ReceiveBinaryQueue;
    TQueue<FLwsReceiveBufferBinaryFragmentPtr, EQueueMode::Spsc> ReceiveBinaryFragmentQueue;
    TQueue<FLwsReceiveBufferTextPtr, EQueueMode::Spsc> ReceiveTextQueue;
    TQueue<FLwsSendBuffer*, EQueueMode::Spsc> SendQueue;
 
    uint64 MaxTextMessageBufferSize;
 
    // Unique identifier for logging
    static int32 IncrementingIdentifier;
    const int32 Identifier;
};
 
typedef TSharedRef<FLwsWebSocket> FLwsWebSocketRef;
 
#endif