PVROSubsystem.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "PVROSubsystem.h"
#include "HAL/RunnableThread.h"
#include "PVROAsyncTaskManager.h"
#include "PVROnlineSession.h"
#include "PVROMultiplayerIdentity.h"
#include "VoiceInterfaceImpl.h"
#include "PVROMultiplayerModule.h"
#include "Misc/CommandLine.h"
 
DEFINE_LOG_CATEGORY_STATIC(LogPVROSubSystem, Log, All);
 
#define Verbose(pmt, ...) UE_LOG(LogPVROSubSystem, Verbose, TEXT(pmt), ##__VA_ARGS__)
#define Log(pmt, ...) UE_LOG(LogPVROSubSystem, Log, TEXT(pmt), ##__VA_ARGS__)
#define Warn(pmt, ...) UE_LOG(LogPVROSubSystem, Warning, TEXT(pmt), ##__VA_ARGS__)
#define Error(pmt, ...) UE_LOG(LogPVROSubSystem, Error, TEXT(pmt), ##__VA_ARGS__)
#define Fatal(pmt, ...) UE_LOG(LogPVROSubSystem, Fatal, TEXT(pmt), ##__VA_ARGS__)
 
FThreadSafeCounter FPVROSubsystem::TaskCounter;
 
IOnlineSessionPtr FPVROSubsystem::GetSessionInterface() const
{
    return SessionInterface;
}
 
IOnlineFriendsPtr FPVROSubsystem::GetFriendsInterface() const
{
    return nullptr;
}
 
IOnlinePartyPtr FPVROSubsystem::GetPartyInterface() const
{
    return nullptr;
}
 
IOnlineGroupsPtr FPVROSubsystem::GetGroupsInterface() const
{
    return nullptr;
}
 
IOnlineSharedCloudPtr FPVROSubsystem::GetSharedCloudInterface() const
{
    return nullptr;
}
 
IOnlineUserCloudPtr FPVROSubsystem::GetUserCloudInterface() const
{
    return nullptr;
}
 
IOnlineEntitlementsPtr FPVROSubsystem::GetEntitlementsInterface() const
{
    return nullptr;
};
 
IOnlineLeaderboardsPtr FPVROSubsystem::GetLeaderboardsInterface() const
{
    return nullptr;
}
 
IOnlineVoicePtr FPVROSubsystem::GetVoiceInterface() const
{
    if (VoiceInterface.IsValid() && !bVoiceInterfaceInitialized)
    {   
        if (!VoiceInterface->Init())
        {
            VoiceInterface = nullptr;
        }
 
        bVoiceInterfaceInitialized = true;
    }
 
    return VoiceInterface;
}
 
IOnlineExternalUIPtr FPVROSubsystem::GetExternalUIInterface() const
{
    return nullptr;
}
 
IOnlineTimePtr FPVROSubsystem::GetTimeInterface() const
{
    return nullptr;
}
 
IOnlineIdentityPtr FPVROSubsystem::GetIdentityInterface() const
{
    return IdentityInterface;
}
 
IOnlineTitleFilePtr FPVROSubsystem::GetTitleFileInterface() const
{
    return nullptr;
}
 
IOnlineEventsPtr FPVROSubsystem::GetEventsInterface() const
{
    return nullptr;
}
 
IOnlineAchievementsPtr FPVROSubsystem::GetAchievementsInterface() const
{
    return nullptr;
}
 
IOnlineSharingPtr FPVROSubsystem::GetSharingInterface() const
{
    return nullptr;
}
 
IOnlineUserPtr FPVROSubsystem::GetUserInterface() const
{
    return nullptr;
}
 
IOnlineMessagePtr FPVROSubsystem::GetMessageInterface() const
{
    return nullptr;
}
 
IOnlinePresencePtr FPVROSubsystem::GetPresenceInterface() const
{
    return nullptr;
}
 
IOnlineChatPtr FPVROSubsystem::GetChatInterface() const
{
    return nullptr;
}
 
IOnlineTurnBasedPtr FPVROSubsystem::GetTurnBasedInterface() const
{
    return nullptr;
}
 
IOnlineTournamentPtr FPVROSubsystem::GetTournamentInterface() const
{
    return nullptr;
}
 
IOnlineStatsPtr FPVROSubsystem::GetStatsInterface() const
{
    return nullptr;
}
 
void FPVROSubsystem::QueueAsyncTask(FOnlineAsyncTask* AsyncTask)
{
    check(TaskThreadManager);
    TaskThreadManager->AddToInQueue(AsyncTask);
}
 
bool FPVROSubsystem::Tick(float DeltaTime)
{
    if (!FOnlineSubsystemImpl::Tick(DeltaTime))
    {
        return false;
    }
 
    if (TaskThreadManager)
    {
        TaskThreadManager->GameTick();
    }
 
    if (SessionInterface.IsValid())
    {
        SessionInterface->Tick(DeltaTime);
    }
 
    if (VoiceInterface.IsValid() && bVoiceInterfaceInitialized)
    {
        VoiceInterface->Tick(DeltaTime);
    }
 
    return true;
}
 
#ifdef UE_EDITOR
void static PrintToScreen(int32 Key, float Time, FColor MessageColor, FString Message)
{
    if (GEngine)
        GEngine->AddOnScreenDebugMessage(Key, Time, MessageColor, Message);
}
#endif
 
bool FPVROSubsystem::TryLoadConfig()
{
    bool bCouldLoad = false;
    FString SubsystemFilePath = FPaths::Combine(FPaths::ProjectPersistentDownloadDir(), TEXT("pixo_onlinesubsystem.ini"));
    Log("Trying to parse subsystem file: %s", *SubsystemFilePath);
    IPlatformFile& FileManager = FPlatformFileManager::Get().GetPlatformFile();
    if (FileManager.FileExists(*SubsystemFilePath))
    {
        FString SubsystemConfigContent;
        if (FFileHelper::LoadFileToString(SubsystemConfigContent, *SubsystemFilePath))
        {
            Log("Successfully loaded file.");
            if (!SubsystemConfigContent.IsEmpty())
            {
                TMap<FString, FString> ParsedConfig;
                bCouldLoad = ParseConfig(SubsystemConfigContent, ParsedConfig);
                if (bCouldLoad)
                {
                    bool bIgnoreVersion = false;
                    if (ParsedConfig.Contains("ignoreVersion"))
                    {
                        bIgnoreVersion = ParsedConfig["ignoreVersion"].ToBool();
                        Log("%s configuration file version.", bIgnoreVersion ? TEXT("Will ignore") : TEXT("Will not ignore"));
                    }
 
                    if (ParsedConfig.Contains("version") && !bIgnoreVersion)
                    {
                        FString ConfigVersion = ParsedConfig["version"];
                        if (ConfigVersion.Compare(ModuleVersion))
                        {
                            Log("Versions are different. Not loading config.")
                                bCouldLoad = false;
                        }
                    }
 
                    if (ParsedConfig.Contains("url") && bCouldLoad)
                    {
                        MultiplayerURL = ParsedConfig["url"];
                        MultiplayerURL.RemoveFromEnd(TEXT("/"));
                    }
                }
            }
        }
    }
    else
    {
        Log("No multiplayer subsystem config file exists at %s.", *SubsystemFilePath);
    }
 
    return bCouldLoad;
}
 
bool FPVROSubsystem::ParseConfig(FString ConfigContent, TMap<FString, FString>& ConfigValues)
{
    TArray<FString> ConfigLines;
    ConfigContent.ParseIntoArrayLines(ConfigLines);
 
 
    if (ConfigLines.Num() < 0)
    {
        return false;
    }
 
    FString Key, Value;
    for (int ConfigIndex = 0; ConfigIndex < ConfigLines.Num(); ConfigIndex++)
    {
        if (ConfigLines[ConfigIndex].Split(TEXT("="), &Key, &Value))
        {
            ConfigValues.Add(Key.ToLower(), Value);
        }
    }
 
    return true;
}
 
bool FPVROSubsystem::SaveConfig()
{
    bool bCouldSave = true;
    FString SubsystemFilePath = FPaths::Combine(FPaths::ProjectPersistentDownloadDir(), TEXT("pixo_onlinesubsystem.ini"));
    
    FString ConfigContent = "url=" + MultiplayerURL + "\nversion=" + ModuleVersion;
 
    if (!FFileHelper::SaveStringToFile(ConfigContent, *SubsystemFilePath))
    {
        bCouldSave = false;
        Warn("Failed to save file %s", *SubsystemFilePath);
    }
 
    return bCouldSave;
}
 
bool FPVROSubsystem::Init()
{
    const bool bPixoVRInit = true;
 
    Log("Initializing the PVROSubsystem!");
    if (bPixoVRInit)
    {
        FString SubsystemFilePath = FPaths::Combine(FPaths::ProjectPersistentDownloadDir(), TEXT("pixo_onlinesubsystem.ini"));
        IPlatformFile& FileManager = FPlatformFileManager::Get().GetPlatformFile();
        
        if (!GConfig->GetString(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("ModuleVersion"), ModuleVersion, GEngineIni))
        {
            int MajorVersion = 0, MinorVersion = 0, PatchVersion = 0;
            GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("MajorVerison"), MajorVersion, GEngineIni);
            GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("MinorVersion"), MinorVersion, GEngineIni);
            GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("PatchVersion"), PatchVersion, GEngineIni);
            ModuleVersion = FString::Printf(TEXT("%i.%.2i.%.2i"), MajorVersion, MinorVersion, PatchVersion);
        }
 
        GConfig->GetInt(TEXT("/Script/ApexSDK.ApexSDKSettings"), TEXT("ModuleId"), ModuleId, GEngineIni);
 
        if (!TryLoadConfig())
        {
            Log("Config failed to load, defaulting to variables in config.");
            if (!GConfig->GetString(TEXT("PixoVRMultiplayer"), TEXT("ServerURI"), MultiplayerURL, GGameIni))
            {
                Log("Could not find configuration value in the game ini, checking engine ini as a back up.");
                if (!GConfig->GetString(TEXT("PixoVRMultiplayer"), TEXT("ServerURI"), MultiplayerURL, GEngineIni))
                {
                    Warn("Failed to get the Server URI, falling back to 127.0.0.1.");
                    MultiplayerURL = "127.0.0.1";
                }
            }
 
            Warn("Multiplayer url is %s.", *MultiplayerURL);
 
            if (!MultiplayerURL.IsEmpty())
            {
                FString ConnectionString = "wss://";
                if (MultiplayerURL.Contains(TEXT("ws://")))
                {
                    ConnectionString = "ws://";
                    Warn("This looks to be a normal web socket. Make sure you use this only for testing.");
                }
 
                MultiplayerURL.RemoveFromStart(ConnectionString);
                MultiplayerURL.RemoveFromStart(TEXT("https://"));
                MultiplayerURL.RemoveFromEnd(TEXT("/"));
 
                MultiplayerURL = ConnectionString + MultiplayerURL;
                SaveConfig();
            }
        }
 
        FPVROAsyncTaskManager::ServerURL = MultiplayerURL;
        FPVROAsyncTaskManager::ServerVersion = ModuleVersion;
        Log("Server URL is %s", *MultiplayerURL);
        
        TaskThreadManager = new FPVROAsyncTaskManager(this);
        check(TaskThreadManager);
        TaskThread = FRunnableThread::Create(TaskThreadManager, *FString::Printf(TEXT("Task Manager %s(%d)"), *InstanceName.ToString(), TaskCounter.Increment()), 128 * 1024, TPri_Normal);
        check(TaskThread);
        Verbose("Created thread (ID:%d).", TaskThread->GetThreadID());
 
        SessionInterface = MakeShareable(new FPVROnlineSession(this));
        IdentityInterface = MakeShareable(new FPVROIdentity(this));
        VoiceInterface = MakeShareable(new FOnlineVoiceImpl(this));
 
#if !UE_SERVER
        WebSocket.OnWebSocketConnected().AddLambda([&]() -> void { Log("Web socket connected!"); });
        WebSocket.OnWebSocketConnectFailed().AddLambda([&](const FString& Error) -> void { Warn("Web socket failed to connect because %s", *Error); });
        WebSocket.OnWebSocketDisconnected().AddLambda([&](int32 StatusCode, const FString& Reason, bool bWasClean) -> 
            void { Warn("Web socket disconnected %s w/ status code %d for reason %s", bWasClean ? "cleanly" : "not cleanly", StatusCode, *Reason); });
#endif
    }
    else
    {
        Shutdown();
    }
 
    return bPixoVRInit;
}
 
bool FPVROSubsystem::ConnectWebsocket()
{
#if UE_SERVER
    return false;
#else
    Warn("Multiplayer url is %s.", *MultiplayerURL);
    return WebSocket.AttemptConnect(MultiplayerURL);
#endif
}
 
bool FPVROSubsystem::Shutdown()
{
    FOnlineSubsystemImpl::Shutdown();
 
    WebSocket.Disconnect();
 
    if (TaskThread)
    {
        // Destroy the online async task thread
        delete TaskThread;
        TaskThread = nullptr;
    }
 
    if (TaskThread)
    {
        delete TaskThread;
        TaskThread = nullptr;
    }
 
    if (VoiceInterface.IsValid() && bVoiceInterfaceInitialized)
    {
        VoiceInterface->Shutdown();
    }
 
    if (SessionInterface.IsValid())
    {
        SessionInterface->CancelFindSessions();
    }
    
#define DESTRUCT_INTERFACE(Interface) \
    if (Interface.IsValid()) \
    { \
        ensure(Interface.IsUnique()); \
        Interface = nullptr; \
    }
 
    // Destruct the interfaces
    DESTRUCT_INTERFACE(VoiceInterface);
    DESTRUCT_INTERFACE(SessionInterface);
 
#undef DESTRUCT_INTERFACE
 
    return true;
}
 
FString FPVROSubsystem::GetAppId() const
{
    return TEXT("");
}
 
bool FPVROSubsystem::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
{
    if (FOnlineSubsystemImpl::Exec(InWorld, Cmd, Ar))
    {
        return true;
    }
    return false;
}
FText FPVROSubsystem::GetOnlineServiceName() const
{
    return NSLOCTEXT("PixoVRMultiplayer", "OnlineServiceName", "PixoVR");
}
 
void FPVROSubsystem::SetUserInfo(FString InUserName, int InUserOrgId)
{
    UserName = InUserName;
    UserOrgId = InUserOrgId;
    IdentityInterface->SetPlayerNickname(0, UserName);
}
 
void FPVROSubsystem::SetModuleInfo(int InModuleId, FString InModuleVersion)
{
    ModuleId = InModuleId;
    ModuleVersion = InModuleVersion;
}
 
bool FPVROSubsystem::FindSessions(int InOrgId, int InModuleId, FString InUserName, FString InModuleVersion)
{
    if (InOrgId >= 0)
    {
        UserOrgId = InOrgId;
    }
 
    if (InModuleId >= 0)
    {
        ModuleId = InModuleId;
    }
 
    if (!InUserName.IsEmpty())
    {
        UserName = InUserName;
    }
 
    if (!InModuleVersion.IsEmpty())
    {
        ModuleVersion = InModuleVersion;
    }
 
    Log("Finding sessions for Module ID %d with Org ID %d.", UserOrgId, ModuleId);
    if (UserOrgId < 0 || ModuleId < 0)
    {
        Error("Invalid OrgId or ModuleId used when finding a session.");
        return false;
    }
 
#if UE_SERVER
    return false;
#else
    bool bCanFindSession = true;
    if (!WebSocket.IsWebsocketConnected())
    {
        bCanFindSession = ConnectWebsocket();
    }
 
    if (bCanFindSession)
    {
        WebSocket.RequestMatchMake(UserOrgId, ModuleId);
    }
 
    return bCanFindSession;
#endif
}
 
#undef Fatal
#undef Error
#undef Warn
#undef Log
#undef Verbose