PVROFindServerTask.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "PVROFindServerTask.h"
#include "PVROnlineSession.h"
#include "PVROSubsystem.h"
#include "GameFramework/GameStateBase.h"
#include "GameFramework/PlayerState.h"
#include "OnlineSubsystemUtils.h"
#include "SocketSubsystem.h"
#include "Runtime/JsonUtilities/Public/JsonObjectConverter.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "HttpModule.h"
#if ENGINE_MAJOR_VERSION >= 5
#include "IPAddressAsyncResolve.h"
#include "Online/OnlineSessionNames.h"
#endif
 
 
FString FPVROFindServerTask::ToString() const
{
    return FString::Printf(TEXT("FPVROFindServerTask bWasSuccessful: %d Results: %d"), WasSuccessful(), SearchSettings->SearchResults.Num());
}
 
void FPVROFindServerTask::RequestSessions()
{
    TSharedRef<IHttpRequest, ESPMode::ThreadSafe> HTTPRequest = FHttpModule::Get().CreateRequest();
    HTTPRequest->OnProcessRequestComplete().BindRaw(this, &FPVROFindServerTask::OnRequestSessionResponseReceived);
    HTTPRequest->SetURL(FPVROAsyncTaskManager::ServerURL / TEXT("RequestSession"));
    HTTPRequest->SetVerb("GET");
 
    FPVROMPSessionRequestInfo SessionRequestInfo {};
 
    int ModuleId = 0;
    // OK, we failed to find the module version reading from the terminal. Let's check the ini files.
    GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("ModuleId"), ModuleId, GEngineIni);
 
    int OrgID = 0;
    SearchSettings->QuerySettings.Get<int>(FName(TEXT("OrgID")), OrgID);
 
    SessionRequestInfo.ModuleID = ModuleId;
    SessionRequestInfo.ModuleVersion = FPVROAsyncTaskManager::ServerVersion;
 
    UE_LOG(LogTemp, Warning, TEXT("Request to find Session: ModuleID: %d, OrgID: N/A, Version: %s, Client: %s"), 
        SessionRequestInfo.ModuleID, *SessionRequestInfo.ModuleVersion, *SessionRequestInfo.ClientID);
 
    HTTPRequest->ProcessRequest();
    SessionSearchStartInSeconds = FPlatformTime::Seconds();
}
 
void FPVROFindServerTask::Initialize()
{
    RequestSessions();
}
 
void FPVROFindServerTask::OnRequestSessionResponseReceived(FHttpRequestPtr HTTPRequest, FHttpResponsePtr HTTPResponse, bool InWasSuccessful)
{
    if (InWasSuccessful)
    {
        PingInMs = static_cast<int32>((FPlatformTime::Seconds() - SessionSearchStartInSeconds) * 1000);
 
        ServerInfos = {};
        ServerInfos.FromJson(HTTPResponse->GetContentAsString());
 
        if(ServerInfos.Reply == ReplyPending)
        {
            if(!bDedicatedServerStart)
            {
                UE_LOG_ONLINE(Warning, TEXT("PixoVR Master Service Started new Dedicated Server: %s"), *ServerInfos.Reply);
                bDedicatedServerStart = true;
            }
            else
            {
                Counter++;
            }
 
            bFoundSessions = EPVRORequestSessionsReply::Pending;
        } 
        else if(ServerInfos.Reply == ReplyInvalidModuleID)
        {
            UE_LOG_ONLINE(Warning, TEXT("Failed due to invalid ModuleID."));
 
            bDedicatedServerStart = false;
            bFoundSessions = EPVRORequestSessionsReply::InvalidModule;
        }
        else if(ServerInfos.Reply == ReplyOK)
        {
            for(auto& Server : ServerInfos.CurrentSessions)
            {
                UE_LOG_ONLINE(Warning, TEXT("IPAddress: %s"), *Server.IPAddress);
                UE_LOG_ONLINE(Warning, TEXT("Port: %s"), *Server.Port);
                UE_LOG_ONLINE(Warning, TEXT("SessionID: %s"), *Server.SessionID);
                UE_LOG_ONLINE(Warning, TEXT("MapName: %s"), *Server.MapName);
                UE_LOG_ONLINE(Warning, TEXT("OwningUserName: %s"), *Server.OwningUserName);
            }
 
            bFoundSessions = EPVRORequestSessionsReply::Success;
            bDedicatedServerStart = false;
        }
        else
        {
            bFoundSessions = EPVRORequestSessionsReply::Failed;
            bDedicatedServerStart = false;
        }
    }
    else
    {
        bFoundSessions = EPVRORequestSessionsReply::Failed;
    }
}
 
void FPVROFindServerTask::Tick()
{
    // ATTN Yaakuro: Don't know why but bIsComplete and bWasSuccessful needs to be set inside this tick else it will not work.
    if(bFoundSessions == EPVRORequestSessionsReply::Success)
    {
        bIsComplete = true;
        bWasSuccessful = true;
        bDedicatedServerStart = false;
    }
    else if(bFoundSessions == EPVRORequestSessionsReply::InvalidModule)
    {
        bIsComplete = true;
        bWasSuccessful = false;
        bDedicatedServerStart = false;
    }
    else if(bFoundSessions == EPVRORequestSessionsReply::Pending)
    {
        // Check if PixoVR Master Service had to start a new Dedicated Server. If yes, wait a bit.
        if(bDedicatedServerStart)
        {
            if(Counter >= MaxAllowedTrials)
            {
                UE_LOG_ONLINE(Warning, TEXT("Failed to find any Sessions."));
 
                bIsComplete = true;
                bWasSuccessful = false;
                bDedicatedServerStart = false;
            }
            else
            {
                double dT = (FPlatformTime::Seconds() - GStartTime) - DedicatedServerAquireStart;
                if(dT > MaxDedicatedServerWaitTime)
                {
                    UE_LOG_ONLINE(Warning, TEXT("Sending another Request: %d"), Counter);
 
                    RequestSessions();
                    DedicatedServerAquireStart = (FPlatformTime::Seconds() - GStartTime);
                }
            }
        }
    } 
    else if(bFoundSessions == EPVRORequestSessionsReply::Failed)
    {
        UE_LOG_ONLINE(Warning, TEXT("HTTP request invalid."), Counter);
 
        bIsComplete = true;
        bWasSuccessful = false;
        bDedicatedServerStart = false;
    }
    else
    {
        // Should never happen.
        check(0);
    }
}
 
void FPVROFindServerTask::Finalize()
{
    FPVROnlineSessionPtr SessionInt = StaticCastSharedPtr<FPVROnlineSession>(Subsystem->GetSessionInterface());
    SearchSettings->SearchState = bWasSuccessful ? EOnlineAsyncTaskState::Done : EOnlineAsyncTaskState::Failed;
    SessionInt->CurrentSessionSearch->SearchState = bWasSuccessful ? EOnlineAsyncTaskState::Done : EOnlineAsyncTaskState::Failed;
 
    if (bWasSuccessful)
    {
        for(auto& Server : ServerInfos.CurrentSessions)
        {
            FOnlineSessionSearchResult* NewResult = new (SessionInt->CurrentSessionSearch->SearchResults) FOnlineSessionSearchResult();
            NewResult->PingInMs = PingInMs;
            FOnlineSession* NewSession = &NewResult->Session;
 
            FPVROSessionInfo* PixoVRSessionInfo = new FPVROSessionInfo();
            PixoVRSessionInfo->HostAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
 
            int32 HostAddress = 0;
            int32 HostPort = 0;
 
            GetHostAndPort(HostAddress, HostPort, Server.IPAddress, Server.Port);
            PixoVRSessionInfo->HostAddr->SetIp(HostAddress);
            PixoVRSessionInfo->HostAddr->SetPort(HostPort);
            NewSession->SessionSettings.Set(SETTING_MAPNAME, Server.MapName);
            NewSession->OwningUserName = Server.OwningUserName;
            NewSession->SessionInfo = MakeShareable(PixoVRSessionInfo);
            
            
            // Allow game code to sort the servers
            SearchSettings->SortSearchResults();
        }
    }
 
    SessionInt->CurrentSessionSearch = NULL;
}
 
void FPVROFindServerTask::TriggerDelegates()
{
    // TODO Yaakuro: For now we rely on timout to get to the JoinSession task.
    if (FindServersCompleteDelegates.IsBound())
    {
        FindServersCompleteDelegates.Broadcast(bWasSuccessful);
    }
}
 
void FPVROFindServerTask::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?
            UE_LOG(LogTemp, Warning, TEXT("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); 
}