PVROMultiplayerIdentity.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "PVROMultiplayerIdentity.h"
#include "Misc/CommandLine.h"
#include "Misc/Guid.h"
#include "Misc/OutputDeviceRedirector.h"
#include "PVROSubsystem.h"
#include "IPAddress.h"
#include "SocketSubsystem.h"
#include "OnlineError.h"
 
#include "PVROPrivate.h"
 
DEFINE_LOG_CATEGORY_STATIC(LogPVROMultiplayerIdentity, Log, All);
 
#define Log(pmt, ...) UE_LOG(LogPVROMultiplayerIdentity, Log, TEXT(pmt), ##__VA_ARGS__)
#define Warn(pmt, ...) UE_LOG(LogPVROMultiplayerIdentity, Warning, TEXT(pmt), ##__VA_ARGS__)
#define Error(pmt, ...) UE_LOG(LogPVROMultiplayerIdentity, Error, TEXT(pmt), ##__VA_ARGS__)
#define Fatal(pmt, ...) UE_LOG(LogPVROMultiplayerIdentity, Fatal, TEXT(pmt), ##__VA_ARGS__)
 
bool FPVROUserAccount::GetAuthAttribute(const FString& AttrName, FString& OutAttrValue) const
{
    const FString* FoundAttr = AdditionalAuthData.Find(AttrName);
    if (FoundAttr != nullptr)
    {
        OutAttrValue = *FoundAttr;
        return true;
    }
    return false;
}
 
bool FPVROUserAccount::GetUserAttribute(const FString& AttrName, FString& OutAttrValue) const
{
    const FString* FoundAttr = UserAttributes.Find(AttrName);
    if (FoundAttr != nullptr)
    {
        OutAttrValue = *FoundAttr;
        return true;
    }
    return false;
}
 
bool FPVROUserAccount::SetUserAttribute(const FString& AttrName, const FString& AttrValue)
{
    const FString* FoundAttr = UserAttributes.Find(AttrName);
    if (FoundAttr == nullptr || *FoundAttr != AttrValue)
    {
        UserAttributes.Add(AttrName, AttrValue);
        return true;
    }
    return false;
}
 
inline FString GenerateRandomUserId(int32 LocalUserNum)
{
    FString HostName;
    if (!ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetHostName(HostName))
    {
        // could not get hostname, use address
        bool bCanBindAll;
        TSharedPtr<class FInternetAddr> Addr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLocalHostAddr(*GLog, bCanBindAll);
        HostName = Addr->ToString(false);
    }
 
    if ( !GIsEditor )
    {
        FString UserId = FString::Printf( TEXT( "%s-%s" ), *HostName, *FPlatformMisc::GetLoginId().ToUpper() );
        if(!FParse::Value(FCommandLine::Get(), TEXT("-PVRMP_SERVER_NAME="), UserId))
        {
            // OK, we failed to find the module version reading from the terminal. Let's check the ini files.
            if(GConfig && !GConfig->GetString(TEXT("PixoVRMultiplayer"), TEXT("ServerName"), UserId, GEngineIni))
            {
                UserId = "PVROServer";
            }
        }
 
        // When possible, return a stable user id
        return UserId;
    }
 
 
    // If we're not the first instance (or in the editor), return truly random id
    return FString::Printf( TEXT( "%s-%s" ), *HostName, *FGuid::NewGuid().ToString() );
}
 
bool FPVROIdentity::Login(int32 LocalUserNum, const FOnlineAccountCredentials& AccountCredentials)
{
    FString ErrorStr;
    TSharedPtr<FPVROUserAccount> UserAccountPtr;
 
    // Do we have a valid Local Player index?
    if (LocalUserNum < 0 || LocalUserNum >= MAX_LOCAL_PLAYERS)
    {
        ErrorStr = FString::Printf(TEXT("Invalid LocalUserNum=%d"), LocalUserNum);
    }
    else if (AccountCredentials.Id.IsEmpty())
    {
        ErrorStr = TEXT("Invalid account id, string empty");
    }
    else
    {
        FUniqueNetIdPtr* UserId = UserIds.Find(LocalUserNum);
        if (UserId == nullptr)
        {
            FString RandomUserId = GenerateRandomUserId(LocalUserNum);
 
            UserAccountPtr = MakeShareable(new FPVROUserAccount(RandomUserId));
            UserAccountPtr->UserAttributes.Add(USER_ATTR_ID, RandomUserId);
 
#if ENGINE_MAJOR_VERSION >= 5
            FUniqueNetIdPixoVRRef NewUserIdRef = FUniqueNetIdPixoVR::Create(RandomUserId);
            UserAccounts.Add(*NewUserIdRef, UserAccountPtr.ToSharedRef());
#else
            FUniqueNetIdPixoVR NewUserId(RandomUserId);
            UserAccounts.Add(NewUserId, UserAccountPtr.ToSharedRef());
#endif
            // keep track of user ids for local users
            UserIds.Add(LocalUserNum, UserAccountPtr->GetUserId());
        }
        else
        {
            const FUniqueNetIdPixoVR* UniqueIdStr = (FUniqueNetIdPixoVR*)(UserId->Get());
            TSharedRef<FPVROUserAccount>* TempPtr = UserAccounts.Find(*UniqueIdStr);
            check(TempPtr);
            UserAccountPtr = *TempPtr;
        }
    }
 
    if (!ErrorStr.IsEmpty())
    {
        Warn("Login request failed. %s", *ErrorStr);
#if ENGINE_MAJOR_VERSION >= 5
        TriggerOnLoginCompleteDelegates(LocalUserNum, false, FUniqueNetIdPixoVR::EmptyId().Get(), ErrorStr);
#else
        TriggerOnLoginCompleteDelegates(LocalUserNum, false, FUniqueNetIdPixoVR(), ErrorStr);
#endif
        return false;
    }
 
    TriggerOnLoginCompleteDelegates(LocalUserNum, true, UserAccountPtr->GetUserId().Get(), ErrorStr);
    return true;
}
 
bool FPVROIdentity::Logout(int32 LocalUserNum)
{
    FUniqueNetIdPtr UserIdPtr = GetUniquePlayerId(LocalUserNum);
    if (UserIdPtr.IsValid())
    {
        // remove cached user account
#if ENGINE_MAJOR_VERSION >= 5
        UserAccounts.Remove(FUniqueNetIdPixoVR::Cast(*UserIdPtr));
#else
        UserAccounts.Remove(FUniqueNetIdPixoVR(*UserIdPtr));
#endif
        // remove cached user id
        UserIds.Remove(LocalUserNum);
        // not async but should call completion delegate anyway
        TriggerOnLogoutCompleteDelegates(LocalUserNum, true);
 
        return true;
    }
    else
    {
        Warn("No logged in user found for LocalUserNum=%d.", LocalUserNum);
        TriggerOnLogoutCompleteDelegates(LocalUserNum, false);
    }
    return false;
}
 
bool FPVROIdentity::AutoLogin(int32 LocalUserNum)
{
    FString LoginStr;
    FString PasswordStr;
    FString TypeStr;
 
    FParse::Value(FCommandLine::Get(), TEXT("AUTH_LOGIN="), LoginStr);
    FParse::Value(FCommandLine::Get(), TEXT("AUTH_PASSWORD="), PasswordStr);
    FParse::Value(FCommandLine::Get(), TEXT("AUTH_TYPE="), TypeStr);
 
    bool bEnableWarning = LoginStr.Len() > 0 || PasswordStr.Len() > 0 || TypeStr.Len() > 0;
    
    if (!LoginStr.IsEmpty())
    {
        if (!PasswordStr.IsEmpty())
        {
            if (!TypeStr.IsEmpty())
            {
                return Login(0, FOnlineAccountCredentials(TypeStr, LoginStr, PasswordStr));
            }
            else if (bEnableWarning)
            {
                Warn("AutoLogin missing AUTH_TYPE=<type>.");
            }
        }
        else if (bEnableWarning)
        {
            Warn("AutoLogin missing AUTH_PASSWORD=<password>.");
        }
    }
    else if (bEnableWarning)
    {
        Warn("AutoLogin missing AUTH_LOGIN=<login id>.");
    }
 
    return false;
}
 
TSharedPtr<FUserOnlineAccount> FPVROIdentity::GetUserAccount(const FUniqueNetId& UserId) const
{
    TSharedPtr<FUserOnlineAccount> Result;
 
#if ENGINE_MAJOR_VERSION >= 5
    FUniqueNetIdPixoVR StringUserId = FUniqueNetIdPixoVR::Cast(UserId);
#else
    FUniqueNetIdPixoVR StringUserId(UserId);
#endif
    const TSharedRef<FPVROUserAccount>* FoundUserAccount = UserAccounts.Find(StringUserId);
    if (FoundUserAccount != nullptr)
    {
        Result = *FoundUserAccount;
    }
 
    return Result;
}
 
TArray<TSharedPtr<FUserOnlineAccount> > FPVROIdentity::GetAllUserAccounts() const
{
    TArray<TSharedPtr<FUserOnlineAccount> > Result;
    
    for (TMap<FUniqueNetIdPixoVR, TSharedRef<FPVROUserAccount>>::TConstIterator It(UserAccounts); It; ++It)
    {
        Result.Add(It.Value());
    }
 
    return Result;
}
 
FUniqueNetIdPtr FPVROIdentity::GetUniquePlayerId(int32 LocalUserNum) const
{
    const FUniqueNetIdPtr* FoundId = UserIds.Find(LocalUserNum);
    if (FoundId != nullptr)
    {
        return *FoundId;
    }
    return nullptr;
}
 
FUniqueNetIdPtr FPVROIdentity::CreateUniquePlayerId(uint8* Bytes, int32 Size)
{
    if (Bytes != nullptr && Size > 0)
    {
        FString StrId(Size, (TCHAR*)Bytes);
#if ENGINE_MAJOR_VERSION >= 5
        return FUniqueNetIdPixoVR::Create(StrId);
#else
        return MakeShareable(new FUniqueNetIdPixoVR(StrId));
#endif
 
    }
    return nullptr;
}
 
FUniqueNetIdPtr FPVROIdentity::CreateUniquePlayerId(const FString& Str)
{
#if ENGINE_MAJOR_VERSION >= 5
    return FUniqueNetIdPixoVR::Create(Str);
#else
    return MakeShareable(new FUniqueNetIdPixoVR(Str));
#endif
}
 
ELoginStatus::Type FPVROIdentity::GetLoginStatus(int32 LocalUserNum) const
{
    FUniqueNetIdPtr UserId = GetUniquePlayerId(LocalUserNum);
    if (UserId.IsValid())
    {
        return GetLoginStatus(*UserId);
    }
    return ELoginStatus::NotLoggedIn;
}
 
ELoginStatus::Type FPVROIdentity::GetLoginStatus(const FUniqueNetId& UserId) const 
{
    TSharedPtr<FUserOnlineAccount> UserAccount = GetUserAccount(UserId);
    if (UserAccount.IsValid() &&
        UserAccount->GetUserId()->IsValid())
    {
        return ELoginStatus::LoggedIn;
    }
    return ELoginStatus::NotLoggedIn;
}
 
FString FPVROIdentity::GetPlayerNickname(int32 LocalUserNum) const
{
    FUniqueNetIdPtr UniqueId = GetUniquePlayerId(LocalUserNum);
    if (UniqueId.IsValid())
    {
        return UniqueId->ToString();
    }
 
    return TEXT("PixoVRUser");
}
 
FString FPVROIdentity::GetPlayerNickname(const FUniqueNetId& UserId) const
{
    return UserId.ToString();
}
 
void FPVROIdentity::SetPlayerNickname(int32 LocalUserNum, const FString PlayerNickname)
{
    FUniqueNetIdPtr UniqueId = GetUniquePlayerId(LocalUserNum);
    if (UniqueId.IsValid())
    {
        SetPlayerNickname(*UniqueId, PlayerNickname);
    }
}
 
void FPVROIdentity::SetPlayerNickname(const FUniqueNetId& UserId, const FString PlayerNickname)
{
    const FUniqueNetIdPixoVR* UniqueIdStr = (FUniqueNetIdPixoVR*)(&UserId);
    TSharedRef<FPVROUserAccount>* UserAccountPtr = UserAccounts.Find(*UniqueIdStr);
    if (UserAccountPtr)
    {
        UserAccountPtr->Get().UserName = PlayerNickname;
    }
}
 
FString FPVROIdentity::GetAuthToken(int32 LocalUserNum) const
{
    FUniqueNetIdPtr UserId = GetUniquePlayerId(LocalUserNum);
    if (UserId.IsValid())
    {
        TSharedPtr<FUserOnlineAccount> UserAccount = GetUserAccount(*UserId);
        if (UserAccount.IsValid())
        {
            return UserAccount->GetAccessToken();
        }
    }
    return FString();
}
 
void FPVROIdentity::RevokeAuthToken(const FUniqueNetId& UserId, const FOnRevokeAuthTokenCompleteDelegate& Delegate)
{
    Log("FPVROIdentity::RevokeAuthToken not implemented");
}
 
FPVROIdentity::FPVROIdentity(FPVROSubsystem* InSubsystem)
    : Subsystem(InSubsystem)
{
    // autologin the 0-th player
    Login(0, FOnlineAccountCredentials(TEXT("PVROGenericPlayer"), TEXT("PVROGenericUser"), TEXT("PVROGenericId")) );
}
 
FPVROIdentity::~FPVROIdentity()
{
}
 
void FPVROIdentity::GetUserPrivilege(const FUniqueNetId& UserId, EUserPrivileges::Type Privilege, const FOnGetUserPrivilegeCompleteDelegate& Delegate)
{
    Delegate.ExecuteIfBound(UserId, Privilege, (uint32)EPrivilegeResults::NoFailures);
}
 
FPlatformUserId FPVROIdentity::GetPlatformUserIdFromUniqueNetId(const FUniqueNetId& UniqueNetId) const
{
    for (int LocalPlayerIndex = 0; LocalPlayerIndex < MAX_LOCAL_PLAYERS; ++LocalPlayerIndex)
    {
        auto CurrentUniqueId = GetUniquePlayerId(LocalPlayerIndex);
        if (CurrentUniqueId.IsValid() && (*CurrentUniqueId == UniqueNetId))
        {
#if ENGINE_MAJOR_VERSION >= 5
            return GetPlatformUserIdFromLocalUserNum(LocalPlayerIndex);
#else
            return LocalPlayerIndex;
#endif
        }
    }
 
    return PLATFORMUSERID_NONE;
}
 
FString FPVROIdentity::GetAuthType() const
{
    return TEXT("");
}
 
#undef Log
#undef Warn
#undef Error
#undef Fatal