PVROnlineSession.h

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#if ENGINE_MAJOR_VERSION >= 5
#include "Online/CoreOnline.h"
#else
#include "UObject/CoreOnline.h"
#endif
#include "Misc/ScopeLock.h"
#include "OnlineSessionSettings.h"
#include "OnlineDelegateMacros.h"
#include "Interfaces/OnlineSessionInterface.h"
#include "PVROBeacon.h"
#include "PVROFindServerTask.h"
#include "PVROMultiplayerSessionInfo.h"
#include "PVROPackage.h"
 
class FPVROSubsystem;
 
DECLARE_MULTICAST_DELEGATE(FOnFindSessionsStart);
typedef FOnFindSessionsStart::FDelegate FOnFindSessionsStartDelegate;
 
DECLARE_MULTICAST_DELEGATE(FOnJoinSessionStart);
typedef FOnJoinSessionStart::FDelegate FOnJoinSessionStartDelegate;
 
class FPVROnlineSession : public IOnlineSession
{
private:
 
    class FPVROSubsystem* Subsystem;
 
    FPVROSession LANSessionManager;
 
    FPVROnlineSession() :
        Subsystem(NULL),
        CurrentSessionSearch(NULL)
    {}
 
    void TickLanTasks(float DeltaTime);
 
    bool NeedsToAdvertise();
 
    bool NeedsToAdvertise( FNamedOnlineSession& Session );
 
    bool IsSessionJoinable( const FNamedOnlineSession& Session) const;
 
    uint32 UpdateLANStatus();
 
    uint32 JoinInternetSession(int32 PlayerNum, class FNamedOnlineSession* Session, const class FOnlineSession* SearchSession);
    
    uint32 FindInternetSession(const TSharedRef<FOnlineSessionSearch>& SearchSettings);
 
    uint32 FindLANSession(const TSharedRef<FOnlineSessionSearch>& SearchSettings);
 
    uint32 FinalizeLANSearch();
 
    void OnValidQueryPacketReceived(uint8* PacketData, int32 PacketLength, uint64 ClientNonce);
 
    void OnValidResponsePacketReceived(uint8* PacketData, int32 PacketLength);
 
    void OnLANSearchTimeout();
 
    static void SetPortFromNetDriver(const FPVROSubsystem& Subsystem, const TSharedPtr<FOnlineSessionInfo>& SessionInfo);
 
    bool IsHost(const FNamedOnlineSession& Session) const;
 
PACKAGE_SCOPE:
 
    TSharedPtr<FUniqueNetIdPixoVR> GameServerPixoVRId;
 
    mutable FCriticalSection SessionLock;
 
    TArray<FNamedOnlineSession> Sessions;
 
    TSharedPtr<FOnlineSessionSearch> CurrentSessionSearch;
 
    double SessionSearchStartTime;
    double SessionSearchEndTime;
 
    FPVROnlineSession(class FPVROSubsystem* InSubsystem);
 
    void Tick(float DeltaTime);
 
    void HandleMessageReceived(const FString& InJsonMessage);
 
    void CheckMatchesFound(TSharedPtr<FJsonObject>& JsonMessageObject);
 
    void GetHostAndPort(int32& Host, int32& Port, const FString& HostIP, const FString& HostPort);
 
    // IOnlineSession
    class FNamedOnlineSession* AddNamedSession(FName SessionName, const FOnlineSessionSettings& SessionSettings) override
    {
        FScopeLock ScopeLock(&SessionLock);
        return new (Sessions) FNamedOnlineSession(SessionName, SessionSettings);
    }
 
    class FNamedOnlineSession* AddNamedSession(FName SessionName, const FOnlineSession& Session) override
    {
        FScopeLock ScopeLock(&SessionLock);
        return new (Sessions) FNamedOnlineSession(SessionName, Session);
    }
 
    void CheckPendingSessionInvite();
 
    void RegisterVoice(const FUniqueNetId& PlayerId);
 
    void UnregisterVoice(const FUniqueNetId& PlayerId);
 
    void RegisterLocalPlayers(class FNamedOnlineSession* Session);
 
    void UnregisterLocalPlayers(class FNamedOnlineSession* Session);
 
 
    FString GetCustomDedicatedServerName() const;
 
    bool ClearSessionSearch(EOnlineAsyncTaskState::Type TaskState = EOnlineAsyncTaskState::Done);
 
public:
 
    virtual ~FPVROnlineSession() {}
 
    virtual TSharedPtr<const FUniqueNetId> CreateSessionIdFromString(const FString& SessionIdStr) override;
 
    int32 HostSessionPort;
    void OnSessionListenPortChanged(int32 Port);
 
    FNamedOnlineSession* GetFirstNamedSession()
    {
        FScopeLock ScopeLock(&SessionLock);
        if (Sessions.Num() > 0)
        {
            return &Sessions[0];
        }
        return NULL;
    }
 
    FNamedOnlineSession* GetNamedSession(FName SessionName) override
    {
        FScopeLock ScopeLock(&SessionLock);
        for (int32 SearchIndex = 0; SearchIndex < Sessions.Num(); SearchIndex++)
        {
            if (Sessions[SearchIndex].SessionName == SessionName)
            {
                return &Sessions[SearchIndex];
            }
        }
        return NULL;
    }
 
    virtual void RemoveNamedSession(FName SessionName) override
    {
        FScopeLock ScopeLock(&SessionLock);
        for (int32 SearchIndex = 0; SearchIndex < Sessions.Num(); SearchIndex++)
        {
            if (Sessions[SearchIndex].SessionName == SessionName)
            {
                Sessions.RemoveAtSwap(SearchIndex);
                return;
            }
        }
    }
 
    virtual EOnlineSessionState::Type GetSessionState(FName SessionName) const override
    {
        FScopeLock ScopeLock(&SessionLock);
        for (int32 SearchIndex = 0; SearchIndex < Sessions.Num(); SearchIndex++)
        {
            if (Sessions[SearchIndex].SessionName == SessionName)
            {
                return Sessions[SearchIndex].SessionState;
            }
        }
 
        return EOnlineSessionState::NoSession;
    }
 
    virtual bool HasPresenceSession() override
    {
        FScopeLock ScopeLock(&SessionLock);
        for (int32 SearchIndex = 0; SearchIndex < Sessions.Num(); SearchIndex++)
        {
            if (Sessions[SearchIndex].SessionSettings.bUsesPresence)
            {
                return true;
            }
        }
        
        return false;
    }
 
    uint32 CreateInternetSession(int32 HostingPlayerNum, FNamedOnlineSession* Session);
    uint32 CreateLANSession(int32 HostingPlayerNum, FNamedOnlineSession* Session);
    uint32 DestroyInternetSession(FNamedOnlineSession* Session, const FOnDestroySessionCompleteDelegate& CompletionDelegate = FOnDestroySessionCompleteDelegate());
    uint32 DestroyLANSession(FName SessionName, const FOnDestroySessionCompleteDelegate& CompletionDelegate = FOnDestroySessionCompleteDelegate());
    uint32 EndInternetSession(FNamedOnlineSession* Session);
 
    // IOnlineSession
    virtual bool CreateSession(int32 HostingPlayerNum, FName SessionName, const FOnlineSessionSettings& NewSessionSettings) override;
    virtual bool CreateSession(const FUniqueNetId& HostingPlayerId, FName SessionName, const FOnlineSessionSettings& NewSessionSettings) override;
    virtual bool StartSession(FName SessionName) override;
    virtual bool UpdateSession(FName SessionName, FOnlineSessionSettings& UpdatedSessionSettings, bool bShouldRefreshOnlineData = true) override;
    virtual bool EndSession(FName SessionName) override;
    virtual bool DestroySession(FName SessionName, const FOnDestroySessionCompleteDelegate& CompletionDelegate = FOnDestroySessionCompleteDelegate()) override;
    virtual bool IsPlayerInSession(FName SessionName, const FUniqueNetId& UniqueId) override;
    virtual bool StartMatchmaking(const TArray< TSharedRef<const FUniqueNetId> >& LocalPlayers, FName SessionName, const FOnlineSessionSettings& NewSessionSettings, TSharedRef<FOnlineSessionSearch>& SearchSettings) override;
    virtual bool CancelMatchmaking(int32 SearchingPlayerNum, FName SessionName) override;
    virtual bool CancelMatchmaking(const FUniqueNetId& SearchingPlayerId, FName SessionName) override;
    virtual bool FindSessions(int32 SearchingPlayerNum, const TSharedRef<FOnlineSessionSearch>& SearchSettings) override;
    virtual bool FindSessions(const FUniqueNetId& SearchingPlayerId, const TSharedRef<FOnlineSessionSearch>& SearchSettings) override;
    virtual bool FindSessionById(const FUniqueNetId& SearchingUserId, const FUniqueNetId& SessionId, const FUniqueNetId& FriendId, const FOnSingleSessionResultCompleteDelegate& CompletionDelegate) override;
    virtual bool CancelFindSessions() override;
    virtual bool PingSearchResults(const FOnlineSessionSearchResult& SearchResult) override;
    virtual bool JoinSession(int32 PlayerNum, FName SessionName, const FOnlineSessionSearchResult& DesiredSession) override;
    virtual bool JoinSession(const FUniqueNetId& PlayerId, FName SessionName, const FOnlineSessionSearchResult& DesiredSession) override;
    virtual bool FindFriendSession(int32 LocalUserNum, const FUniqueNetId& Friend) override;
    virtual bool FindFriendSession(const FUniqueNetId& LocalUserId, const FUniqueNetId& Friend) override;
    virtual bool FindFriendSession(const FUniqueNetId& LocalUserId, const TArray<TSharedRef<const FUniqueNetId>>& FriendList) override;
    virtual bool SendSessionInviteToFriend(int32 LocalUserNum, FName SessionName, const FUniqueNetId& Friend) override;
    virtual bool SendSessionInviteToFriend(const FUniqueNetId& LocalUserId, FName SessionName, const FUniqueNetId& Friend) override;
    virtual bool SendSessionInviteToFriends(int32 LocalUserNum, FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Friends) override;
    virtual bool SendSessionInviteToFriends(const FUniqueNetId& LocalUserId, FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Friends) override;
    virtual bool GetResolvedConnectString(FName SessionName, FString& ConnectInfo, FName PortType) override;
    virtual bool GetResolvedConnectString(const FOnlineSessionSearchResult& SearchResult, FName PortType, FString& ConnectInfo) override;
    virtual FOnlineSessionSettings* GetSessionSettings(FName SessionName) override;
    virtual bool RegisterPlayer(FName SessionName, const FUniqueNetId& PlayerId, bool bWasInvited) override;
    virtual bool RegisterPlayers(FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Players, bool bWasInvited = false) override;
    virtual bool UnregisterPlayer(FName SessionName, const FUniqueNetId& PlayerId) override;
    virtual bool UnregisterPlayers(FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Players) override;
    virtual void RegisterLocalPlayer(const FUniqueNetId& PlayerId, FName SessionName, const FOnRegisterLocalPlayerCompleteDelegate& Delegate) override;
    virtual void UnregisterLocalPlayer(const FUniqueNetId& PlayerId, FName SessionName, const FOnUnregisterLocalPlayerCompleteDelegate& Delegate) override;
    virtual int32 GetNumSessions() override;
    virtual void DumpSessionState() override;
 
public:
 
    DEFINE_ONLINE_DELEGATE(OnFindSessionsStart);
    DEFINE_ONLINE_DELEGATE(OnJoinSessionStart);
};
 
typedef TSharedPtr<FPVROnlineSession, ESPMode::ThreadSafe> FPVROnlineSessionPtr;