Added identity interface, recompiled all binaries for 4.13.1

Former-commit-id: 8c89eb776e877ee486ca908db651667c7f87e469

Source/AdvancedSessions/Private/AdvancedFriendsGameInstance.cpp

@@ -8,11 +8,14 @@ DEFINE_LOG_CATEGORY(AdvancedFriendsInterfaceLog);
 UAdvancedFriendsGameInstance::UAdvancedFriendsGameInstance(const FObjectInitializer& ObjectInitializer) 
 	: Super(ObjectInitializer)
 	, bCallFriendInterfaceEventsOnPlayerControllers(true)
+	, bCallIdentityInterfaceEventsOnPlayerControllers(true)
 	, bCallVoiceInterfaceEventsOnPlayerControllers(true)
 	, bEnableTalkingStatusDelegate(true)
 	, SessionInviteReceivedDelegate(FOnSessionInviteReceivedDelegate::CreateUObject(this, &ThisClass::OnSessionInviteReceivedMaster))
 	, SessionInviteAcceptedDelegate(FOnSessionUserInviteAcceptedDelegate::CreateUObject(this, &ThisClass::OnSessionInviteAcceptedMaster))
 	, PlayerTalkingStateChangedDelegate(FOnPlayerTalkingStateChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerTalkingStateChangedMaster))
+	, PlayerLoginChangedDelegate(FOnLoginChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerLoginChangedMaster))
+	, PlayerLoginStatusChangedDelegate(FOnLoginStatusChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerLoginStatusChangedMaster))
 {
 }
 
@@ -48,6 +51,18 @@ void UAdvancedFriendsGameInstance::Shutdown()
 		}
 	}
 
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (IdentityInterface.IsValid())
+	{
+		IdentityInterface->ClearOnLoginChangedDelegate_Handle(PlayerLoginChangedDelegateHandle);
+		
+
+		// I am just defaulting to player 1
+		IdentityInterface->ClearOnLoginStatusChangedDelegate_Handle(0, PlayerLoginStatusChangedDelegateHandle);
+	}
+
+
 	Super::Shutdown();
 }
 
@@ -87,6 +102,21 @@ void UAdvancedFriendsGameInstance::Init()
 		}
 	}
 
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (IdentityInterface.IsValid())
+	{
+		PlayerLoginChangedDelegateHandle = IdentityInterface->AddOnLoginChangedDelegate_Handle(PlayerLoginChangedDelegate);
+
+		// Just defaulting to player 1
+		PlayerLoginStatusChangedDelegateHandle = IdentityInterface->AddOnLoginStatusChangedDelegate_Handle(0, PlayerLoginStatusChangedDelegate);
+	}
+	else
+	{
+		UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get identity interface!"));
+	}
+
+
 	Super::Init();
 }
 
@@ -128,6 +158,58 @@ void UAdvancedFriendsGameInstance::Init()
 	}
 }*/
 
+void UAdvancedFriendsGameInstance::OnPlayerLoginStatusChangedMaster(int32 PlayerNum, ELoginStatus::Type PreviousStatus, ELoginStatus::Type NewStatus, const FUniqueNetId & NewPlayerUniqueNetID)
+{
+	EBPLoginStatus OrigStatus = (EBPLoginStatus)PreviousStatus;
+	EBPLoginStatus CurrentStatus = (EBPLoginStatus)NewStatus;
+	FBPUniqueNetId PlayerID;
+	PlayerID.SetUniqueNetId(&NewPlayerUniqueNetID);
+
+	OnPlayerLoginStatusChanged(PlayerNum, OrigStatus,CurrentStatus,PlayerID);
+
+
+	if (bCallIdentityInterfaceEventsOnPlayerControllers)
+	{
+		APlayerController* Player = UGameplayStatics::GetPlayerController(GetWorld(), PlayerNum);
+
+		if (Player != NULL)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnPlayerLoginStatusChanged(Player, OrigStatus, CurrentStatus, PlayerID);
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnPlayerLoginStatusChangedMaster!"));
+		}
+	}
+}
+
+void UAdvancedFriendsGameInstance::OnPlayerLoginChangedMaster(int32 PlayerNum)
+{
+	OnPlayerLoginChanged(PlayerNum);
+
+	if (bCallIdentityInterfaceEventsOnPlayerControllers)
+	{
+		APlayerController* Player = UGameplayStatics::GetPlayerController(GetWorld(), PlayerNum);
+
+		if (Player != NULL)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnPlayerLoginChanged(Player, PlayerNum);
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnPlayerLoginChanged!"));
+		}
+	}
+}
+
 void UAdvancedFriendsGameInstance::OnPlayerTalkingStateChangedMaster(TSharedRef<const FUniqueNetId> PlayerId, bool bIsTalking)
 {
 	FBPUniqueNetId PlayerTalking;

Source/AdvancedSessions/Private/AdvancedIdentityLibrary.cpp

@@ -0,0 +1,198 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "OnlineSubSystemHeader.h"
+#include "AdvancedIdentityLibrary.h"
+
+//General Log
+DEFINE_LOG_CATEGORY(AdvancedIdentityLog);
+
+void UAdvancedIdentityLibrary::GetPlayerNickname(const FBPUniqueNetId & UniqueNetID, FString & PlayerNickname)
+{
+	if (!UniqueNetID.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetPlayerNickname was passed a bad player uniquenetid!"));
+		return;
+	}
+
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (!IdentityInterface.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetPlayerNickname Failed to get identity interface!"));
+		return;
+	}
+
+	PlayerNickname = IdentityInterface->GetPlayerNickname(*UniqueNetID.GetUniqueNetId());
+}
+
+
+void UAdvancedIdentityLibrary::GetLoginStatus(const FBPUniqueNetId & UniqueNetID, EBPLoginStatus & LoginStatus, EBlueprintResultSwitch &Result)
+{
+	if(!UniqueNetID.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetLoginStatus was passed a bad player uniquenetid!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (!IdentityInterface.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetLoginStatus Failed to get identity interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	LoginStatus = (EBPLoginStatus)IdentityInterface->GetLoginStatus(*UniqueNetID.GetUniqueNetId());
+	EBlueprintResultSwitch::OnSuccess;
+}
+
+
+void UAdvancedIdentityLibrary::GetAllUserAccounts(TArray<FBPUserOnlineAccount> & AccountInfos, EBlueprintResultSwitch &Result)
+{
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (!IdentityInterface.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetAllUserAccounts Failed to get identity interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	TArray<TSharedPtr<FUserOnlineAccount>> accountInfos = IdentityInterface->GetAllUserAccounts();
+
+	for (int i = 0; i < accountInfos.Num(); ++i)
+	{
+		AccountInfos.Add(FBPUserOnlineAccount(accountInfos[i]));
+	}
+
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedIdentityLibrary::GetUserAccount(const FBPUniqueNetId & UniqueNetId, FBPUserOnlineAccount & AccountInfo, EBlueprintResultSwitch &Result)
+{
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface();
+
+	if (!IdentityInterface.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccount Failed to get identity interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	TSharedPtr<FUserOnlineAccount> accountInfo = IdentityInterface->GetUserAccount(*UniqueNetId.GetUniqueNetId());
+
+	if (!accountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccount Failed to get the account!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	AccountInfo.UserAccountInfo = accountInfo;
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedIdentityLibrary::GetUserAccountAccessToken(const FBPUserOnlineAccount & AccountInfo, FString & AccessToken)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountAccessToken was passed an invalid account!"));
+		return;
+	}
+
+	AccessToken = AccountInfo.UserAccountInfo->GetAccessToken();
+}
+
+void UAdvancedIdentityLibrary::GetUserAccountAuthAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, FString & AuthAttribute, EBlueprintResultSwitch &Result)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountAuthAttribute was passed an invalid account!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	if (!AccountInfo.UserAccountInfo->GetAuthAttribute(AttributeName, AuthAttribute))
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountAuthAttribute couldn't find the attribute!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedIdentityLibrary::SetUserAccountAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, const FString & NewAttributeValue, EBlueprintResultSwitch &Result)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("SetUserAccountAuthAttribute was passed an invalid account!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	if (!AccountInfo.UserAccountInfo->SetUserAttribute(AttributeName, NewAttributeValue))
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("SetUserAccountAuthAttribute was unable to set the attribute!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedIdentityLibrary::GetUserID(const FBPUserOnlineAccount & AccountInfo, FBPUniqueNetId & UniqueNetID)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserID was passed an invalid account!"));
+		return;
+	}
+
+	
+	UniqueNetID.SetUniqueNetId(AccountInfo.UserAccountInfo->GetUserId());
+}
+
+void UAdvancedIdentityLibrary::GetUserAccountRealName(const FBPUserOnlineAccount & AccountInfo, FString & UserName)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountRealName was passed an invalid account!"));
+		return;
+	}
+
+
+	UserName = AccountInfo.UserAccountInfo->GetRealName();
+}
+
+void UAdvancedIdentityLibrary::GetUserAccountDisplayName(const FBPUserOnlineAccount & AccountInfo, FString & DisplayName)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountDisplayName was passed an invalid account!"));
+		return;
+	}
+
+
+	DisplayName = AccountInfo.UserAccountInfo->GetDisplayName();
+}
+
+void UAdvancedIdentityLibrary::GetUserAccountAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, FString & AttributeValue, EBlueprintResultSwitch &Result)
+{
+	if (!AccountInfo.UserAccountInfo.IsValid())
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountAttribute was passed an invalid account!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	if (!AccountInfo.UserAccountInfo->GetUserAttribute(AttributeName, AttributeValue))
+	{
+		UE_LOG(AdvancedIdentityLog, Warning, TEXT("GetUserAccountAttribute failed to get user attribute!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	Result = EBlueprintResultSwitch::OnSuccess;
+}

Source/AdvancedSessions/Private/GetUserPrivilegeCallbackProxy.cpp

@@ -0,0 +1,40 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+
+#include "OnlineSubSystemHeader.h"
+#include "GetUserPrivilegeCallbackProxy.h"
+
+//////////////////////////////////////////////////////////////////////////
+// UGetUserPrivilegeCallbackProxy
+
+UGetUserPrivilegeCallbackProxy::UGetUserPrivilegeCallbackProxy(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+UGetUserPrivilegeCallbackProxy* UGetUserPrivilegeCallbackProxy::GetUserPrivilege(UObject* WorldContextObject, const EBPUserPrivileges & PrivilegeToCheck, const FBPUniqueNetId & PlayerUniqueNetID)
+{
+	UGetUserPrivilegeCallbackProxy* Proxy = NewObject<UGetUserPrivilegeCallbackProxy>();
+	Proxy->PlayerUniqueNetID.SetUniqueNetId(PlayerUniqueNetID.GetUniqueNetId());
+	Proxy->UserPrivilege = PrivilegeToCheck;
+	Proxy->WorldContextObject = WorldContextObject;
+	return Proxy;
+}
+
+void UGetUserPrivilegeCallbackProxy::Activate()
+{
+	auto Identity = Online::GetIdentityInterface();
+
+	if (Identity.IsValid())
+	{
+		Identity->GetUserPrivilege(*PlayerUniqueNetID.GetUniqueNetId(), (EUserPrivileges::Type)UserPrivilege, IOnlineIdentity::FOnGetUserPrivilegeCompleteDelegate::CreateUObject(this, &ThisClass::OnCompleted));
+		return;
+	}
+
+	// Fail immediately
+	OnFailure.Broadcast();
+}
+
+void UGetUserPrivilegeCallbackProxy::OnCompleted(const FUniqueNetId& PlayerID, EUserPrivileges::Type Privilege, uint32 PrivilegeResult)
+{
+	OnSuccess.Broadcast(/*PlayerID,*/ (EBPUserPrivileges)Privilege, PrivilegeResult == 0);
+}

Source/AdvancedSessions/Private/LoginUserCallbackProxy.cpp

@@ -0,0 +1,81 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+
+#include "OnlineSubSystemHeader.h"
+#include "LoginUserCallbackProxy.h"
+
+//////////////////////////////////////////////////////////////////////////
+// ULoginUserCallbackProxy
+
+ULoginUserCallbackProxy::ULoginUserCallbackProxy(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+	, Delegate(FOnLoginCompleteDelegate::CreateUObject(this, &ThisClass::OnCompleted))
+{
+}
+
+ULoginUserCallbackProxy* ULoginUserCallbackProxy::LoginUser(UObject* WorldContextObject, class APlayerController* PlayerController, FString UserID, FString UserToken)
+{
+	ULoginUserCallbackProxy* Proxy = NewObject<ULoginUserCallbackProxy>();
+	Proxy->PlayerControllerWeakPtr = PlayerController;
+	Proxy->UserID = UserID;
+	Proxy->UserToken = UserToken;
+	Proxy->WorldContextObject = WorldContextObject;
+	return Proxy;
+}
+
+void ULoginUserCallbackProxy::Activate()
+{
+
+	if (!PlayerControllerWeakPtr.IsValid())
+	{
+		OnFailure.Broadcast();
+		return;
+	}
+
+	ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerControllerWeakPtr->Player);
+
+	if (!Player)
+	{
+		OnFailure.Broadcast();
+		return;
+	}
+
+	auto Identity = Online::GetIdentityInterface();
+
+	if (Identity.IsValid())
+	{
+		DelegateHandle = Identity->AddOnLoginCompleteDelegate_Handle(Player->GetControllerId(), Delegate);
+		FOnlineAccountCredentials AccountCreds(Identity->GetAuthType(), UserID, UserToken);
+		Identity->Login(Player->GetControllerId(), AccountCreds);
+		return;
+	}
+
+	// Fail immediately
+	OnFailure.Broadcast();
+}
+
+void ULoginUserCallbackProxy::OnCompleted(int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& ErrorVal)
+{
+	if (PlayerControllerWeakPtr.IsValid())
+	{
+		ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerControllerWeakPtr->Player);
+
+		if (Player)
+		{
+			auto Identity = Online::GetIdentityInterface();
+
+			if (Identity.IsValid())
+			{
+				Identity->ClearOnLoginCompleteDelegate_Handle(Player->GetControllerId(), DelegateHandle);
+			}
+		}
+	}
+
+	if (bWasSuccessful)
+	{
+		OnSuccess.Broadcast();
+	}
+	else
+	{
+		OnFailure.Broadcast();
+	}
+}

Source/AdvancedSessions/Private/LogoutUserCallbackProxy.cpp

@@ -0,0 +1,80 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+
+#include "OnlineSubSystemHeader.h"
+#include "LogoutUserCallbackProxy.h"
+
+//////////////////////////////////////////////////////////////////////////
+// ULogoutUserCallbackProxy
+
+ULogoutUserCallbackProxy::ULogoutUserCallbackProxy(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+	, Delegate(FOnLogoutCompleteDelegate::CreateUObject(this, &ThisClass::OnCompleted))
+{
+}
+
+ULogoutUserCallbackProxy* ULogoutUserCallbackProxy::LogoutUser(UObject* WorldContextObject, class APlayerController* PlayerController)
+{
+	ULogoutUserCallbackProxy* Proxy = NewObject<ULogoutUserCallbackProxy>();
+	Proxy->PlayerControllerWeakPtr = PlayerController;
+	Proxy->WorldContextObject = WorldContextObject;
+	return Proxy;
+}
+
+void ULogoutUserCallbackProxy::Activate()
+{
+
+	if (!PlayerControllerWeakPtr.IsValid())
+	{
+		OnFailure.Broadcast();
+		return;
+	}
+
+
+	ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerControllerWeakPtr->Player);
+
+	if (!Player)
+	{
+		OnFailure.Broadcast();
+		return;
+	}
+
+	auto Identity = Online::GetIdentityInterface();
+
+	if (Identity.IsValid())
+	{
+		DelegateHandle = Identity->AddOnLogoutCompleteDelegate_Handle(Player->GetControllerId(), Delegate);
+		Identity->Logout(Player->GetControllerId());
+		return;
+	}
+
+	// Fail immediately
+	OnFailure.Broadcast();
+}
+
+void ULogoutUserCallbackProxy::OnCompleted(int LocalUserNum, bool bWasSuccessful)
+{
+
+	if (PlayerControllerWeakPtr.IsValid())
+	{
+		ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerControllerWeakPtr->Player);
+
+		if (Player)
+		{
+			auto Identity = Online::GetIdentityInterface();
+
+			if (Identity.IsValid())
+			{
+				Identity->ClearOnLogoutCompleteDelegate_Handle(Player->GetControllerId(), DelegateHandle);
+			}
+		}
+	}
+
+	if (bWasSuccessful)
+	{
+		OnSuccess.Broadcast();
+	}
+	else
+	{
+		OnFailure.Broadcast();
+	}
+}