techy/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fcc1b09210e7832a5d82e53c2d2ef95b20f8430a
UnrealEngine/Engine/Plugins/Online/OnlineFramework/Source/Party/Private/SocialManager.cpp
Brandyn / Techy fcc1b09210 init
2026-04-04 15:40:51 -05:00

1367 lines
50 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SocialManager.h"
#include "Engine/GameInstance.h"
#include "Engine/GameViewportClient.h"
#include "Interactions/SocialInteractionMacros.h"
#include "SocialToolkit.h"
#include "Online/OnlineSessionNames.h"
#include "SocialDebugTools.h"
#include "Interactions/CoreInteractions.h"
#include "Interactions/PartyInteractions.h"
#include "OnlineSessionSettings.h"
#include "Party/SocialParty.h"
#include "Party/PartyMember.h"
#include "Party/PartyPlatformSessionMonitor.h"
#include "OnlineSubsystemUtils.h"
#include "Engine/LocalPlayer.h"
#include UE_INLINE_GENERATED_CPP_BY_NAME(SocialManager)
#if PARTY_PLATFORM_SESSIONS_XBL
#include "Misc/Base64.h"
#endif
#if !UE_BUILD_SHIPPING
static TAutoConsoleVariable<bool> CVarForceDisconnectedToPartyService(
TEXT("SocialUI.ForceDisconnectedToPartyService"),
false,
TEXT("Overrides the bIsConnectedToPartyService state"));
#endif
namespace UE::OnlineFramework::CVars
{
bool bAssignPartyJoinInfoOnPartyJoinFailure = true;
static FAutoConsoleVariableRef CVarAssignPartyJoinInfoOnPartyJoinFailure(
TEXT("Party.AssignPartyJoinInfoOnPartyJoinFailure"), bAssignPartyJoinInfoOnPartyJoinFailure,
TEXT("Temporary cvar (remove after proven stable), whether to set the party join info on the join attempt when ValidateJoinTarget fails"),
ECVF_Default);
}
//////////////////////////////////////////////////////////////////////////
// FJoinPartyAttempt
//////////////////////////////////////////////////////////////////////////
USocialManager::FJoinPartyAttempt::FJoinPartyAttempt(const USocialUser* InTargetUser, const FOnlinePartyTypeId& InPartyTypeId, const FName& InJoinMethod, const FOnJoinPartyAttemptComplete& InOnJoinComplete)
: TargetUser(InTargetUser)
, PartyTypeId(InPartyTypeId)
, JoinMethod(InJoinMethod)
, OnJoinComplete(InOnJoinComplete)
{}
FString USocialManager::FJoinPartyAttempt::ToDebugString() const
{
return FString::Printf(TEXT("TargetUser(%s), PartyId(%s), TypeId(%d), TargetUserPlatformId(%s), JoinMethod(%s)"),
TargetUser.IsValid() ? *TargetUser->ToDebugString() : TEXT("invalid"),
JoinInfo.IsValid() ? *JoinInfo->GetPartyId()->ToDebugString() : TEXT("unknown"),
PartyTypeId.GetValue(),
*TargetUserPlatformId.ToDebugString(),
*JoinMethod.ToString());
}
const FName USocialManager::FJoinPartyAttempt::Step_FindPlatformSession = TEXT("FindPlatformSession");
const FName USocialManager::FJoinPartyAttempt::Step_QueryJoinability = TEXT("QueryJoinability");
const FName USocialManager::FJoinPartyAttempt::Step_LeaveCurrentParty = TEXT("LeaveCurrentParty");
const FName USocialManager::FJoinPartyAttempt::Step_JoinParty = TEXT("JoinParty");
const FName USocialManager::FJoinPartyAttempt::Step_DeferredPartyCreation = TEXT("DeferredPartyCreation");
const FName USocialManager::FJoinPartyAttempt::Step_WaitForPersistentPartyCreation = TEXT("WaitForPersistentPartyCreation");
//////////////////////////////////////////////////////////////////////////
// USocialManager
//////////////////////////////////////////////////////////////////////////
TArray<ESocialSubsystem> USocialManager::DefaultSubsystems;
TArray<FSocialInteractionHandle> USocialManager::RegisteredInteractions;
/*static*/bool USocialManager::IsSocialSubsystemEnabled(ESocialSubsystem SubsystemType)
{
return GetSocialOss(nullptr, SubsystemType) != nullptr;
}
/*static*/FName USocialManager::GetSocialOssName(ESocialSubsystem SubsystemType)
{
if (IOnlineSubsystem* SocialOSS = GetSocialOss(nullptr, SubsystemType))
{
return SocialOSS->GetSubsystemName();
}
return NAME_None;
}
/*static*/ FText USocialManager::GetSocialOssPlatformName(ESocialSubsystem SubsystemType)
{
if (IOnlineSubsystem* SocialOSS = GetSocialOss(nullptr, SubsystemType))
{
return SocialOSS->GetSocialPlatformName();
}
return FText::GetEmpty();
}
/*static*/IOnlineSubsystem* USocialManager::GetSocialOss(UWorld* World, ESocialSubsystem SubsystemType)
{
if (SubsystemType == ESocialSubsystem::Primary)
{
IOnlineSubsystem* PrimaryOss = Online::GetSubsystem(World);
if (PrimaryOss && !PrimaryOss->GetSubsystemName().IsEqual(NULL_SUBSYSTEM))
{
return PrimaryOss;
}
}
else if (SubsystemType == ESocialSubsystem::Platform)
{
if (IOnlineSubsystem::IsEnabled(TENCENT_SUBSYSTEM))
{
return Online::GetSubsystem(World, TENCENT_SUBSYSTEM);
}
/*else if (IOnlineSubsystem::IsEnabled(STEAM_SUBSYSTEM))
{
return Online::GetSubsystem(World, STEAM_SUBSYSTEM);
}*/
else
{
return IOnlineSubsystem::GetByPlatform();
}
}
return nullptr;
}
FUserPlatform USocialManager::GetLocalUserPlatform()
{
return IOnlineSubsystem::GetLocalPlatformName();
}
USocialManager::USocialManager()
: ToolkitClass(USocialToolkit::StaticClass())
{
if (!IsTemplate())
{
if (DefaultSubsystems.Num() == 0)
{
//@todo DanH social: This module assumes there is a primary (aka mcp) OSS available that other accounts are linked to. Consider whether we want to support platform-only situations with this module #future
if (IsSocialSubsystemEnabled(ESocialSubsystem::Primary))
{
DefaultSubsystems.Add(ESocialSubsystem::Primary);
if (IsSocialSubsystemEnabled(ESocialSubsystem::Platform))
{
DefaultSubsystems.Add(ESocialSubsystem::Platform);
}
}
}
}
}
void USocialManager::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
Super::AddReferencedObjects(InThis, Collector);
USocialManager& This = *CastChecked<USocialManager>(InThis);
Collector.AddReferencedObjects(This.JoinedPartiesByTypeId);
Collector.AddReferencedObjects(This.LeavingPartiesByTypeId);
}
void USocialManager::InitSocialManager()
{
if (RegisteredInteractions.Num() == 0)
{
RegisterSocialInteractions();
}
if (FPartyPlatformSessionManager::DoesOssNeedPartySession(GetSocialOssName(ESocialSubsystem::Platform)))
{
// We're on a platform that requires a platform session backing each party, so spin up the manager to take care of that
PartySessionManager = FPartyPlatformSessionManager::Create(*this);
}
UGameInstance& GameInstance = GetGameInstance();
GameInstance.OnNotifyPreClientTravel().AddUObject(this, &USocialManager::HandlePreClientTravel);
if (GameInstance.GetGameViewportClient())
{
HandleGameViewportInitialized();
}
else
{
UGameViewportClient::OnViewportCreated().AddUObject(this, &USocialManager::HandleGameViewportInitialized);
}
//@todo DanH Sessions: So it's only at the FortOnlineSessionClient level that the console session interface is used #required
// Technically I could have the platform session manager just listen to the platform session interface itself for invites, but then I'm sure we miss out on functionality
// Having this happen only at the Fort level though is a travesty, we NEED to know when a platform session invite has been accepted
/*if (UOnlineSession* OnlineSession = GameInstance.GetOnlineSession())
{
OnlineSession->OnSessionInviteAccepted().BindUObject(this, &UFortSocialManager::ProcessConsoleInvite);
}*/
// Because multiclient PIE, we need to have a world to be able to access the appropriate OSS suite
FCoreUObjectDelegates::PostLoadMapWithWorld.AddUObject(this, &USocialManager::HandleWorldEstablished);
if (UWorld* World = GetWorld())
{
HandleWorldEstablished(World);
}
#if !UE_SERVER && !UE_BUILD_SHIPPING
SocialDebugTools = NewObject<USocialDebugTools>(this, GetSocialDebugToolsClass());
check(SocialDebugTools);
#endif
}
void USocialManager::ShutdownSocialManager()
{
bCanCreatePartyObjects = false;
JoinAttemptsByTypeId.Reset();
// Mark all parties and members pending kill to prevent any callbacks from being triggered on them during shutdown
const auto ShutdownPartiesFunc =
[this] (TMap<FOnlinePartyTypeId, TObjectPtr<USocialParty>>& PartiesByTypeId)
{
for (auto& TypeIdPartyPair : PartiesByTypeId)
{
for (UPartyMember* PartyMember : TypeIdPartyPair.Value->GetPartyMembers())
{
PartyMember->MarkAsGarbage();
}
TypeIdPartyPair.Value->MarkAsGarbage();
}
PartiesByTypeId.Reset();
};
ShutdownPartiesFunc(JoinedPartiesByTypeId);
ShutdownPartiesFunc(LeavingPartiesByTypeId);
if (SocialDebugTools)
{
SocialDebugTools->Shutdown();
SocialDebugTools = nullptr;
}
// We could have outstanding OSS queries and requests, and we are no longer interested in getting any callbacks triggered
bShutdownPending = true;
}
USocialToolkit& USocialManager::GetSocialToolkit(const ULocalPlayer& LocalPlayer) const
{
USocialToolkit* FoundToolkit = nullptr;
for (USocialToolkit* Toolkit : SocialToolkits)
{
if (&LocalPlayer == Toolkit->GetOwningLocalPlayerPtr())
{
FoundToolkit = Toolkit;
break;
}
}
checkf(FoundToolkit, TEXT("No SocialToolkit exists for LocalPlayer [%s]. Should be impossible. Was the LocalPlayer created correctly via UGameInstance::CreateLocalPlayer?"), *LocalPlayer.GetName());
return *FoundToolkit;
}
USocialToolkit* USocialManager::GetSocialToolkit(int32 LocalPlayerNum) const
{
for (USocialToolkit* Toolkit : SocialToolkits)
{
if (Toolkit->GetLocalUserNum() == LocalPlayerNum)
{
return Toolkit;
}
}
return nullptr;
}
USocialToolkit* USocialManager::GetSocialToolkit(FUniqueNetIdRepl LocalUserId) const
{
for (USocialToolkit* Toolkit : SocialToolkits)
{
const ULocalPlayer* LocalPlayer = Toolkit->GetOwningLocalPlayerPtr();
if (LocalPlayer && LocalPlayer->GetPreferredUniqueNetId() == LocalUserId)
{
return Toolkit;
}
}
return nullptr;
}
TSubclassOf<USocialDebugTools> USocialManager::GetSocialDebugToolsClass() const
{
return USocialDebugTools::StaticClass();
}
USocialToolkit* USocialManager::GetFirstLocalUserToolkit() const
{
if (SocialToolkits.Num() > 0)
{
return SocialToolkits[0];
}
return nullptr;
}
FUniqueNetIdRepl USocialManager::GetFirstLocalUserId(ESocialSubsystem SubsystemType) const
{
if (SocialToolkits.Num() > 0)
{
return SocialToolkits[0]->GetLocalUserNetId(SubsystemType);
}
return FUniqueNetIdRepl();
}
bool USocialManager::IsLocalUser(const FUniqueNetIdRepl& LocalUserId, ESocialSubsystem SubsystemType) const
{
for(USocialToolkit* SocialToolkit : SocialToolkits)
{
if (SocialToolkit->GetLocalUserNetId(SubsystemType) == LocalUserId)
{
return true;
}
}
return false;
}
int32 USocialManager::GetFirstLocalUserNum() const
{
if (SocialToolkits.Num() > 0)
{
return SocialToolkits[0]->GetLocalUserNum();
}
return 0;
}
void USocialManager::CreateParty(const FOnlinePartyTypeId& PartyTypeId, const FPartyConfiguration& PartyConfig, const FOnCreatePartyAttemptComplete& OnCreatePartyComplete)
{
if (const USocialParty* ExistingParty = GetPartyInternal(PartyTypeId, true))
{
UE_LOG(LogParty, Warning, TEXT("Existing party [%s] of type [%d] found when trying to create a new one. Cannot create new one until the existing one has been left."), *ExistingParty->GetPartyId().ToDebugString(), PartyTypeId.GetValue());
OnCreatePartyComplete.ExecuteIfBound(ECreatePartyCompletionResult::AlreadyInPartyOfSpecifiedType);
}
else
{
// Only the primary local player can create parties (which secondary players will auto-join)
FUniqueNetIdRepl PrimaryLocalUserId = GetFirstLocalUserId(ESocialSubsystem::Primary);
IOnlinePartyPtr PartyInterface = Online::GetPartyInterface(GetWorld());
if (PartyInterface.IsValid() && PrimaryLocalUserId.IsValid())
{
PartyInterface->CreateParty(*PrimaryLocalUserId, PartyTypeId, PartyConfig, FOnCreatePartyComplete::CreateUObject(this, &USocialManager::HandleCreatePartyComplete, PartyTypeId, OnCreatePartyComplete));
}
else
{
UE_LOG(LogParty, Warning, TEXT("Cannot create party of type [%d] - PartyInterface.IsValid=%s PrimaryLocalUserId.IsValid=%s primary OSS [%s]"), PartyTypeId.GetValue(), *LexToString(PartyInterface.IsValid()), *LexToString(PrimaryLocalUserId.IsValid()), *GetSocialOssName(ESocialSubsystem::Primary).ToString());
OnCreatePartyComplete.ExecuteIfBound(ECreatePartyCompletionResult::UnknownClientFailure);
}
}
}
void USocialManager::CreatePersistentParty(const FOnCreatePartyAttemptComplete& OnCreatePartyComplete)
{
UE_LOG(LogParty, Log, TEXT("Attempting to create new persistent party"));
// If the player tries to join a party while persistent party creation is in progress, the persistent party
// should be left when creation completes before attempting to handle the join attempt.
bCreatingPersistentParty = true;
// The persistent party starts off closed by default, and will update its config as desired after initializing
FPartyConfiguration InitialPersistentPartyConfig;
InitialPersistentPartyConfig.JoinRequestAction = EJoinRequestAction::Manual;
InitialPersistentPartyConfig.bIsAcceptingMembers = false;
InitialPersistentPartyConfig.bShouldRemoveOnDisconnection = true;
InitialPersistentPartyConfig.PresencePermissions = PartySystemPermissions::EPermissionType::Noone;
InitialPersistentPartyConfig.InvitePermissions = PartySystemPermissions::EPermissionType::Noone;
InitialPersistentPartyConfig.MaxMembers = USocialSettings::GetDefaultMaxPartySize();
CreateParty(IOnlinePartySystem::GetPrimaryPartyTypeId(), InitialPersistentPartyConfig, FOnCreatePartyAttemptComplete::CreateUObject(this, &USocialManager::OnCreatePersistentPartyCompleteInternal, OnCreatePartyComplete));
}
void USocialManager::OnCreatePersistentPartyCompleteInternal(ECreatePartyCompletionResult Result, FOnCreatePartyAttemptComplete OnCreatePartyComplete)
{
ABORT_DURING_SHUTDOWN();
bCreatingPersistentParty = false;
// Notify completion before possibly tearing down the party for a join attempt.
OnCreatePartyComplete.ExecuteIfBound(Result);
// Leave persistent party if a join attempt was made to a different persistent party while creation was underway.
// OnPartyLeft will handle joining the other persistent party.
if (FJoinPartyAttempt* JoinAttempt = JoinAttemptsByTypeId.Find(IOnlinePartySystem::GetPrimaryPartyTypeId()))
{
JoinAttempt->ActionTimeTracker.CompleteStep(FJoinPartyAttempt::Step_WaitForPersistentPartyCreation);
if (Result == ECreatePartyCompletionResult::Succeeded)
{
if (USocialParty* ExistingParty = GetPartyInternal(IOnlinePartySystem::GetPrimaryPartyTypeId(), true))
{
// Another party of the same type exists - leave that one first
JoinAttempt->ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_LeaveCurrentParty);
if (!ExistingParty->IsCurrentlyLeaving())
{
ExistingParty->LeaveParty(USocialParty::FOnLeavePartyAttemptComplete::CreateUObject(this, &USocialManager::HandleLeavePartyForJoinComplete, ExistingParty));
}
}
else
{
// This case shouldn't really be possible if the create succeeded - attempt to join.
JoinPartyInternal(*JoinAttempt);
}
}
else
{
// Party creation failed, attempt to join.
JoinPartyInternal(*JoinAttempt);
}
}
}
void USocialManager::RegisterSocialInteractions()
{
// Register Party Interactions
RegisterInteraction<FSocialInteraction_JoinParty>();
RegisterInteraction<FSocialInteraction_RequestToJoinParty>();
RegisterInteraction<FSocialInteraction_AcceptJoinRequest>();
RegisterInteraction<FSocialInteraction_DismissJoinRequest>();
RegisterInteraction<FSocialInteraction_InviteToParty>();
RegisterInteraction<FSocialInteraction_AcceptPartyInvite>();
RegisterInteraction<FSocialInteraction_RejectPartyInvite>();
RegisterInteraction<FSocialInteraction_PromoteToPartyLeader>();
RegisterInteraction<FSocialInteraction_KickPartyMember>();
RegisterInteraction<FSocialInteraction_LeaveParty>();
// Register Core interactions
RegisterInteraction<FSocialInteraction_AddFriend>();
RegisterInteraction<FSocialInteraction_AddPlatformFriend>();
RegisterInteraction<FSocialInteraction_AcceptFriendInvite>();
RegisterInteraction<FSocialInteraction_RejectFriendInvite>();
RegisterInteraction<FSocialInteraction_PrivateMessage>();
RegisterInteraction<FSocialInteraction_RemoveFriend>();
RegisterInteraction<FSocialInteraction_Block>();
RegisterInteraction<FSocialInteraction_Unblock>();
RegisterInteraction<FSocialInteraction_ShowPlatformProfile>();
}
FJoinPartyResult USocialManager::ValidateJoinAttempt(const FOnlinePartyTypeId& PartyTypeId) const
{
UE_LOG(LogParty, VeryVerbose, TEXT("Validating join attempt of party of type [%d]"), PartyTypeId.GetValue());
FJoinPartyResult ValidationResult;
IOnlinePartyPtr PartyInterface = Online::GetPartyInterface(GetWorld());
if (!PartyInterface.IsValid())
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::OssUnavailable);
}
else if (JoinAttemptsByTypeId.Contains(PartyTypeId))
{
//@todo DanH Party: Is this ok? Or should we mark the existing attempt as something we should bail asap and restart the process with the new target? #suggested
// We'll need to track join attempts by party ID if that's the case and just be diligent about making sure that only 1 of the same party type is actually live at a time.
return EJoinPartyCompletionResult::AlreadyJoiningParty;
}
else if (!GetPartyClassForType(PartyTypeId))
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::MissingPartyClassForTypeId);
}
return ValidationResult;
}
FJoinPartyResult USocialManager::ValidateJoinTarget(const USocialUser& UserToJoin, const FOnlinePartyTypeId& PartyTypeId) const
{
return ValidateJoinTarget(UserToJoin, PartyTypeId, /*bCheckPlatformSession*/true);
}
bool USocialManager::ShouldReadPresenceFromOnlineServices()
{
if (IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("onlineframework.party.shouldreadpresencefromonlineservices")))
{
return CVar->GetBool();
}
return false;
}
FName USocialManager::GetPresenceFrameworkInstance()
{
return GetDefault<USocialManager>()->PresenceFrameworkInstance;
}
FName USocialManager::GetPresenceFrameworkAdapterInstance()
{
return GetDefault<USocialManager>()->PresenceFrameworkAdapterInstance;
}
FJoinPartyResult USocialManager::ValidateJoinTarget(const USocialUser& UserToJoin, const FOnlinePartyTypeId& PartyTypeId, bool bCheckPlatformSession) const
{
UE_LOG(LogParty, VeryVerbose, TEXT("Validating user [%s] as join target of party type [%d]"), *UserToJoin.ToDebugString(), PartyTypeId.GetValue());
FJoinPartyResult PartyTypeValidation = ValidateJoinAttempt(PartyTypeId);
if (!PartyTypeValidation.WasSuccessful())
{
// Don't bother checking the user for info if we can't even join anyway
return PartyTypeValidation;
}
else if (!UserToJoin.GetOwningToolkit().IsOwnerLoggedIn())
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::NotLoggedIn);
}
else if ((ShouldReadPresenceFromOnlineServices() ? UserToJoin.GetOnlineStatusV2() == UE::Online::EUserPresenceStatus::Away : UserToJoin.GetOnlineStatus() == EOnlinePresenceState::Away) && // Away indicates they do not want to be joined
(!CanAcceptInvitationsFromAwayUsers() || !UserToJoin.HasSentPartyInvite(PartyTypeId))) // They can still send you invitations while away, should we ignore the Away status if we've received an invite?
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserAway);
}
else if (UserToJoin.GetPartyMember(PartyTypeId))
{
return EJoinPartyCompletionResult::AlreadyInParty;
}
else if (UserToJoin.IsBlocked())
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserBlocked);
}
else
{
TSharedPtr<const IOnlinePartyJoinInfo> JoinInfo = UserToJoin.GetPartyJoinInfo(PartyTypeId);
if (JoinInfo.IsValid())
{
if (!JoinInfo->IsValid())
{
return EJoinPartyCompletionResult::JoinInfoInvalid;
}
else if (!JoinInfo->IsAcceptingMembers())
{
FPartyJoinDenialReason DenialReason = JoinInfo->GetNotAcceptingReason();
if (DenialReason.GetReason() != EPartyJoinDenialReason::PartyPrivate || !UserToJoin.HasSentPartyInvite(PartyTypeId))
{
return DenialReason;
}
}
}
else if (UserToJoin.IsFriend(ESocialSubsystem::Platform))
{
ECrossplayPreference Preference = GetCrossplayPreference();
if (UserToJoin.GetCurrentPlatform().IsCrossplayWithLocalPlatform() && OptedOutOfCrossplay(Preference))
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::JoinerCrossplayRestricted);
}
if (const FOnlineUserPresence* PlatformPresence = UserToJoin.GetFriendPresenceInfo(ESocialSubsystem::Platform))
{
if (!PlatformPresence->bIsPlayingThisGame)
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserPlayingDifferentGame);
}
else if (!UserToJoin.HasSentPartyInvite(PartyTypeId))
{
if (!PlatformPresence->bIsJoinable)
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserUnjoinable);
}
else if (!PlatformPresence->SessionId.IsValid() || !PlatformPresence->SessionId->IsValid())
{
if (bCheckPlatformSession)
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserMissingPlatformSession);
}
else
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::PartyPrivate);
}
}
}
}
else
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserMissingPresence);
}
}
else if (!UserToJoin.IsPlayingThisGame())
{
return FPartyJoinDenialReason(EPartyJoinDenialReason::TargetUserPlayingDifferentGame);
}
else
{
// We've got no info on this party for the given user, so it's gotta be private (or doesn't even exist)
return FPartyJoinDenialReason(EPartyJoinDenialReason::PartyPrivate);
}
}
return FJoinPartyResult();
}
bool USocialManager::CanAcceptInvitationsFromAwayUsers() const
{
return bAcceptInvitationsFromAwayUsers;
}
void USocialManager::JoinParty(const USocialUser& UserToJoin, const FOnlinePartyTypeId& PartyTypeId, const FOnJoinPartyAttemptComplete& OnJoinPartyComplete, const FName& JoinMethod)
{
UE_LOG(LogParty, Verbose, TEXT("Attempting to join user [%s]'s party of type [%d] by [%s]"), *UserToJoin.ToDebugString(), PartyTypeId.GetValue(), *JoinMethod.ToString());
FJoinPartyAttempt NewAttempt(&UserToJoin, PartyTypeId, JoinMethod, OnJoinPartyComplete);
NewAttempt.AnalyticsContext = UserToJoin.GetAnalyticsContext();
const FJoinPartyResult ValidationResult = ValidateJoinTarget(UserToJoin, PartyTypeId, /*bCheckPlatformSession*/true);
if (ValidationResult.WasSuccessful())
{
FJoinPartyAttempt& JoinAttempt = JoinAttemptsByTypeId.Add(PartyTypeId, NewAttempt);
JoinAttempt.JoinInfo = UserToJoin.GetPartyJoinInfo(PartyTypeId);
if (JoinAttempt.JoinInfo.IsValid())
{
QueryPartyJoinabilityInternal(JoinAttempt);
}
else
{
JoinAttempt.ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_FindPlatformSession);
PartySessionManager->FindSession(UserToJoin, FPartyPlatformSessionManager::FOnFindSessionAttemptComplete::CreateUObject(this, &USocialManager::HandleFindSessionForJoinComplete, PartyTypeId));
}
}
else
{
if (UE::OnlineFramework::CVars::bAssignPartyJoinInfoOnPartyJoinFailure)
{
NewAttempt.JoinInfo = UserToJoin.GetPartyJoinInfo(PartyTypeId);
}
// We don't do the standard FinishJoinAttempt here because this entry isn't actually in our map of join attempts yet
// It's possible that this attempt failed immediately because a join is already in progress, in which case we don't want to replace the legitimate attempt with the same ID
OnJoinPartyAttemptCompleteInternal(NewAttempt, ValidationResult);
NewAttempt.OnJoinComplete.ExecuteIfBound(ValidationResult);
}
}
void USocialManager::NotifyPartyInitialized(USocialParty& Party)
{
//only make the outside modules aware of party after initialization is complete
OnPartyJoined().Broadcast(Party);
}
bool USocialManager::IsPartyJoinInProgress(const FOnlinePartyTypeId& TypeId) const
{
return JoinAttemptsByTypeId.Contains(TypeId);
}
bool USocialManager::IsPersistentPartyJoinInProgress() const
{
return IsPartyJoinInProgress(IOnlinePartySystem::GetPrimaryPartyTypeId());
}
void USocialManager::FillOutJoinRequestData(const FOnlinePartyId& TargetParty, FOnlinePartyData& OutJoinRequestData) const
{
ECrossplayPreference Preference = GetCrossplayPreference();
if (Preference != ECrossplayPreference::NoSelection)
{
FVariantData CrossplayPreferenceVal;
CrossplayPreferenceVal.SetValue((int32)Preference);
OutJoinRequestData.SetAttribute(TEXT("CrossplayPreference"), CrossplayPreferenceVal);
}
}
TSubclassOf<USocialParty> USocialManager::GetPartyClassForType(const FOnlinePartyTypeId& PartyTypeId) const
{
return USocialParty::StaticClass();
}
void USocialManager::OnJoinPartyAttemptCompleteInternal(const FJoinPartyAttempt& JoinAttemptInfo, const FJoinPartyResult& Result)
{
UE_LOG(LogParty, Verbose, TEXT("JoinPartyAttempt [%s] completed with result [%s] and reason [%s]"), *JoinAttemptInfo.ToDebugString(), ToString(Result.GetResult()), ToString(Result.GetDenialReason().GetReason()));
}
void USocialManager::OnToolkitCreatedInternal(USocialToolkit& NewToolkit)
{
OnSocialToolkitCreated().Broadcast(NewToolkit);
}
bool USocialManager::CanCreateNewPartyObjects() const
{
// At the root level, we just want to be sure that we have a world before spinning up party UObjects
return GetWorld() != nullptr;
}
ECrossplayPreference USocialManager::GetCrossplayPreference() const
{
return ECrossplayPreference::NoSelection;
}
void USocialManager::RefreshCanCreatePartyObjects()
{
const bool bCanNowCreate = CanCreateNewPartyObjects();
if (bCanNowCreate != bCanCreatePartyObjects)
{
bCanCreatePartyObjects = bCanNowCreate;
if (bCanNowCreate && JoinAttemptsByTypeId.Num() > 0)
{
// We'll potentially be removing map entries mid-loop, just work with a copy
auto JoinAttemptsCopy = JoinAttemptsByTypeId;
for (auto& TypeIdJoinAttemptPair : JoinAttemptsCopy)
{
FJoinPartyAttempt& JoinAttempt = TypeIdJoinAttemptPair.Value;
if (JoinAttempt.ActionTimeTracker.GetCurrentStepName() == FJoinPartyAttempt::Step_DeferredPartyCreation && ensure(JoinAttempt.JoinInfo.IsValid()))
{
JoinAttempt.ActionTimeTracker.CompleteStep(FJoinPartyAttempt::Step_DeferredPartyCreation);
FJoinPartyResult JoinResult = EJoinPartyCompletionResult::Succeeded;
if (!EstablishNewParty(*GetFirstLocalUserId(ESocialSubsystem::Primary), *JoinAttempt.JoinInfo->GetPartyId(), JoinAttempt.JoinInfo->GetPartyTypeId()))
{
JoinResult = EJoinPartyCompletionResult::UnknownClientFailure;
}
FinishJoinPartyAttempt(JoinAttempt, JoinResult);
}
}
}
}
}
UGameInstance& USocialManager::GetGameInstance() const
{
return *GetTypedOuter<UGameInstance>();
}
USocialToolkit& USocialManager::CreateSocialToolkit(ULocalPlayer& OwningLocalPlayer, int32 LocalPlayerIndex)
{
for (USocialToolkit* ExistingToolkit : SocialToolkits)
{
check(&OwningLocalPlayer != ExistingToolkit->GetOwningLocalPlayerPtr());
}
check(ToolkitClass);
USocialToolkit* NewToolkit = NewObject<USocialToolkit>(this, ToolkitClass);
SocialToolkits.Insert(NewToolkit, LocalPlayerIndex);
NewToolkit->InitializeToolkit(OwningLocalPlayer);
OnToolkitCreatedInternal(*NewToolkit);
NewToolkit->OnToolkitReset().AddUObject(this, &USocialManager::HandleToolkitReset, NewToolkit->GetLocalUserNum());
return *NewToolkit;
}
void USocialManager::RegisterSecondaryPlayer(int32 LocalPlayerNum, const FOnJoinPartyComplete& JoinDelegate)
{
USocialToolkit* SocialToolkit = GetSocialToolkit(LocalPlayerNum);
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
USocialParty* PersistentParty = GetPersistentParty();
if (PartyInterface != nullptr && PersistentParty != nullptr)
{
FUniqueNetIdRepl PrimaryUserId = GetFirstLocalUserId(ESocialSubsystem::Primary);
FUniqueNetIdRepl SecondaryUserId = SocialToolkit->GetLocalUser().GetUserId(ESocialSubsystem::Primary);
if (PrimaryUserId.IsValid() && SecondaryUserId.IsValid())
{
// If P2 is already in the party, leave first so we can join cleanly
if (PersistentParty->GetPartyMember(SecondaryUserId))
{
PersistentParty->RemoveLocalMember(SecondaryUserId, USocialParty::FOnLeavePartyAttemptComplete::CreateWeakLambda(this, [this, LocalPlayerNum, JoinDelegate](ELeavePartyCompletionResult LeaveResult)
{
if (LeaveResult == ELeavePartyCompletionResult::Succeeded)
{
RegisterSecondaryPlayer(LocalPlayerNum, JoinDelegate);
}
else
{
UE_LOG(LogParty, Warning, TEXT("RegisterSecondaryPlayer RemoveLocalMember failed LeaveResult=%s"), ToString(LeaveResult));
USocialToolkit* LambdaSocialToolkit = GetSocialToolkit(LocalPlayerNum);
USocialParty* LambdaPersistentParty = GetPersistentParty();
FUniqueNetIdRepl LambdaSecondaryUserId = LambdaSocialToolkit->GetLocalUser().GetUserId(ESocialSubsystem::Primary);
JoinDelegate.Execute(*LambdaSecondaryUserId, LambdaPersistentParty->GetPartyId(), EJoinPartyCompletionResult::UnknownClientFailure, 0);
}
}));
}
else
{
FString JoinInfoStr = PartyInterface->MakeJoinInfoJson(*PrimaryUserId, PersistentParty->GetPartyId());
IOnlinePartyJoinInfoConstPtr JoinInfo = PartyInterface->MakeJoinInfoFromJson(JoinInfoStr);
if (JoinInfo && JoinInfo->IsValid())
{
PartyInterface->JoinParty(*SecondaryUserId, *JoinInfo, JoinDelegate);
}
}
}
}
}
void USocialManager::QueryPartyJoinabilityInternal(FJoinPartyAttempt& JoinAttempt)
{
FUniqueNetIdRepl LocalUserId = GetFirstLocalUserId(ESocialSubsystem::Primary);
if (ensure(LocalUserId.IsValid()) && ensure(JoinAttempt.JoinInfo.IsValid()))
{
JoinAttempt.ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_QueryJoinability);
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
PartyInterface->QueryPartyJoinability(*LocalUserId, *JoinAttempt.JoinInfo, FOnQueryPartyJoinabilityCompleteEx::CreateUObject(this, &USocialManager::HandleQueryJoinabilityComplete, JoinAttempt.JoinInfo->GetPartyTypeId()));
}
else
{
FinishJoinPartyAttempt(JoinAttempt, FJoinPartyResult(EJoinPartyCompletionResult::UnknownClientFailure));
}
}
void USocialManager::JoinPartyInternal(FJoinPartyAttempt& JoinAttempt)
{
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
FUniqueNetIdRepl LocalUserId = GetFirstLocalUserId(ESocialSubsystem::Primary);
if (LocalUserId.IsValid())
{
JoinAttempt.ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_JoinParty);
PartyInterface->JoinParty(*LocalUserId, *JoinAttempt.JoinInfo, FOnJoinPartyComplete::CreateUObject(this, &USocialManager::HandleJoinPartyComplete, JoinAttempt.JoinInfo->GetPartyTypeId()));
}
else
{
UE_LOG(LogParty, Error, TEXT("USocialManager::JoinPartyInternal Invalid LocalUserId=[%s] on primary subsystem."), *LocalUserId.ToDebugString());
}
}
void USocialManager::FinishJoinPartyAttempt(FJoinPartyAttempt& JoinAttemptToDestroy, const FJoinPartyResult& JoinResult)
{
OnJoinPartyAttemptCompleteInternal(JoinAttemptToDestroy, JoinResult);
JoinAttemptToDestroy.OnJoinComplete.ExecuteIfBound(JoinResult);
const bool bWasPersistentPartyJoinAttempt = JoinAttemptToDestroy.PartyTypeId == IOnlinePartySystem::GetPrimaryPartyTypeId();
// JoinAttemptToDestroy is garbage after this. Be careful!
JoinAttemptsByTypeId.Remove(JoinAttemptToDestroy.PartyTypeId);
if (bWasPersistentPartyJoinAttempt && !JoinResult.WasSuccessful() && !GetPersistentParty())
{
// Something goofed when trying to join a new persistent party, so create a replacement immediately
// TODO: See if the below warning happens, and if so, flesh out this flow
UE_CLOG(!GetFirstLocalUserToolkit()->CanAutoRecreatePersistentParty(), LogParty, Warning, TEXT("FinishJoinPartyAttempt creating a persistent party when we shouldn't!"));
CreatePersistentParty();
}
}
USocialParty* USocialManager::GetPersistentPartyInternal(bool bEvenIfLeaving /*= false*/) const
{
auto* PersistentParty = JoinedPartiesByTypeId.Find(IOnlinePartySystem::GetPrimaryPartyTypeId());
if (PersistentParty && ensure(*PersistentParty) && (bEvenIfLeaving || !(*PersistentParty)->IsLeavingParty()))
{
return *PersistentParty;
}
return nullptr;
}
const USocialManager::FJoinPartyAttempt* USocialManager::GetJoinAttemptInProgress(const FOnlinePartyTypeId& PartyTypeId) const
{
return JoinAttemptsByTypeId.Find(PartyTypeId);
}
USocialParty* USocialManager::EstablishNewParty(const FUniqueNetId& LocalUserId, const FOnlinePartyId& PartyId, const FOnlinePartyTypeId& PartyTypeId)
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_SocialManager_EstablishNewParty);
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
TSubclassOf<USocialParty> PartyClass = GetPartyClassForType(PartyTypeId);
TSharedPtr<const FOnlineParty> OssParty = PartyInterface->GetParty(LocalUserId, PartyTypeId);
if (ensure(OssParty.IsValid()) && ensure(PartyClass) && ensure(*OssParty->PartyId == PartyId))
{
USocialParty* NewParty = NewObject<USocialParty>(this, *PartyClass);
NewParty->OnPartyLeaveBegin().AddUObject(this, &USocialManager::HandlePartyLeaveBegin, NewParty);
NewParty->OnPartyLeft().AddUObject(this, &USocialManager::HandlePartyLeft, NewParty);
NewParty->OnPartyDisconnected().AddUObject(this, &USocialManager::HandlePartyDisconnected, NewParty);
// This must be done before InitializeParty(), as initialization can complete synchronously.
JoinedPartiesByTypeId.Add(PartyTypeId, NewParty);
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_SocialManager_EstablishNewParty_InitializeParty);
NewParty->InitializeParty(OssParty.ToSharedRef());
}
if (NewParty->IsPersistentParty())
{
NewParty->OnPartyStateChanged().AddUObject(this, &USocialManager::HandlePersistentPartyStateChanged, NewParty);
HandlePersistentPartyStateChanged(NewParty->GetOssPartyState(), NewParty->GetOssPartyPreviousState(), NewParty);
}
return NewParty;
}
return nullptr;
}
USocialParty* USocialManager::GetPartyInternal(const FOnlinePartyTypeId& PartyTypeId, bool bIncludeLeavingParties) const
{
auto* Party = JoinedPartiesByTypeId.Find(PartyTypeId);
if (!Party && bIncludeLeavingParties)
{
Party = LeavingPartiesByTypeId.Find(PartyTypeId);
}
return Party ? *Party : nullptr;
}
USocialParty* USocialManager::GetPartyInternal(const FOnlinePartyId& PartyId, bool bIncludeLeavingParties) const
{
for (auto& TypeIdPartyPair : JoinedPartiesByTypeId)
{
if (TypeIdPartyPair.Value->GetPartyId() == PartyId)
{
return TypeIdPartyPair.Value;
}
}
if (bIncludeLeavingParties)
{
for (auto& TypeIdPartyPair : LeavingPartiesByTypeId)
{
if (TypeIdPartyPair.Value->GetPartyId() == PartyId)
{
return TypeIdPartyPair.Value;
}
}
}
return nullptr;
}
#if PARTY_PLATFORM_SESSIONS_XBL
extern TAutoConsoleVariable<bool> CVarXboxMpaEnabled;
#endif
TSharedPtr<const IOnlinePartyJoinInfo> USocialManager::GetJoinInfoFromSession(const FOnlineSessionSearchResult& PlatformSession)
{
static const FName JoinInfoSettingName = PARTY_PLATFORM_SESSIONS_XBL ? SETTING_CUSTOM_JOIN_INFO : SETTING_CUSTOM;
FString JoinInfoString;
if (PlatformSession.Session.SessionSettings.Get(JoinInfoSettingName, JoinInfoString))
{
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
#if PARTY_PLATFORM_SESSIONS_XBL
if (CVarXboxMpaEnabled.GetValueOnAnyThread())
{
return PartyInterface->MakeJoinInfoFromToken(JoinInfoString);
}
// On Xbox MPSD we encode our party data in base64 to avoid XboxLive trying to parse our json, so now we need to decode that
FBase64::Decode(JoinInfoString, JoinInfoString);
#endif
return PartyInterface->MakeJoinInfoFromJson(JoinInfoString);
}
return nullptr;
}
void USocialManager::HandleGameViewportInitialized()
{
ABORT_DURING_SHUTDOWN();
UGameViewportClient::OnViewportCreated().RemoveAll(this);
UGameInstance& GameInstance = GetGameInstance();
UGameViewportClient* GameViewport = GameInstance.GetGameViewportClient();
check(GameViewport);
GameViewport->OnPlayerAdded().AddUObject(this, &USocialManager::HandleLocalPlayerAdded);
GameViewport->OnPlayerRemoved().AddUObject(this, &USocialManager::HandleLocalPlayerRemoved);
// Immediately spin up toolkits for local players that already exist
const TArray<ULocalPlayer*>& LocalPlayers = GameInstance.GetLocalPlayers();
for (int32 LocalPlayerIndex = 0; LocalPlayerIndex < LocalPlayers.Num(); ++LocalPlayerIndex)
{
ULocalPlayer* ExistingLocalPlayer = LocalPlayers[LocalPlayerIndex];
CreateSocialToolkit(*ExistingLocalPlayer, LocalPlayerIndex);
}
}
void USocialManager::HandlePreClientTravel(const FString& PendingURL, ETravelType TravelType, bool bIsSeamlessTravel)
{
ABORT_DURING_SHUTDOWN();
RefreshCanCreatePartyObjects();
}
void USocialManager::HandleWorldEstablished(UWorld* World)
{
ABORT_DURING_SHUTDOWN();
RefreshCanCreatePartyObjects();
if (!OnFillJoinRequestInfoHandle.IsValid())
{
IOnlinePartyPtr PartyInterface = Online::GetPartyInterface(World);
if (PartyInterface.IsValid())
{
OnFillJoinRequestInfoHandle = PartyInterface->AddOnFillPartyJoinRequestDataDelegate_Handle(FOnFillPartyJoinRequestDataDelegate::CreateUObject(this, &USocialManager::HandleFillPartyJoinRequestData));
}
}
}
void USocialManager::HandleLocalPlayerAdded(int32 LocalUserNum)
{
ABORT_DURING_SHUTDOWN();
ULocalPlayer* NewLocalPlayer = GetGameInstance().GetLocalPlayerByIndex(LocalUserNum);
check(NewLocalPlayer);
CreateSocialToolkit(*NewLocalPlayer, LocalUserNum);
}
void USocialManager::HandleLocalPlayerRemoved(int32 LocalUserNum)
{
ABORT_DURING_SHUTDOWN();
//GetSocialToolkit accepts a ControllerId, not a player index, so we'll access it directly
if (SocialToolkits.IsValidIndex(LocalUserNum))
{
if (USocialToolkit* Toolkit = SocialToolkits[LocalUserNum])
{
SocialToolkits.Remove(Toolkit);
OnSocialToolkitDestroyed().Broadcast(*Toolkit);
Toolkit->MarkAsGarbage();
}
}
}
void USocialManager::HandleToolkitReset(int32 LocalUserNum)
{
ABORT_DURING_SHUTDOWN();
JoinAttemptsByTypeId.Reset();
}
void USocialManager::RestorePartyStateFromPartySystem(const FOnRestorePartyStateFromPartySystemComplete& OnRestoreComplete)
{
UE_LOG(LogParty, Verbose, TEXT("RestorePartyStateFromPartySystem"));
FUniqueNetIdRepl LocalUserId = GetFirstLocalUserId(ESocialSubsystem::Primary);
// If the player has any parties, do not try to restore
if (LocalUserId.IsValid() &&
bCanCreatePartyObjects &&
JoinedPartiesByTypeId.Num() == 0 &&
JoinAttemptsByTypeId.Num() == 0)
{
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
PartyInterface->RestoreParties(*LocalUserId, FOnRestorePartiesComplete::CreateUObject(this, &USocialManager::OnRestorePartiesComplete, OnRestoreComplete));
}
else
{
OnRestoreComplete.ExecuteIfBound(false);
}
}
void USocialManager::OnRestorePartiesComplete(const FUniqueNetId& LocalUserId, const FOnlineError& Result, const FOnRestorePartyStateFromPartySystemComplete OnRestoreComplete)
{
ABORT_DURING_SHUTDOWN();
if (Result.WasSuccessful())
{
// Restore our parties
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
TArray<TSharedRef<const FOnlinePartyId>> JoinedParties;
PartyInterface->GetJoinedParties(LocalUserId, JoinedParties);
for (const TSharedRef<const FOnlinePartyId>& PartyId : JoinedParties)
{
TSharedPtr<const FOnlineParty> Party = PartyInterface->GetParty(LocalUserId, *PartyId);
check(Party.IsValid());
if (!EstablishNewParty(LocalUserId, *PartyId, Party->PartyTypeId))
{
UE_LOG(LogParty, Warning, TEXT("OnRestorePartiesComplete: User=[%s] Party=[%s] Type=%d failed to establish party"), *LocalUserId.ToDebugString(), *PartyId->ToDebugString(), Party->PartyTypeId.GetValue());
}
}
}
OnRestoreComplete.ExecuteIfBound(Result.WasSuccessful());
}
void USocialManager::HandleQueryJoinabilityComplete(const FUniqueNetId& LocalUserId, const FOnlinePartyId& PartyId, const FQueryPartyJoinabilityResult& Result, FOnlinePartyTypeId PartyTypeId)
{
ABORT_DURING_SHUTDOWN();
if (FJoinPartyAttempt* JoinAttempt = JoinAttemptsByTypeId.Find(PartyTypeId))
{
if (Result.EnumResult == EJoinPartyCompletionResult::Succeeded)
{
if (USocialParty* ExistingParty = GetPartyInternal(PartyTypeId, true))
{
// We're currently in another party of the same type, so we have to leave that one first
JoinAttempt->ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_LeaveCurrentParty);
if (!ExistingParty->IsCurrentlyLeaving())
{
ExistingParty->LeaveParty(USocialParty::FOnLeavePartyAttemptComplete::CreateUObject(this, &USocialManager::HandleLeavePartyForJoinComplete, ExistingParty));
}
}
else
{
if (bCreatingPersistentParty && PartyTypeId == IOnlinePartySystem::GetPrimaryPartyTypeId())
{
UE_LOG(LogParty, Log, TEXT("HandleQueryJoinabilityComplete: User=[%s] Party=[%s] Delaying join until persistent party creation has completed."), *LocalUserId.ToDebugString(), *PartyId.ToDebugString());
// When the internal persistent party creation completes, the new party will be left to process the join request.
JoinAttempt->ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_WaitForPersistentPartyCreation);
}
else
{
JoinPartyInternal(*JoinAttempt);
}
}
}
else
{
FinishJoinPartyAttempt(*JoinAttempt, FJoinPartyResult(Result.EnumResult, Result.SubCode));
}
}
}
void USocialManager::HandleCreatePartyComplete(const FUniqueNetId& LocalUserId, const TSharedPtr<const FOnlinePartyId>& PartyId, ECreatePartyCompletionResult Result, FOnlinePartyTypeId PartyTypeId, FOnCreatePartyAttemptComplete CompletionDelegate)
{
ABORT_DURING_SHUTDOWN();
QUICK_SCOPE_CYCLE_COUNTER(STAT_SocialManager_HandleCreatePartyComplete);
ECreatePartyCompletionResult LocalCreationResult = Result;
if (Result == ECreatePartyCompletionResult::Succeeded)
{
if (USocialParty* NewParty = EstablishNewParty(LocalUserId, *PartyId, PartyTypeId))
{
NewParty->ResetPrivacySettings();
if (UPartyMember* LocalPartyMember = NewParty->GetPartyMember(LocalUserId.AsShared()))
{
UE_LOG(LogParty, Verbose, TEXT("Player [%s] created party."), *LocalUserId.ToDebugString());
LocalPartyMember->GetMutableRepData().SetJoinMethod(PartyJoinMethod::Creation.ToString());
}
}
else
{
LocalCreationResult = ECreatePartyCompletionResult::UnknownClientFailure;
}
}
UE_LOG(LogParty, Verbose, TEXT("Finished trying to create party [%s] with result [%s]"), PartyId.IsValid() ? *PartyId->ToDebugString() : TEXT("Invalid"), ToString(LocalCreationResult));
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_SocialManager_HandleCreatePartyComplete_Delegate);
CompletionDelegate.ExecuteIfBound(LocalCreationResult);
}
}
void USocialManager::HandleJoinPartyComplete(const FUniqueNetId& LocalUserId, const FOnlinePartyId& PartyId, EJoinPartyCompletionResult Result, int32 NotApprovedReasonCode, FOnlinePartyTypeId PartyTypeId)
{
ABORT_DURING_SHUTDOWN();
UE_LOG(LogParty, Log, TEXT("Attempt to join party of type [%d] completed with result [%s] and reason code [%d] by user is [%s] "), PartyTypeId.GetValue(), ToString(Result), NotApprovedReasonCode, *LocalUserId.ToDebugString());
FJoinPartyResult JoinResult(Result, NotApprovedReasonCode);
FJoinPartyAttempt* JoinAttempt = JoinAttemptsByTypeId.Find(PartyTypeId);
if (ensure(JoinAttempt))
{
JoinAttempt->ActionTimeTracker.CompleteStep(FJoinPartyAttempt::Step_JoinParty);
if (JoinResult.WasSuccessful())
{
if (bCanCreatePartyObjects)
{
USocialParty* NewParty = EstablishNewParty(LocalUserId, PartyId, PartyTypeId);
if (!NewParty)
{
JoinResult.SetResult(EJoinPartyCompletionResult::UnknownClientFailure);
}
FinishJoinPartyAttempt(*JoinAttempt, JoinResult);
}
else
{
// Not currently in an ok state to be creating new party objects (between maps or something) - update the join attempt and revisit when we're cleared to create party objects again
JoinAttempt->ActionTimeTracker.BeginStep(FJoinPartyAttempt::Step_DeferredPartyCreation);
}
}
else
{
FinishJoinPartyAttempt(*JoinAttempt, JoinResult);
}
}
else
{
//@note DanH: Should be quite impossible, but happening in the wild without repro steps (FORT-123031) - putting in lots of mines here to make sure we see it if it happens in-house
UE_LOG(LogParty, Error, TEXT("Attempt to join party of type [%d] completed with result [%s], but there is no existing FJoinPartyAttempt object."), PartyTypeId.GetValue(), ToString(Result));
if (!ensure(!JoinResult.WasSuccessful()))
{
UE_LOG(LogParty, Error, TEXT("Auto-bailing on party of type [%d] - cannot finish establishing it without a valid FJoinPartyAttempt."), PartyTypeId.GetValue(), ToString(Result));
IOnlinePartyPtr PartyInterface = Online::GetPartyInterfaceChecked(GetWorld());
PartyInterface->LeaveParty(LocalUserId, PartyId, true, FOnLeavePartyComplete::CreateUObject(this, &USocialManager::HandleLeavePartyForMissingJoinAttempt, PartyTypeId));
}
else
{
// Failed to join this party in the first place - skip to the leave complete handler and to do any necessary fixup (since we were still missing the join attempt, and that's far less than ideal)
HandleLeavePartyForMissingJoinAttempt(LocalUserId, PartyId, ELeavePartyCompletionResult::Succeeded, PartyTypeId);
}
}
}
void USocialManager::HandlePersistentPartyStateChanged(EPartyState NewState, EPartyState PreviousState, USocialParty* PersistentParty)
{
ABORT_DURING_SHUTDOWN();
UE_LOG(LogParty, Verbose, TEXT("Persistent party state changed to %s"), ToString(NewState));
if (NewState == EPartyState::Disconnected)
{
bIsConnectedToPartyService = false;
if (PreviousState == EPartyState::Active)
{
if (USocialSettings::ShouldLeavePartyOnDisconnect())
{
PersistentParty->LeaveParty();
}
}
}
else if (NewState == EPartyState::Active)
{
bIsConnectedToPartyService = true;
}
}
void USocialManager::HandleLeavePartyForJoinComplete(ELeavePartyCompletionResult LeaveResult, USocialParty* LeftParty)
{
ABORT_DURING_SHUTDOWN();
if (LeftParty)
{
UE_LOG(LogParty, Verbose, TEXT("Attempt to leave party [%s] for pending join completed with result [%s]"), *LeftParty->ToDebugString(), ToString(LeaveResult));
}
}
bool USocialManager::IsConnectedToPartyService() const
{
return bIsConnectedToPartyService
#if !UE_BUILD_SHIPPING
&& !CVarForceDisconnectedToPartyService.GetValueOnAnyThread()
#endif
;
}
void USocialManager::HandlePartyDisconnected(USocialParty* DisconnectingParty)
{
ABORT_DURING_SHUTDOWN();
if (DisconnectingParty)
{
const FOnlinePartyTypeId& PartyTypeId = DisconnectingParty->GetPartyTypeId();
JoinedPartiesByTypeId.Remove(PartyTypeId);
DisconnectingParty->MarkAsGarbage();
}
}
void USocialManager::HandlePartyLeaveBegin(EMemberExitedReason Reason, USocialParty* LeavingParty)
{
ABORT_DURING_SHUTDOWN();
if (LeavingParty)
{
const FOnlinePartyTypeId& PartyTypeId = LeavingParty->GetPartyTypeId();
JoinedPartiesByTypeId.Remove(PartyTypeId);
LeavingPartiesByTypeId.Add(PartyTypeId, LeavingParty);
}
}
void USocialManager::HandlePartyLeft(EMemberExitedReason Reason, USocialParty* LeftParty)
{
ABORT_DURING_SHUTDOWN();
if (LeftParty)
{
const FOnlinePartyTypeId& PartyTypeId = LeftParty->GetPartyTypeId();
LeavingPartiesByTypeId.Remove(PartyTypeId);
if (!ensure(!JoinedPartiesByTypeId.Contains(PartyTypeId)))
{
// Really shouldn't be any scenario wherein we receive a PartyLeft event without a prior PartyLeaveBegin
JoinedPartiesByTypeId.Remove(PartyTypeId);
}
OnPartyLeftInternal(*LeftParty, Reason);
LeftParty->MarkAsGarbage();
if (FJoinPartyAttempt* JoinAttempt = JoinAttemptsByTypeId.Find(PartyTypeId))
{
JoinAttempt->ActionTimeTracker.CompleteStep(FJoinPartyAttempt::Step_LeaveCurrentParty);
// We're in the process of joining another party of the same type - do we know where we're heading yet?
if (JoinAttempt->JoinInfo.IsValid())
{
// Join the new party immediately and early out
JoinPartyInternal(*JoinAttempt);
return;
}
else
{
// An attempt to join a party of this type has been initiated, but something/someone decided to leave the party before the attempt was ready to do so
// It's not worth accounting for the potential limbo that this could put us into, so just abort the join attempt and let the explicit leave action win
UE_LOG(LogParty, Verbose, TEXT("Finished leaving party [%s] before the current join attempt established join info. Cancelling join attempt."), *LeftParty->ToDebugString());
FinishJoinPartyAttempt(*JoinAttempt, FJoinPartyResult(EPartyJoinDenialReason::JoinAttemptAborted));
}
}
if (LeftParty->IsPersistentParty() && GetFirstLocalUserToolkit()->CanAutoRecreatePersistentParty())
{
UE_LOG(LogParty, Verbose, TEXT("Finished leaving persistent party without a join/rejoin target. Creating a new persistent party now."));
// This wasn't part of a join process, so immediately create a new persistent party
CreatePersistentParty();
}
}
}
void USocialManager::HandleLeavePartyForMissingJoinAttempt(const FUniqueNetId& LocalUserId, const FOnlinePartyId& PartyId, ELeavePartyCompletionResult LeaveResult, FOnlinePartyTypeId PartyTypeId)
{
ABORT_DURING_SHUTDOWN();
if (PartyTypeId == IOnlinePartySystem::GetPrimaryPartyTypeId() && GetFirstLocalUserToolkit()->CanAutoRecreatePersistentParty() && !GetPersistentPartyInternal(true))
{
// We just had to bail on the persistent party due to unforeseen shenanigans, so try to correct things and set another one back up
CreatePersistentParty();
}
}
void USocialManager::HandleFillPartyJoinRequestData(const FUniqueNetId& LocalUserId, const FOnlinePartyId& PartyId, FOnlinePartyData& PartyData)
{
ABORT_DURING_SHUTDOWN();
FillOutJoinRequestData(PartyId, PartyData);
}
void USocialManager::HandleFindSessionForJoinComplete(bool bWasSuccessful, const FOnlineSessionSearchResult& FoundSession, FOnlinePartyTypeId PartyTypeId)
{
ABORT_DURING_SHUTDOWN();
if (FJoinPartyAttempt* JoinAttempt = JoinAttemptsByTypeId.Find(PartyTypeId))
{
JoinAttempt->ActionTimeTracker.CompleteStep(FJoinPartyAttempt::Step_FindPlatformSession);
if (bWasSuccessful)
{
JoinAttempt->JoinInfo = GetJoinInfoFromSession(FoundSession);
if (JoinAttempt->JoinInfo.IsValid())
{
QueryPartyJoinabilityInternal(*JoinAttempt);
}
else
{
FinishJoinPartyAttempt(*JoinAttempt, FJoinPartyResult(EPartyJoinDenialReason::PlatformSessionMissingJoinInfo));
}
}
else
{
FinishJoinPartyAttempt(*JoinAttempt, FJoinPartyResult(EPartyJoinDenialReason::TargetUserMissingPlatformSession));
}
}
}
#if UE_ALLOW_EXEC_COMMANDS
bool USocialManager::Exec(class UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out)
{
if (FParse::Command(&Cmd, TEXT("SOCIAL")))
{
if (SocialDebugTools &&
SocialDebugTools->Exec(InWorld, Cmd, Out))
{
return true;
}
for (USocialToolkit* Toolkit : SocialToolkits)
{
if (Toolkit &&
Toolkit->Exec(InWorld, Cmd, Out))
{
return true;
}
}
return true;
}
return false;
}
#endif // UE_ALLOW_EXEC_COMMANDS
USocialDebugTools* USocialManager::GetDebugTools() const
{
return SocialDebugTools;
}
Reference in New Issue View Git Blame Copy Permalink