PVROnlineSession.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "PVROnlineSession.h"
#include "Misc/Guid.h"
#include "OnlineSubsystem.h"
#include "PVROSubsystem.h"
#include "PVROMultiplayerSessionInfo.h"
#include "OnlineSubsystem.h"
#include "OnlineSubsystemUtils.h"
#include "OnlineAsyncTaskManager.h"
#include "SocketSubsystem.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "JsonObjectConverter.h"
#include "MultiplayerTypes.h"
 
#if ENGINE_MAJOR_VERSION >= 5
#include "Online/OnlineBase.h"
#include "Online/OnlineSessionNames.h"
#include "IPAddress.h"
#endif
 
#define MAX_PUBLIC_CONNECTIONS 2048
 
DEFINE_LOG_CATEGORY_STATIC(LogPVROnlineSession, Log, All);
 
#define Log(pmt, ...) UE_LOG(LogPVROnlineSession, Log, TEXT(pmt), ##__VA_ARGS__)
#define Warn(pmt, ...) UE_LOG(LogPVROnlineSession, Warning, TEXT(pmt), ##__VA_ARGS__)
#define Error(pmt, ...) UE_LOG(LogPVROnlineSession, Error, TEXT(pmt), ##__VA_ARGS__)
#define Fatal(pmt, ...) UE_LOG(LogPVROnlineSession, Fatal, TEXT(pmt), ##__VA_ARGS__)
 
FPVROSessionInfo::FPVROSessionInfo() :
    HostAddr(nullptr),
#if ENGINE_MAJOR_VERSION >= 5
    SessionId(FUniqueNetIdPixoVR::Create(TEXT("INVALID")).Get())
#else
    SessionId(TEXT("INVALID"))
#endif
{
}
 
void FPVROSessionInfo::Init(const FPVROSubsystem& Subsystem)
{
    // Read the IP from the system
    bool bCanBindAll=false;
    HostAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLocalHostAddr(*GLog, bCanBindAll);
 
    // The below is a workaround for systems that set hostname to a distinct address from 127.0.0.1 on a loopback interface.
    // See e.g. https://www.debian.org/doc/manuals/debian-reference/ch05.en.html#_the_hostname_resolution
    // and http://serverfault.com/questions/363095/why-does-my-hostname-appear-with-the-address-127-0-1-1-rather-than-127-0-0-1-in
    // Since we bind to 0.0.0.0, we won't answer on 127.0.1.1, so we need to advertise ourselves as 127.0.0.1 for any other loopback address we may have.
    uint32 HostIp = 0;
    HostAddr->GetIp(HostIp); // will return in host order
    // if this address is on loopback interface, advertise it as 127.0.0.1
    if ((HostIp & 0xff000000) == 0x7f000000)
    {
        HostAddr->SetIp(0x7f000001);    // 127.0.0.1
    }
 
    // Now set the port that was configured
    HostAddr->SetPort(GetPortFromNetDriver(Subsystem.GetInstanceName()));
 
    FGuid OwnerGuid;
    FPlatformMisc::CreateGuid(OwnerGuid);
 
#if ENGINE_MAJOR_VERSION >= 5
    SessionId = FUniqueNetIdPixoVR::Create(OwnerGuid.ToString()).Get();
#else
    SessionId = FUniqueNetIdPixoVR(OwnerGuid.ToString());
#endif
    Log("Session ID is %s.", *SessionId.ToString());
}
 
FPVROnlineSession::FPVROnlineSession(class FPVROSubsystem* InSubsystem) :
    Subsystem(InSubsystem),
    CurrentSessionSearch(nullptr),
    SessionSearchStartTime(0),
    SessionSearchEndTime(0)
{
    Subsystem->WebSocket.OnWebSocketConnectFailed().AddLambda([&](const FString& ErrorMessage) ->
        void { CancelFindSessions(); }
    );
    Subsystem->WebSocket.OnWebSocketDisconnected().AddLambda([&](int32 StatusCode, const FString& Reason, bool bWasClean) ->
        void { if (StatusCode != 1006) { CancelFindSessions(); } }
    );
    Subsystem->WebSocket.OnWebSocketMessageReceived().AddLambda([&](const FString& Message) ->
        void { HandleMessageReceived(Message); }
    );
}
 
void FPVROnlineSession::HandleMessageReceived(const FString& InJsonMessage)
{
    TSharedPtr<FJsonObject> JsonMessageObject = MakeShareable(new FJsonObject);
    TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(*InJsonMessage);
 
    if (!FJsonSerializer::Deserialize(Reader, JsonMessageObject))
    {
        Log("Failed to deserialize the websocket message.");
        bool bHasCurrentSearch = CurrentSessionSearch.IsValid() ? (CurrentSessionSearch->SearchState == EOnlineAsyncTaskState::InProgress) : false;
        TriggerOnFindSessionsCompleteDelegates(false);
    }
    else
    {
        Log("Successfully deserialized the websocket message.")
        bool bHasError = JsonMessageObject->GetBoolField("error");
        if (!bHasError)
        {
            Log("Doesn't have an error. Checking to see if we found a match.");
            FString Message = JsonMessageObject->GetStringField("message");
 
            if (Message.Equals("match found", ESearchCase::IgnoreCase))
            {
                Log("Found a match!");
                SessionSearchEndTime = FPlatformTime::Seconds();
                CheckMatchesFound(JsonMessageObject);
                ClearSessionSearch();
            }
        }
        else
        {
            FString ErrorMessage = JsonMessageObject->GetStringField("message");
            Log("Websocket error: %s", *ErrorMessage);
            CancelFindSessions();
        }
    }
}
 
void FPVROnlineSession::CheckMatchesFound(TSharedPtr<FJsonObject>& JsonMessageObject)
{
    FMatchDetails FoundMatchDetails;
    TSharedPtr<FJsonObject> MatchDetailsObject = JsonMessageObject->GetObjectField("matchDetails");
 
    if (!CurrentSessionSearch)
    {
        Error("The current search has been lost.");
        TriggerOnFindSessionsCompleteDelegates(false);
        return;
    }
 
    if (FJsonObjectConverter::JsonObjectToUStruct<FMatchDetails>(MatchDetailsObject.ToSharedRef(), &FoundMatchDetails))
    {
        Log("Parsed the match details.");
        int32 PingInMs = static_cast<int32>((SessionSearchEndTime - SessionSearchStartTime) * 1000);
 
        FOnlineSessionSearchResult* SearchResult = new (CurrentSessionSearch->SearchResults) FOnlineSessionSearchResult();
        SearchResult->PingInMs = PingInMs;
        FOnlineSession* NewSession = &SearchResult->Session;
 
        FPVROSessionInfo* SessionInfo = new FPVROSessionInfo();
        SessionInfo->HostAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
#if ENGINE_MAJOR_VERSION >= 5
        SessionInfo->SessionId = FUniqueNetIdPixoVR::Create(FoundMatchDetails.SessionID).Get();
#else
        SessionInfo->SessionId = FUniqueNetIdPixoVR(FoundMatchDetails.SessionID);
#endif
        int32 HostAddress = 0;
        int32 HostPort = 0;
 
        GetHostAndPort(HostAddress, HostPort, FoundMatchDetails.IPAddress, FoundMatchDetails.Port);
        SessionInfo->HostAddr->SetIp(HostAddress);
        SessionInfo->HostAddr->SetPort(HostPort);
        NewSession->SessionSettings.Set(SETTING_MAPNAME, FoundMatchDetails.MapName);
        NewSession->OwningUserName = FoundMatchDetails.OwningUserName;
 
        NewSession->SessionSettings.NumPublicConnections = MAX_PUBLIC_CONNECTIONS;
        NewSession->SessionSettings.NumPrivateConnections = MAX_PUBLIC_CONNECTIONS;
        NewSession->NumOpenPublicConnections = MAX_PUBLIC_CONNECTIONS;
        NewSession->NumOpenPrivateConnections = MAX_PUBLIC_CONNECTIONS;
 
        NewSession->SessionInfo = MakeShareable(SessionInfo);
 
        TriggerOnFindSessionsCompleteDelegates(true);
    }
    else
    {
        TriggerOnFindSessionsCompleteDelegates(false);
    }
}
 
uint32 FPVROnlineSession::CreateInternetSession(int32 HostingPlayerNum, FNamedOnlineSession* Session)
{
    check(Session);
 
    return PVRO_SUCCESS;
}
 
uint32 FPVROnlineSession::CreateLANSession(int32 HostingPlayerNum, FNamedOnlineSession* Session)
{
    check(Session);
    uint32 Result = PVRO_SUCCESS;
 
    if (LANSessionManager.GetBeaconState() != ELanBeaconState::Searching)
    {
        if (Sessions.Num() > 0)
        {
            LANSessionManager.IsLANMatch = true;
 
            FOnValidQueryPacketDelegate QueryPacketDelegate = FOnValidQueryPacketDelegate::CreateRaw(this, &FPVROnlineSession::OnValidQueryPacketReceived);
            FOnPortChangedDelegate PortChangedDelegate = FOnPortChangedDelegate::CreateRaw(this, &FPVROnlineSession::OnSessionListenPortChanged);
            //TODO: if its a LAN Connection just send port 1 for now, maybe change this...
            if (!LANSessionManager.Host(QueryPacketDelegate))
            {
                Result = PVRO_FAIL;
 
                LANSessionManager.StopLANSession();
            }
 
            Result = PVRO_SUCCESS;
        }
    }
 
    return Result;
}
 
bool FPVROnlineSession::CreateSession(int32 HostingPlayerNum, FName SessionName, const FOnlineSessionSettings& NewSessionSettings)
{
    uint32 Result = PVRO_FAIL;
 
    // Check for an existing session
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session == nullptr)
    {
        // Create a new session and deep copy the game settings
        Session = AddNamedSession(SessionName, NewSessionSettings);
        check(Session);
        Session->SessionState = EOnlineSessionState::Creating;
        Session->HostingPlayerNum = HostingPlayerNum;
 
        check(Subsystem);
 
        IOnlineIdentityPtr Identity = Subsystem->GetIdentityInterface();
        if (Identity.IsValid())
        {
            Session->OwningUserId = Identity->GetUniquePlayerId(HostingPlayerNum);
            Session->OwningUserName = Identity->GetPlayerNickname(HostingPlayerNum);
        }
 
        // if did not get a valid one, use just something
        if (!Session->OwningUserId.IsValid())
        {
#if ENGINE_MAJOR_VERSION >= 5
            Session->OwningUserId = FUniqueNetIdPixoVR::Create(FString::Printf(TEXT("%d"), HostingPlayerNum)).ToSharedPtr();
#else
            Session->OwningUserId = MakeShareable(new FUniqueNetIdPixoVR(FString::Printf(TEXT("%d"), HostingPlayerNum)));
#endif
            // We should fill this in with the users name from Apex somehow or somehow otherwise set.
            Session->OwningUserName = FString(TEXT("PVROUserName"));
        }
        
        // Unique identifier of this build for compatibility
        Session->SessionSettings.BuildUniqueId = GetBuildUniqueId();
 
        // Setup the host session info
        FPVROSessionInfo* NewSessionInfo = new FPVROSessionInfo();
        NewSessionInfo->Init(*Subsystem);
        Session->SessionInfo = MakeShareable(NewSessionInfo);
 
        // Create Internet or LAN match.
        if (NewSessionSettings.bIsLANMatch)
        {
            Result = CreateLANSession(HostingPlayerNum, Session);
        }
        else
        {
            Result = CreateInternetSession(HostingPlayerNum, Session);
        }
 
        if (Result != PVRO_IO_PENDING)
        {
            // Set the game state as pending (not started)
            Session->SessionState = EOnlineSessionState::Pending;
 
            if (Result != PVRO_SUCCESS)
            {
                // Clean up the session info so we don't get into a confused state
                RemoveNamedSession(SessionName);
            }
            else
            {
                RegisterLocalPlayers(Session);
            }
        }
    }
    else
    {
        Warn("Cannot create session '%s': session already exists.", *SessionName.ToString());
    }
 
    if (Result != PVRO_IO_PENDING)
    {
        TriggerOnCreateSessionCompleteDelegates(SessionName, (Result == PVRO_SUCCESS) ? true : false);
    }
    
    return Result == PVRO_IO_PENDING || Result == PVRO_SUCCESS;
}
 
bool FPVROnlineSession::CreateSession(const FUniqueNetId& HostingPlayerId, FName SessionName, const FOnlineSessionSettings& NewSessionSettings)
{
    // todo: use proper HostingPlayerId
    return CreateSession(0, SessionName, NewSessionSettings);
}
 
bool FPVROnlineSession::NeedsToAdvertise()
{
    FScopeLock ScopeLock(&SessionLock);
 
    bool bResult = false;
    for (int32 SessionIdx=0; SessionIdx < Sessions.Num(); SessionIdx++)
    {
        FNamedOnlineSession& Session = Sessions[SessionIdx];
        if (NeedsToAdvertise(Session))
        {
            bResult = true;
            break;
        }
    }
 
    return bResult;
}
 
bool FPVROnlineSession::NeedsToAdvertise( FNamedOnlineSession& Session )
{
    return Session.SessionSettings.bShouldAdvertise && IsHost(Session) &&
        (
            (
              !Session.SessionSettings.bIsLANMatch &&             
              (Session.SessionState != EOnlineSessionState::InProgress || (Session.SessionSettings.bAllowJoinInProgress && Session.NumOpenPublicConnections > 0))
            ) 
            ||
            (
                Session.SessionSettings.bAllowJoinViaPresence || Session.SessionSettings.bAllowJoinViaPresenceFriendsOnly
            )
        );      
}
 
bool FPVROnlineSession::IsSessionJoinable(const FNamedOnlineSession& Session) const
{
    const FOnlineSessionSettings& Settings = Session.SessionSettings;
 
    // LAN beacons are implicitly advertised.
    const bool bIsAdvertised = Settings.bShouldAdvertise || Settings.bIsLANMatch;
    const bool bIsMatchInProgress = Session.SessionState == EOnlineSessionState::InProgress;
 
    const bool bJoinableFromProgress = (!bIsMatchInProgress || Settings.bAllowJoinInProgress);
 
    const bool bAreSpacesAvailable = Session.NumOpenPublicConnections > 0;
 
    // LAN matches don't care about private connections / invites.
    // LAN matches don't care about presence information.
    return bIsAdvertised && bJoinableFromProgress && bAreSpacesAvailable;
}
 
uint32 FPVROnlineSession::UpdateLANStatus()
{
    uint32 Result = ONLINE_SUCCESS;
 
    if ( NeedsToAdvertise() )
    {
        // set up LAN session
        if (LANSessionManager.GetBeaconState() == ELanBeaconState::NotUsingLanBeacon)
        {
            FOnValidQueryPacketDelegate QueryPacketDelegate = FOnValidQueryPacketDelegate::CreateRaw(this, &FPVROnlineSession::OnValidQueryPacketReceived);
            if (!LANSessionManager.Host(QueryPacketDelegate))
            {
                Result = ONLINE_FAIL;
 
                LANSessionManager.StopLANSession();
            }
        }
    }
    else
    {
        if (LANSessionManager.GetBeaconState() != ELanBeaconState::Searching)
        {
            // Tear down the LAN beacon
            LANSessionManager.StopLANSession();
        }
    }
 
    return Result;
}
 
void FPVROnlineSession::OnSessionListenPortChanged(int32 Port)
{
    HostSessionPort = Port;
}
 
bool FPVROnlineSession::StartSession(FName SessionName)
{
    Log("Starting session %s.", *SessionName.ToString());
    uint32 Result = PVRO_FAIL;
    // Grab the session information by name
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        // Can't start a match multiple times
        if (Session->SessionState == EOnlineSessionState::Pending ||
            Session->SessionState == EOnlineSessionState::Ended)
        {
            if (!Session->SessionSettings.bIsLANMatch)
            {
                Result = PVRO_SUCCESS;
                Session->SessionState = EOnlineSessionState::InProgress;
            }
            else
            {
                // If this lan match has join in progress disabled, shut down the beacon
                if (!Session->SessionSettings.bAllowJoinInProgress)
                {
                    Result = UpdateLANStatus();
                }
                Result = PVRO_SUCCESS;
                Session->SessionState = EOnlineSessionState::InProgress;
            }
        }
        else
        {
            Warn("Can't start an online session (%s) in state %s.", *SessionName.ToString(), EOnlineSessionState::ToString(Session->SessionState));
        }
    }
    else
    {
        Warn("Can't start an online game for session (%s) that hasn't been created.", *SessionName.ToString());
    }
 
    if (Result != PVRO_IO_PENDING)
    {
        // Just trigger the delegate
        TriggerOnStartSessionCompleteDelegates(SessionName, (Result == PVRO_SUCCESS) ? true : false);
    }
 
    return Result == PVRO_SUCCESS || Result == PVRO_IO_PENDING;
}
 
bool FPVROnlineSession::UpdateSession(FName SessionName, FOnlineSessionSettings& UpdatedSessionSettings, bool bShouldRefreshOnlineData)
{
    bool bWasSuccessful = true;
 
    // Grab the session information by name
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        if (!Session->SessionSettings.bIsLANMatch)
        {
        }
        else
        {
            // @TODO ONLINE update LAN settings
            Session->SessionSettings = UpdatedSessionSettings;
            TriggerOnUpdateSessionCompleteDelegates(SessionName, bWasSuccessful);
        }
    }
 
    return bWasSuccessful;
}
 
bool FPVROnlineSession::EndSession(FName SessionName)
{
    Warn("Ending session %s.", *SessionName.ToString());
 
    uint32 Result = PVRO_FAIL;
 
    // Grab the session information by name
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        // Can't end a match that isn't in progress
        if (Session->SessionState == EOnlineSessionState::InProgress)
        {
            if (!Session->SessionSettings.bIsLANMatch)
            {
                Result = EndInternetSession(Session);
            }
            else
            {
                Session->SessionState = EOnlineSessionState::Ended;
 
                // If the session should be advertised and the lan beacon was destroyed, recreate
                Result = UpdateLANStatus();
            }
        }
        else
        {
            Warn("Can't end session (%s) in state %s.", *SessionName.ToString(), EOnlineSessionState::ToString(Session->SessionState));
        }
    }
    else
    {
        Warn("Can't end an online game for session (%s) that hasn't been created", *SessionName.ToString());
    }
 
    if (Result != PVRO_IO_PENDING)
    {
        if (Session)
        {
            Session->SessionState = EOnlineSessionState::Ended;
        }
 
        TriggerOnEndSessionCompleteDelegates(SessionName, (Result == PVRO_SUCCESS) ? true : false);
    }
 
    return Result == PVRO_SUCCESS || Result == PVRO_IO_PENDING;
}
 
uint32 FPVROnlineSession::EndInternetSession(FNamedOnlineSession* Session)
{
    return PVRO_SUCCESS;
}
 
bool FPVROnlineSession::DestroySession(FName SessionName, const FOnDestroySessionCompleteDelegate& CompletionDelegate)
{
    uint32 Result = PVRO_FAIL;
    // Find the session in question
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        if (Session->SessionState != EOnlineSessionState::Destroying)
        {
            if (Session->SessionState == EOnlineSessionState::InProgress)
            {
                // Enqueue all the end session tasks first
                EndInternetSession(Session);
            }
 
            Result = DestroyInternetSession(Session, CompletionDelegate);
 
            if (Result != PVRO_IO_PENDING)
            {
                // The session info is no longer needed
                RemoveNamedSession(Session->SessionName);
                CompletionDelegate.ExecuteIfBound(SessionName, (Result == PVRO_SUCCESS) ? true : false);
                TriggerOnDestroySessionCompleteDelegates(SessionName, (Result == PVRO_SUCCESS) ? true : false);
            }
        }
        else
        {
            Warn("Already in process of destroying session (%s).", *SessionName.ToString());
        }
    }
    else
    {
        if (Sessions.Num() > 0)
        {
            Warn("Can't destroy an online session that doesn't exist (%s).", *SessionName.ToString());
            CompletionDelegate.ExecuteIfBound(SessionName, false);
            TriggerOnDestroySessionCompleteDelegates(SessionName, false);
        }
        else
        {
            Error("There are no sessions to destroy.\nCheck against the Session Interface's Sessions before calling delete.\nWill not trigger OnDestroySession.");
        }
    }
 
    return Result == PVRO_SUCCESS || Result == PVRO_IO_PENDING;
}
 
uint32 FPVROnlineSession::DestroyInternetSession(FNamedOnlineSession* Session, const FOnDestroySessionCompleteDelegate& CompletionDelegate) 
{
    Session->SessionState = EOnlineSessionState::Destroying;
    if (Session->SessionInfo.IsValid())
    {
        if (GetNumSessions() == 0 || !Subsystem->IsDedicated())
        {
            IOnlineVoicePtr VoiceInt = Subsystem->GetVoiceInterface();
            if (VoiceInt.IsValid())
            {
                if (!Subsystem->IsDedicated())
                {
                    // Stop local talkers
                    VoiceInt->UnregisterLocalTalkers();
                }
 
                // Stop remote voice 
                VoiceInt->RemoveAllRemoteTalkers();
            }
        }
    }
 
    return PVRO_SUCCESS;
}
 
uint32 FPVROnlineSession::DestroyLANSession(FName SessionName, const FOnDestroySessionCompleteDelegate& CompletionDelegate)
{
    return UpdateLANStatus();
}
 
bool FPVROnlineSession::IsPlayerInSession(FName SessionName, const FUniqueNetId& UniqueId)
{
    return IsPlayerInSessionImpl(this, SessionName, UniqueId);
}
 
bool FPVROnlineSession::StartMatchmaking(const TArray< TSharedRef<const FUniqueNetId> >& LocalPlayers, FName SessionName, const FOnlineSessionSettings& NewSessionSettings, TSharedRef<FOnlineSessionSearch>& SearchSettings)
{
    Warn("StartMatchmaking is not supported on this platform. Use FindSessions or FindSessionById.");
    TriggerOnMatchmakingCompleteDelegates(SessionName, false);
    return false;
}
 
bool FPVROnlineSession::CancelMatchmaking(int32 SearchingPlayerNum, FName SessionName)
{
    Warn("CancelMatchmaking is not supported on this platform. Use CancelFindSessions.");
    TriggerOnCancelMatchmakingCompleteDelegates(SessionName, false);
    return false;
}
 
bool FPVROnlineSession::CancelMatchmaking(const FUniqueNetId& SearchingPlayerId, FName SessionName)
{
    Warn("CancelMatchmaking is not supported on this platform. Use CancelFindSessions.");
    TriggerOnCancelMatchmakingCompleteDelegates(SessionName, false);
    return false;
}
 
bool FPVROnlineSession::FindSessions(int32 SearchingPlayerNum, const TSharedRef<FOnlineSessionSearch>& SearchSettings)
{
    uint32 Return = PVRO_FAIL;
 
    bool bIsValidCurrentSearch = CurrentSessionSearch.IsValid() ? (CurrentSessionSearch->SearchState == EOnlineAsyncTaskState::InProgress) : false;
 
    // Don't start another search while one is in progress
    if (!bIsValidCurrentSearch)
    {
        TriggerOnFindSessionsStartDelegates();
        // Free up previous results
        SearchSettings->SearchResults.Empty();
 
        // Copy the search pointer so we can keep it around
        CurrentSessionSearch = SearchSettings;
        if (CurrentSessionSearch->TimeoutInSeconds < 120.f)
        {
            CurrentSessionSearch->TimeoutInSeconds = 120.f;
        }
 
        // Remember the time at which we started search, as this will be used for a "good enough" ping estimation
        SessionSearchStartTime = FPlatformTime::Seconds();
 
        // LAN works the same as an Internet session in this case.
        Return = FindInternetSession(SearchSettings);
 
        if (Return == PVRO_IO_PENDING)
        {
            SearchSettings->SearchState = EOnlineAsyncTaskState::InProgress;
        }
 
        if (Return == PVRO_FAIL)
        {
            SearchSettings->SearchState = EOnlineAsyncTaskState::Failed;
        }
    }
    else
    {
        Log("Ignoring game search request while one is pending");
        Return = PVRO_IO_PENDING;
    }
 
    return Return == PVRO_SUCCESS || Return == PVRO_IO_PENDING;
}
 
bool FPVROnlineSession::FindSessions(const FUniqueNetId& SearchingPlayerId, const TSharedRef<FOnlineSessionSearch>& SearchSettings)
{
    return FindSessions(0, SearchSettings);
}
 
bool FPVROnlineSession::FindSessionById(const FUniqueNetId& SearchingUserId, const FUniqueNetId& SessionId, const FUniqueNetId& FriendId, const FOnSingleSessionResultCompleteDelegate& CompletionDelegates)
{
    FOnlineSessionSearchResult EmptyResult;
    CompletionDelegates.ExecuteIfBound(0, false, EmptyResult);
    return true;
}
 
uint32 FPVROnlineSession::FindInternetSession(const TSharedRef<FOnlineSessionSearch>& SearchSettings)
{
    uint32 Return = PVRO_IO_PENDING;
 
    int32 OrgId = -1, ModuleId = -1;
    FString ModuleVersion, UserName;
    SearchSettings->QuerySettings.Get<int32>(FName(TEXT("OrgID")), OrgId);
    SearchSettings->QuerySettings.Get<int32>(FName(TEXT("ModuleID")), ModuleId);
    SearchSettings->QuerySettings.Get<FString>(FName(TEXT("ModuleVersion")), ModuleVersion);
    SearchSettings->QuerySettings.Get<FString>(FName(TEXT("UserName")), UserName);
    // TODO: Add it to accept search settings
    if (!Subsystem->FindSessions(OrgId, ModuleId, UserName, ModuleVersion))
    {
        Return = PVRO_FAIL;
    }
 
    return PVRO_IO_PENDING;
}
 
uint32 FPVROnlineSession::FindLANSession(const TSharedRef<FOnlineSessionSearch>& SearchSettings)
{
    uint32 Return = PVRO_SUCCESS;//PVRO_IO_PENDING;
 
    // Honestly, we'll probably just replace this with the internet session find and point to the local IP. No reason for sillyness.
 
    return Return;
}
 
bool FPVROnlineSession::ClearSessionSearch(EOnlineAsyncTaskState::Type TaskState)
{
    Log("Clearing session search data.");
    bool bCouldClear = false;
 
    if (CurrentSessionSearch.IsValid())
    {
        // Make sure it's the right type
        bCouldClear = true;
        CurrentSessionSearch->SearchState = TaskState;
        CurrentSessionSearch = nullptr;
    }
    else
    {
        Warn("No session search to clear.");
    }
 
    return bCouldClear;
}
 
bool FPVROnlineSession::CancelFindSessions()
{
    Log("Canceling session search.");
    uint32 Return = PVRO_FAIL;
    if (CurrentSessionSearch.IsValid() && CurrentSessionSearch->SearchState == EOnlineAsyncTaskState::InProgress)
    {
        FinalizeLANSearch();
 
        Return = ClearSessionSearch(EOnlineAsyncTaskState::Failed);
    }
    else
    {
        Warn("Can't cancel a search that isn't in progress");
    }
 
    if (Return != PVRO_IO_PENDING)
    {
        TriggerOnCancelFindSessionsCompleteDelegates(true);
    }
 
    return Return == PVRO_SUCCESS || Return == PVRO_IO_PENDING;
}
 
void FPVROnlineSession::GetHostAndPort(int32& Host, int32& Port, const FString& HostIP, const FString& HostPort)
{
    // Convert the HostAddress and Port into their appropriate forms.
    FIPv4Address HostAddress;
    bool Result = FIPv4Address::Parse(HostIP, HostAddress);
    if (!Result)
    {
        ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
        if (SocketSubsystem)
        {
            FResolveInfo* ResolveInfo = SocketSubsystem->GetHostByName(TCHAR_TO_ANSI(*HostIP));
            while (!ResolveInfo->IsComplete());
            if (ResolveInfo->GetErrorCode() == 0)
            {
                const FInternetAddr* Address = &ResolveInfo->GetResolvedAddress();
                uint32 IP = 0;
                Address->GetIp(IP);
                Host = FIPv4Address(IP).Value;
            }
        }
        else
        {
            // TODO SocketSubsystem issue?
            Warn("FindSession: No SocketSubsystem found.");
        }
    }
    else
    {
        Host = HostAddress.Value;
    }
 
    // +1 is a workaround because this implementation uses 2 ports for communication. The user shouldn't bother
    // to add this inside the BP or config files.
    Port = FCString::Atoi(*HostPort);
}
 
bool FPVROnlineSession::JoinSession(int32 PlayerNum, FName SessionName, const FOnlineSessionSearchResult& DesiredSession)
{
    Log("Attemping to join session %s.", *DesiredSession.GetSessionIdStr());
    uint32 Return = PVRO_FAIL;
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
 
    // Don't join a session if already in one or hosting one
    if (Session == nullptr)
    {
        TriggerOnJoinSessionStartDelegates();
        
        // Remove any local talkers
        IOnlineVoicePtr VoiceInt = Subsystem->GetVoiceInterface();
        if (VoiceInt.IsValid())
        {
            if (!Subsystem->IsDedicated())
            {
                // Stop local talkers
                VoiceInt->UnregisterLocalTalkers();
            }
 
            // Stop remote voice 
            VoiceInt->RemoveAllRemoteTalkers();
        }
 
        // Create a named session from the search result data
        Session = AddNamedSession(SessionName, DesiredSession.Session);
        Session->HostingPlayerNum = PlayerNum;
 
        // Join a session
        FPVROSessionInfo* NewSessionInfo = new FPVROSessionInfo();
        Session->SessionInfo = MakeShareable(NewSessionInfo);
 
        Return = JoinInternetSession(PlayerNum, Session, &DesiredSession.Session);
 
        // turn off advertising on Join, to avoid clients advertising it over LAN
        Session->SessionSettings.bShouldAdvertise = false;
        if (Return != PVRO_IO_PENDING)
        {
            if (Return != PVRO_SUCCESS)
            {
                // Clean up the session info so we don't get into a confused state
                RemoveNamedSession(SessionName);
            }
            else
            {
                RegisterLocalPlayers(Session);
            }
        }
    }
    else
    {
        Warn("Session (%s) already exists, can't join twice.", *SessionName.ToString());
    }
 
    if (Return != PVRO_IO_PENDING)
    {
        // Just trigger the delegate as having failed
        TriggerOnJoinSessionCompleteDelegates(SessionName, Return == PVRO_SUCCESS ? EOnJoinSessionCompleteResult::Success : EOnJoinSessionCompleteResult::UnknownError);
    }
 
    return Return == PVRO_SUCCESS || Return == PVRO_IO_PENDING;
}
 
bool FPVROnlineSession::JoinSession(const FUniqueNetId& PlayerId, FName SessionName, const FOnlineSessionSearchResult& DesiredSession)
{
    // Assuming player 0 should be OK here
    return JoinSession(0, SessionName, DesiredSession);
}
 
bool FPVROnlineSession::FindFriendSession(int32 LocalUserNum, const FUniqueNetId& Friend)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    TArray<FOnlineSessionSearchResult> EmptySearchResult;
    TriggerOnFindFriendSessionCompleteDelegates(LocalUserNum, false, EmptySearchResult);
    return false;
};
 
bool FPVROnlineSession::FindFriendSession(const FUniqueNetId& LocalUserId, const FUniqueNetId& Friend)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    TArray<FOnlineSessionSearchResult> EmptySearchResult;
    TriggerOnFindFriendSessionCompleteDelegates(0, false, EmptySearchResult);
    return false;
}
 
bool FPVROnlineSession::FindFriendSession(const FUniqueNetId& LocalUserId, const TArray<TSharedRef<const FUniqueNetId>>& FriendList)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    TArray<FOnlineSessionSearchResult> EmptySearchResult;
    TriggerOnFindFriendSessionCompleteDelegates(0, false, EmptySearchResult);
    return false;
}
 
bool FPVROnlineSession::SendSessionInviteToFriend(int32 LocalUserNum, FName SessionName, const FUniqueNetId& Friend)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    return false;
};
 
bool FPVROnlineSession::SendSessionInviteToFriend(const FUniqueNetId& LocalUserId, FName SessionName, const FUniqueNetId& Friend)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    return false;
}
 
bool FPVROnlineSession::SendSessionInviteToFriends(int32 LocalUserNum, FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Friends)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    return false;
};
 
bool FPVROnlineSession::SendSessionInviteToFriends(const FUniqueNetId& LocalUserId, FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Friends)
{
    // this function has to exist due to interface definition, but it does not have a meaningful implementation in PixoVR subsystem
    return false;
}
 
uint32 FPVROnlineSession::JoinInternetSession(int32 PlayerNum, FNamedOnlineSession* Session, const FOnlineSession* SearchSession)
{
    uint32 Result = PVRO_FAIL;
    Session->SessionState = EOnlineSessionState::Pending;
 
    if (Session->SessionInfo.IsValid() && SearchSession != nullptr && SearchSession->SessionInfo.IsValid())
    {
        // Copy the session info over
        const FPVROSessionInfo* SearchSessionInfo = (const FPVROSessionInfo*)SearchSession->SessionInfo.Get();
        FPVROSessionInfo* SessionInfo = (FPVROSessionInfo*)Session->SessionInfo.Get();
        SessionInfo->SessionId = SearchSessionInfo->SessionId;
 
        uint32 IpAddr;
        SearchSessionInfo->HostAddr->GetIp(IpAddr);
        SessionInfo->HostAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
        SessionInfo->HostAddr->SetIp(IpAddr);
        SessionInfo->HostAddr->SetPort(SearchSessionInfo->HostAddr->GetPort());
 
        Result = PVRO_SUCCESS;
    }
 
    return Result;
}
 
bool FPVROnlineSession::PingSearchResults(const FOnlineSessionSearchResult& SearchResult)
{
    return false;
}
 
static bool GetConnectStringFromSessionInfo(TSharedPtr<FPVROSessionInfo>& SessionInfo, FString& ConnectInfo, int32 PortOverride=0)
{
    bool bSuccess = false;
    if (SessionInfo.IsValid())
    {
        if (SessionInfo->HostAddr.IsValid() && SessionInfo->HostAddr->IsValid())
        {
            if (PortOverride != 0)
            {
                ConnectInfo = FString::Printf(TEXT("%s:%d"), *SessionInfo->HostAddr->ToString(false), PortOverride);
            }
            else
            {
                ConnectInfo = FString::Printf(TEXT("%s"), *SessionInfo->HostAddr->ToString(true));
            }
 
            bSuccess = true;
        }
    }
 
    return bSuccess;
}
 
bool FPVROnlineSession::GetResolvedConnectString(FName SessionName, FString& ConnectInfo, FName PortType)
{
    bool bSuccess = false;
    // Find the session
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session != nullptr)
    {
        TSharedPtr<FPVROSessionInfo> SessionInfo = StaticCastSharedPtr<FPVROSessionInfo>(Session->SessionInfo);
        if (PortType == NAME_BeaconPort)
        {
            int32 BeaconListenPort = GetBeaconPortFromSessionSettings(Session->SessionSettings);
            bSuccess = GetConnectStringFromSessionInfo(SessionInfo, ConnectInfo, BeaconListenPort);
        }
        else if (PortType == NAME_GamePort)
        {
            bSuccess = GetConnectStringFromSessionInfo(SessionInfo, ConnectInfo);
        }
 
        if (!bSuccess)
        {
            Warn("Invalid session info for session %s in GetResolvedConnectString()", *SessionName.ToString());
        }
    }
    else
    {
        Warn("Unknown session name (%s) specified to GetResolvedConnectString().", *SessionName.ToString());
    }
 
    return bSuccess;
}
 
bool FPVROnlineSession::GetResolvedConnectString(const FOnlineSessionSearchResult& SearchResult, FName PortType, FString& ConnectInfo)
{
    bool bSuccess = false;
    if (SearchResult.Session.SessionInfo.IsValid())
    {
        TSharedPtr<FPVROSessionInfo> SessionInfo = StaticCastSharedPtr<FPVROSessionInfo>(SearchResult.Session.SessionInfo);
 
        if (PortType == NAME_BeaconPort)
        {
            int32 BeaconListenPort = GetBeaconPortFromSessionSettings(SearchResult.Session.SessionSettings);
            bSuccess = GetConnectStringFromSessionInfo(SessionInfo, ConnectInfo, BeaconListenPort);
 
        }
        else if (PortType == NAME_GamePort)
        {
            bSuccess = GetConnectStringFromSessionInfo(SessionInfo, ConnectInfo);
        }
    }
    
    if (!bSuccess || ConnectInfo.IsEmpty())
    {
        Warn("Invalid session info in search result to GetResolvedConnectString().");
    }
 
    return bSuccess;
}
 
FOnlineSessionSettings* FPVROnlineSession::GetSessionSettings(FName SessionName) 
{
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        return &Session->SessionSettings;
    }
    return nullptr;
}
 
void FPVROnlineSession::RegisterLocalPlayers(FNamedOnlineSession* Session)
{
    if (!Subsystem->IsDedicated())
    {
        IOnlineVoicePtr VoiceInt = Subsystem->GetVoiceInterface();
        if (VoiceInt.IsValid())
        {
            for (int32 Index = 0; Index < MAX_LOCAL_PLAYERS; Index++)
            {
                // Register the local player as a local talker
                VoiceInt->RegisterLocalTalker(Index);
            }
        }
    }
}
 
void FPVROnlineSession::RegisterVoice(const FUniqueNetId& PlayerId)
{
    if (!Subsystem->IsDedicated())
    {
        IOnlineVoicePtr VoiceInt = Subsystem->GetVoiceInterface();
        if (VoiceInt.IsValid())
        {
            if (!Subsystem->IsLocalPlayer(PlayerId))
            {
                VoiceInt->RegisterRemoteTalker(PlayerId);
            }
            else
            {
                // This is a local player. In case their PlayerState came last during replication, reprocess muting
                VoiceInt->ProcessMuteChangeNotification();
            }
        }
    }
}
 
void FPVROnlineSession::UnregisterVoice(const FUniqueNetId& PlayerId)
{
    if (!Subsystem->IsDedicated())
    {
        IOnlineVoicePtr VoiceInt = Subsystem->GetVoiceInterface();
        if (VoiceInt.IsValid())
        {
            if (!Subsystem->IsLocalPlayer(PlayerId))
            {
                if (VoiceInt.IsValid())
                {
                    VoiceInt->UnregisterRemoteTalker(PlayerId);
                }
            }
        }
    }
}
 
bool FPVROnlineSession::RegisterPlayer(FName SessionName, const FUniqueNetId& PlayerId, bool bWasInvited)
{
#if ENGINE_MAJOR_VERSION >= 5
    TArray<FUniqueNetIdRef> Players;
    Players.Add(FUniqueNetIdPixoVR::Create(PlayerId));
#else
    TArray<TSharedRef<const FUniqueNetId>> Players;
    Players.Add(MakeShareable(new FUniqueNetIdPixoVR(PlayerId)));
#endif
    return RegisterPlayers(SessionName, Players, bWasInvited);
}
 
bool FPVROnlineSession::RegisterPlayers(FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Players, bool bWasInvited)
{
    bool bSuccess = false;
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        bSuccess = true;
 
        for (int32 PlayerIdx=0; PlayerIdx<Players.Num(); PlayerIdx++)
        {
            const TSharedRef<const FUniqueNetId>& PlayerId = Players[PlayerIdx];
 
            FUniqueNetIdMatcher PlayerMatch(*PlayerId);
            if (Session->RegisteredPlayers.IndexOfByPredicate(PlayerMatch) == INDEX_NONE)
            {
                Session->RegisteredPlayers.Add(PlayerId);
                RegisterVoice(*PlayerId);
            }
            else
            {
                RegisterVoice(*PlayerId);
                Log("Player %s already registered in session %s.", *PlayerId->ToDebugString(), *SessionName.ToString());
            }           
        }
    }
    else
    {
        Warn("No game present to join for session (%s).", *SessionName.ToString());
    }
 
    TriggerOnRegisterPlayersCompleteDelegates(SessionName, Players, bSuccess);
    return bSuccess;
}
 
bool FPVROnlineSession::UnregisterPlayer(FName SessionName, const FUniqueNetId& PlayerId)
{
#if ENGINE_MAJOR_VERSION >= 5
    TArray<FUniqueNetIdRef> Players;
    Players.Add(FUniqueNetIdPixoVR::Create(PlayerId));
#else
    TArray<TSharedRef<const FUniqueNetId>> Players;
    Players.Add(MakeShareable(new FUniqueNetIdPixoVR(PlayerId)));
#endif
    return UnregisterPlayers(SessionName, Players);
}
 
bool FPVROnlineSession::UnregisterPlayers(FName SessionName, const TArray< TSharedRef<const FUniqueNetId> >& Players)
{
    bool bSuccess = true;
 
    FNamedOnlineSession* Session = GetNamedSession(SessionName);
    if (Session)
    {
        for (int32 PlayerIdx=0; PlayerIdx < Players.Num(); PlayerIdx++)
        {
            const TSharedRef<const FUniqueNetId>& PlayerId = Players[PlayerIdx];
 
            FUniqueNetIdMatcher PlayerMatch(*PlayerId);
            int32 RegistrantIndex = Session->RegisteredPlayers.IndexOfByPredicate(PlayerMatch);
            if (RegistrantIndex != INDEX_NONE)
            {
                Session->RegisteredPlayers.RemoveAtSwap(RegistrantIndex);
                UnregisterVoice(*PlayerId);
            }
            else
            {
                Warn("Player %s is not part of session (%s).", *PlayerId->ToDebugString(), *SessionName.ToString());
            }
        }
    }
    else
    {
        Warn("No game present to leave for session (%s).", *SessionName.ToString());
        bSuccess = false;
    }
 
    TriggerOnUnregisterPlayersCompleteDelegates(SessionName, Players, bSuccess);
    return bSuccess;
}
 
void FPVROnlineSession::Tick(float DeltaTime)
{
    SCOPE_CYCLE_COUNTER(STAT_Session_Interface);
    TickLanTasks(DeltaTime);
 
    if (CurrentSessionSearch.IsValid())
    {
        float CurrentTimeInSeconds = FPlatformTime::Seconds();
        if (CurrentTimeInSeconds - SessionSearchStartTime > CurrentSessionSearch->TimeoutInSeconds)
        {
            CancelFindSessions();
        }
    }
}
 
void FPVROnlineSession::TickLanTasks(float DeltaTime)
{
    LANSessionManager.Tick(DeltaTime);
}
 
// TODO: Evaluate if this is still needed
void FPVROnlineSession::OnValidQueryPacketReceived(uint8* PacketData, int32 PacketLength, uint64 ClientNonce)
{
    Log("Executing OnValidQueryPacketReceived.");
 
    // Iterate through all registered sessions and respond for each one that can be joinable
    FScopeLock ScopeLock(&SessionLock);
    for (int32 SessionIndex = 0; SessionIndex < Sessions.Num(); SessionIndex++)
    {
        Warn("OnValidQueryPacketReceived Session is Registered.");
 
        FNamedOnlineSession* Session = &Sessions[SessionIndex];
 
        // Don't respond to query if the session is not a joinable LAN match.
        if (Session)
        {
            Warn("Session valid trough Session Index.");
 
            const FOnlineSessionSettings& Settings = Session->SessionSettings;
 
            const bool bIsMatchInProgress = Session->SessionState == EOnlineSessionState::InProgress;
 
            const bool bIsMatchJoinable = (!bIsMatchInProgress || Settings.bAllowJoinInProgress) && Settings.NumPublicConnections > 0;
            if (bIsMatchJoinable)
            {
                Warn("Match from query is joinable.");
            }
        }
    }
}
 
// TODO: Evaluate if this is still needed
void FPVROnlineSession::OnValidResponsePacketReceived(uint8* PacketData, int32 PacketLength)
{
    // Create an object that we'll copy the data to
    FOnlineSessionSettings NewServer;
    if (CurrentSessionSearch.IsValid())
    {
        // Add space in the search results array
        FOnlineSessionSearchResult* NewResult = new (CurrentSessionSearch->SearchResults) FOnlineSessionSearchResult();
        // this is not a correct ping, but better than nothing
        NewResult->PingInMs = static_cast<int32>((FPlatformTime::Seconds() - SessionSearchStartTime) * 1000);
 
        FOnlineSession* NewSession = &NewResult->Session;
    }
    else
    {
        Warn("Failed to create new online game settings object.");
    }
}
 
uint32 FPVROnlineSession::FinalizeLANSearch()
{
    if (LANSessionManager.GetBeaconState() == ELanBeaconState::Searching)
    {
        LANSessionManager.StopLANSession();
    }
 
    return UpdateLANStatus();
}
 
void FPVROnlineSession::OnLANSearchTimeout()
{
    FinalizeLANSearch();
 
    if (CurrentSessionSearch.IsValid())
    {
        if (CurrentSessionSearch->SearchResults.Num() > 0)
        {
            // Allow game code to sort the servers
            CurrentSessionSearch->SortSearchResults();
        }
        CurrentSessionSearch->SearchState = EOnlineAsyncTaskState::Done;
 
        CurrentSessionSearch = nullptr;
    }
 
    // Trigger the delegate as complete
    TriggerOnFindSessionsCompleteDelegates(true);
}
 
int32 FPVROnlineSession::GetNumSessions()
{
    FScopeLock ScopeLock(&SessionLock);
    return Sessions.Num();
}
 
void FPVROnlineSession::DumpSessionState()
{
    FScopeLock ScopeLock(&SessionLock);
 
    for (int32 SessionIdx=0; SessionIdx < Sessions.Num(); SessionIdx++)
    {
        DumpNamedSession(&Sessions[SessionIdx]);
    }
}
 
void FPVROnlineSession::RegisterLocalPlayer(const FUniqueNetId& PlayerId, FName SessionName, const FOnRegisterLocalPlayerCompleteDelegate& Delegate)
{
    Delegate.ExecuteIfBound(PlayerId, EOnJoinSessionCompleteResult::Success);
}
 
void FPVROnlineSession::UnregisterLocalPlayer(const FUniqueNetId& PlayerId, FName SessionName, const FOnUnregisterLocalPlayerCompleteDelegate& Delegate)
{
    Delegate.ExecuteIfBound(PlayerId, true);
}
 
void FPVROnlineSession::SetPortFromNetDriver(const FPVROSubsystem& Subsystem, const TSharedPtr<FOnlineSessionInfo>& SessionInfo)
{
    auto NetDriverPort = GetPortFromNetDriver(Subsystem.GetInstanceName());
    auto SessionInfoPixoVR = StaticCastSharedPtr<FPVROSessionInfo>(SessionInfo);
    if (SessionInfoPixoVR.IsValid() && SessionInfoPixoVR->HostAddr.IsValid())
    {
        SessionInfoPixoVR->HostAddr->SetPort(NetDriverPort);
    }
}
 
bool FPVROnlineSession::IsHost(const FNamedOnlineSession& Session) const
{
    if (Subsystem->IsDedicated())
    {
        return true;
    }
 
#if ENGINE_MAJOR_VERSION >= 5
    FUniqueNetIdPixoVRRef UserId = FUniqueNetIdPixoVR::Create(FString::Printf(TEXT("%d"), Session.HostingPlayerNum));
    return (UserId->IsValid() && (*UserId == *Session.OwningUserId));
#else
    TSharedPtr<const FUniqueNetId> UserId = MakeShareable(new FUniqueNetIdPixoVR(FString::Printf(TEXT("%d"), Session.HostingPlayerNum)));
    return (UserId.IsValid() && (*UserId == *Session.OwningUserId));
#endif
}
 
TSharedPtr<const FUniqueNetId> FPVROnlineSession::CreateSessionIdFromString(const FString& SessionIdStr)
{
#if ENGINE_MAJOR_VERSION >= 5
    FUniqueNetIdPtr SessionId;
    if (!SessionIdStr.IsEmpty())
    {
        SessionId = FUniqueNetIdPixoVR::Create(SessionIdStr);
    }
#else
    FUniqueNetIdPtr SessionId;
    if (!SessionIdStr.IsEmpty())
    {
        SessionId = MakeShared<FUniqueNetIdPixoVR>(SessionIdStr);
    }
#endif
 
    return SessionId;
}
 
FString FPVROnlineSession::GetCustomDedicatedServerName() const
{
    FString ServerName = TEXT("");
    if(FParse::Value(FCommandLine::Get(), TEXT("-PIXOVR_SERVER_NAME="), ServerName))
    {
    }
 
    return ServerName;
}
 
#undef Fatal
#undef Error
#undef Warn
#undef Log