Use the Online Subsystem to set up presence - Presence essentials - (Unreal Engine module)

Last updated on March 26, 2025

Unwrap the subsystem

This tutorial will show you how to set and get player presence status using the AGS Online Subsystem (OSS). In the Byte Wars project, there is already a game instance subsystem created named PresenceEssentialsSubsystem. This subsystem contains the completed implementation for setting and getting player presence statuses. However, in this tutorial, you will use a starter version of that subsystem so you can implement the functions from scratch.

What's in the starter pack

To follow this tutorial, a starter subsystem class named PresenceEssentialsSubsystem_Starter has been prepared for you. This class is available in the Resources section and consists of the following files:

Header file: /Source/AccelByteWars/TutorialModules/Social/PresenceEssentials/PresenceEssentialsSubsystem_Starter.h
CPP file: /Source/AccelByteWars/TutorialModules/Social/PresenceEssentials/PresenceEssentialsSubsystem_Starter.cpp

The PresenceEssentialsSubsystem_Starter class also has several helpers:

A set of AGS OSS interfaces declaration:
- GetPresenceInterface(): a function which returns the AGS Presence interface. You will use this interface to get and set player presences.
- GetFriendsInterface(): a function that returns the AGS Friends interface. You will use this interface to refresh the player presence when the friend or blocked player list is updated.
- GetIdentityInterface(): a function that returns the AGS Identity interface. You will use this interface to initialize the player presence status once the player is logged in.
- GetSessionInterface(): a function that returns the AGS Session interface. You will use this interface to refresh the player presence when the game session member list is updated.
- GetOnlineSession(): a function that returns the Byte Wars online session wrapper. You will use this to set the player's game activity in the presence status, such as the party and matchmaking status.
```
protected:
// ...
    FOnlinePresenceAccelBytePtr GetPresenceInterface() const;
    TSharedPtr<FOnlineFriendsAccelByte, ESPMode::ThreadSafe> GetFriendsInterface() const;
    TSharedPtr<FOnlineIdentityAccelByte, ESPMode::ThreadSafe> GetIdentityInterface() const;
    TSharedPtr<FOnlineSessionV2AccelByte, ESPMode::ThreadSafe> GetSessionInterface() const;
    UAccelByteWarsOnlineSessionBase* GetOnlineSession() const;
```

A helper function to get the logged-in player. You will use this to set the player's presence status later.

FUniqueNetIdPtr UPresenceEssentialsSubsystem_Starter::GetPrimaryPlayerUserId()
{
    if (!GetGameInstance())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to get current logged in player's User Id. GameInstance is invalid."));
        return nullptr;
    }

    const APlayerController* PC = GetGameInstance()->GetFirstLocalPlayerController();
    if (!PC)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to get current logged in player's User Id. PlayerController is invalid."));
        return nullptr;
    }

    const ULocalPlayer* LocalPlayer = PC->GetLocalPlayer();
    if (!LocalPlayer)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to get current logged in player's User Id. LocalPlayer is invalid."));
        return nullptr;
    }

    return LocalPlayer->GetPreferredUniqueNetId().GetUniqueNetId();
}

There is also a model file located in /Source/AccelByteWars/TutorialModules/Social/PresenceEssentials/PresenceEssentialsModels.h. This file contains the following helpers:

String constants for printing logs and messages.

#define TEXT_PRESENCE_ONLINE NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_online", "Online")
#define TEXT_PRESENCE_OFFLINE NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_offline", "Offline")

#define TEXT_PRESENCE_LAST_ONLINE_YEARS NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_years_ago", "Last Online Years Ago")
#define TEXT_PRESENCE_LAST_ONLINE_MONTHS NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_months_ago", "Last Online {0} Month(s) Ago")
#define TEXT_PRESENCE_LAST_ONLINE_DAYS NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_days_ago", "Last Online {0} Day(s) Ago")
#define TEXT_PRESENCE_LAST_ONLINE_HOURS NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_hours_ago", "Last Online {0} Hour(s) Ago")
#define TEXT_PRESENCE_LAST_ONLINE_MINUTES NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_minutes_ago", "Last Online {0} Minute(s) Ago")
#define TEXT_PRESENCE_LAST_ONLINE_AWHILE NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_last_online_while_ago", "Last Online a While Ago")

#define TEXT_PRESENCE_LEVEL_MAINMENU NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_level_main_menu", "In Main Menu")
#define TEXT_PRESENCE_LEVEL_GAMEPLAY NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_level_gameplay", "In Match")
#define TEXT_PRESENCE_ACTIVITY_PARTY NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_activity_party", "In Party")
#define TEXT_PRESENCE_ACTIVITY_MATCHMAKING NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_activity_matchmaking", "Matchmaking")
#define TEXT_PRESENCE_ACTIVITY_LOBBY NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_activity_lobby", "Lobby")
#define TEXT_PRESENCE_ACTIVITY_GAMEPLAY NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_activity_gameplay", "Game Mode: {0}")
#define TEXT_PRESENCE_ACTIVITY_UNKNOWN NSLOCTEXT(ACCELBYTEWARS_LOCTEXT_NAMESPACE, "presence_activity_unknown", "Unknown Activity")

A function to convert the last online datetime to readable text.

inline static FString GetLastOnline(const FDateTime LastOnline) 
{
    // Only check last online within a year.
    const FDateTime CurrentTime = FDateTime::UtcNow();
    if (CurrentTime.GetYear() != LastOnline.GetYear())
    {
        return TEXT_PRESENCE_LAST_ONLINE_YEARS.ToString();
    }

    // Check last online in months.
    if (CurrentTime.GetMonth() > LastOnline.GetMonth())
    {
        const int32 Months = CurrentTime.GetMonth() - LastOnline.GetMonth();
        return FText::Format(TEXT_PRESENCE_LAST_ONLINE_MONTHS, Months).ToString();
    }

    // Check last online in days.
    if (CurrentTime.GetDay() > LastOnline.GetDay())
    {
        const int32 Days = CurrentTime.GetDay() - LastOnline.GetDay();
        return FText::Format(TEXT_PRESENCE_LAST_ONLINE_DAYS, Days).ToString();
    }

    // Check last online in hours.
    if (CurrentTime.GetHour() > LastOnline.GetHour())
    {
        const int32 Hours = CurrentTime.GetHour() - LastOnline.GetHour();
        return FText::Format(TEXT_PRESENCE_LAST_ONLINE_HOURS, Hours).ToString();
    }

    // Check last online in minutes.
    if (CurrentTime.GetMinute() > LastOnline.GetMinute())
    {
        const int32 Minutes = CurrentTime.GetMinute() - LastOnline.GetMinute();
        return FText::Format(TEXT_PRESENCE_LAST_ONLINE_MINUTES, Minutes).ToString();
    }

    return TEXT_PRESENCE_LAST_ONLINE_AWHILE.ToString();
}

Implement get presence

In this section, you will implement functions to retrieve player presence.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare the following functions:

public:
// ...
    void GetPresence(const FUniqueNetIdPtr UserId, bool bForceQuery, const FOnPresenceTaskComplete& OnComplete = FOnPresenceTaskComplete());

protected:
    void OnGetPresenceComplete(const class FUniqueNetId& UserId, const bool bWasSuccessful, const FOnPresenceTaskComplete OnComplete);

Now, define the functions mentioned above. Open the PresenceEssentialsSubsystem_Starter class CPP file and define the GetPresence() function first. The code below retrieves the player's presence data from the cache. If it is not available in the cache, it will query the backend.

void UPresenceEssentialsSubsystem_Starter::GetPresence(const FUniqueNetIdPtr UserId, bool bForceQuery, const FOnPresenceTaskComplete& OnComplete)
{
    FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface();
    if (!PresenceInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot get presence. Presence interface is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    const FUniqueNetIdAccelByteUserPtr UserABId = StaticCastSharedPtr<const FUniqueNetIdAccelByteUser>(UserId);
    if (!UserABId)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot get presence. User Id is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    if(!bForceQuery)
    {
        // Try get the presence from cache.
        TSharedPtr<FOnlineUserPresence> OutPresence = nullptr;
        PresenceInterface->GetCachedPresence(UserABId.ToSharedRef().Get(), OutPresence);
        if (TSharedPtr<FOnlineUserPresenceAccelByte> ABPresence = StaticCastSharedPtr<FOnlineUserPresenceAccelByte>(OutPresence))
        {
            UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Success to get presence for user: %s"), *UserABId->GetAccelByteId());
            OnComplete.ExecuteIfBound(true, ABPresence);
            return;
        }
    }

    // If the presence is not available on cache, then query it.
    PresenceInterface->QueryPresence(
        UserABId.ToSharedRef().Get(),
        IOnlinePresence::FOnPresenceTaskCompleteDelegate::CreateUObject(this, &ThisClass::OnGetPresenceComplete, OnComplete));
}

Finally, define the OnGetPresenceComplete() function. This function invokes the delegate passed to it to inform whether the get presence process was successful or not.

void UPresenceEssentialsSubsystem_Starter::OnGetPresenceComplete(const FUniqueNetId& UserId, const bool bWasSuccessful, const FOnPresenceTaskComplete OnComplete)
{
    const FUniqueNetIdAccelByteUserRef UserABId = StaticCastSharedRef<const FUniqueNetIdAccelByteUser>(UserId.AsShared());
    if (!UserABId->IsValid())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to get presence. User Id is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface();
    if (!PresenceInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to get presence for user: %s. Presence interface is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    if (!bWasSuccessful)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to get presence for user: %s. Operation failed."), *UserABId->GetAccelByteId());
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    TSharedPtr<FOnlineUserPresence> OutPresence;
    PresenceInterface->GetCachedPresence(UserABId.Get(), OutPresence);

    TSharedPtr<FOnlineUserPresenceAccelByte> ABPresence = StaticCastSharedPtr<FOnlineUserPresenceAccelByte>(OutPresence);
    if (!ABPresence)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to get presence for user: %s. Invalid presence type."), *UserABId->GetAccelByteId());
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Success to get presence for user: %s"), *UserABId->GetAccelByteId());

    OnComplete.ExecuteIfBound(true, ABPresence);
}

Implement bulk get presence

In this section, you will implement functions to query and retrieve the presence of multiple players.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare the following functions:

public:
// ...
    void BulkQueryPresence(const FUniqueNetIdPtr UserId, const TArray<FUniqueNetIdRef>& UserIds);

Next, declare a delegate and a callback function to handle when the bulk query for presence is complete. You will use the delegate to update the UIs in the next section of the tutorial.

public:
// ...
    FOnBulkQueryPresenceComplete* GetOnBulkQueryPresenceCompleteDelegates()
    {
        return &OnBulkQueryPresenceCompleteDelegates;
    }

protected:
// ...
    void OnBulkQueryPresenceComplete(const bool bWasSuccessful, const FUserIDPresenceMap& Presences);

private:
// ...
    FOnBulkQueryPresenceComplete OnBulkQueryPresenceCompleteDelegates;

Now, define the functions mentioned above. Open the PresenceEssentialsSubsystem_Starter class CPP file and define the BulkQueryPresence() function first. The code below will retrieve the list of player presences from the cache. If the information is not found in the cache, it will then query the backend for the presences.

void UPresenceEssentialsSubsystem_Starter::BulkQueryPresence(const FUniqueNetIdPtr UserId, const TArray<FUniqueNetIdRef>& UserIds)
{
    FUserIDPresenceMap CachedPresences;

    FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface();
    if (!PresenceInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot bulk query presence. Presence interface is invalid."));
        OnBulkQueryPresenceComplete(false, CachedPresences);
        return;
    }

    if (!UserId || UserIds.IsEmpty())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot bulk query presence. User Ids are invalid."));
        OnBulkQueryPresenceComplete(false, CachedPresences);
        return;
    }

    // Try to collect cached presences.
    for (const FUniqueNetIdRef& TargetUserId : UserIds)
    {
        const FUniqueNetIdAccelByteUserRef TargetUserABId = StaticCastSharedRef<const FUniqueNetIdAccelByteUser>(TargetUserId);
        if (!TargetUserABId->IsValid())
        {
            return;
        }

        TSharedPtr<FOnlineUserPresence> OutPresence;
        PresenceInterface->GetCachedPresence(TargetUserABId.Get(), OutPresence);
        
        if (const TSharedPtr<FOnlineUserPresenceAccelByte> ABPresence = StaticCastSharedPtr<FOnlineUserPresenceAccelByte>(OutPresence))
        {
            CachedPresences.Add(TargetUserABId->GetAccelByteId(), ABPresence.ToSharedRef());
        }
        else
        {
            break;
        }
    }

    // The cached presences are complete, return the cached presence.
    if (CachedPresences.Num() == UserIds.Num())
    {
        OnBulkQueryPresenceComplete(true, CachedPresences);
        return;
    }

    // There are some missing cached presences, try to query.
    PresenceInterface->BulkQueryPresence(UserId.ToSharedRef().Get(), UserIds);
}

In the same file, define the callback function. This function will broadcast the delegate you created earlier to inform whether the bulk query presence process was successful or not.

void UPresenceEssentialsSubsystem_Starter::OnBulkQueryPresenceComplete(const bool bWasSuccessful, const FUserIDPresenceMap& Presences)
{
    UE_LOG_PRESENCEESSENTIALS(Log, TEXT("%s to bulk query presences. Presences found: %d"), bWasSuccessful ? TEXT("Success") : TEXT("Failed"), Presences.Num());

    OnBulkQueryPresenceCompleteDelegates.Broadcast(bWasSuccessful, Presences);
}

Next, bind the callback function so that it will be called when the bulk query presence is complete. You can do this by adding the following code to the Initialize() function, which is the first function called when the subsystem is initialized.

void UPresenceEssentialsSubsystem_Starter::Initialize(FSubsystemCollectionBase& Collection)
{
// ...
    // Listen to presence events.
    if (FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface())
    {
// ...
        PresenceInterface->AddOnBulkQueryPresenceCompleteDelegate_Handle(FOnBulkQueryPresenceCompleteDelegate::CreateUObject(this, &ThisClass::OnBulkQueryPresenceComplete));
    }
}

Finally, you need to unbind the callback function when the subsystem is deinitialized. You can accomplish this by adding the following code.

void UPresenceEssentialsSubsystem_Starter::Deinitialize()
{
// ...
    if (FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface())
    {
// ...
        PresenceInterface->ClearOnBulkQueryPresenceCompleteDelegates(this);
    }
}

Implement set presence status

In this section, you will implement functions to set the presence of individual players to indicate their online status and game activity.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare the following functions.

public:
// ...
    void SetPresenceStatus(const FUniqueNetIdPtr UserId, const FString& Status, const FOnPresenceTaskComplete& OnComplete = FOnPresenceTaskComplete());

protected:
// ...
    void OnSetPresenceStatusComplete(const class FUniqueNetId& UserId, const bool bWasSuccessful, const FOnPresenceTaskComplete OnComplete);

Now, define the functions mentioned above. Open the PresenceEssentialsSubsystem_Starter class CPP file and first define the SetPresenceStatus() function to set the player's online presence status and the status string.

void UPresenceEssentialsSubsystem_Starter::SetPresenceStatus(const FUniqueNetIdPtr UserId, const FString& Status, const FOnPresenceTaskComplete& OnComplete)
{
    FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface();
    if (!PresenceInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot set presence status. Presence interface is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    if (!UserId)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Cannot set presence status. User Id is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    FOnlineUserPresenceStatus PresenceStatus;
    PresenceStatus.StatusStr = Status;
    PresenceStatus.State = EOnlinePresenceState::Type::Online;

    PresenceInterface->SetPresence(
        UserId.ToSharedRef().Get(),
        PresenceStatus,
        IOnlinePresence::FOnPresenceTaskCompleteDelegate::CreateUObject(this, &ThisClass::OnSetPresenceStatusComplete, OnComplete));
}

Next, define the OnSetPresenceStatusComplete() function. This function invokes the delegate passed to it to inform whether the presence-setting process is successful or not.

void UPresenceEssentialsSubsystem_Starter::OnSetPresenceStatusComplete(const FUniqueNetId& UserId, const bool bWasSuccessful, const FOnPresenceTaskComplete OnComplete)
{
    const FUniqueNetIdAccelByteUserRef UserABId = StaticCastSharedRef<const FUniqueNetIdAccelByteUser>(UserId.AsShared());
    if (!UserABId->IsValid())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to set presence status. User Id is invalid."));
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface();
    if (!PresenceInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to set presence status for user: %s. Presence interface is invalid."), *UserABId->GetAccelByteId());
        OnComplete.ExecuteIfBound(false, nullptr);
        return;
    }

    TSharedPtr<FOnlineUserPresence> OutPresence;
    PresenceInterface->GetCachedPresence(UserABId.Get(), OutPresence);

    const TSharedPtr<FOnlineUserPresenceAccelByte> ABPresence = StaticCastSharedPtr<FOnlineUserPresenceAccelByte>(OutPresence);
    if (bWasSuccessful && ABPresence)
    {
        UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Success to set presence status for user: %s"), *UserABId->GetAccelByteId());
        OnComplete.ExecuteIfBound(true, ABPresence);
    }
    else
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Failed to set presence status for user: %s. Operation failed."), *UserABId->GetAccelByteId());
        OnComplete.ExecuteIfBound(false, nullptr);
    }
}

Handle on presence update received

In this section, you will implement functions to handle received player presence updates. You will manage this event to broadcast information that will be used by the UIs to display the updated presence later.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare a delegate and a callback function to handle when the presence update is received. You will use the delegate to update the UIs later in the next section of the tutorial.

public:
// ...
    FOnPresenceReceived* GetOnPresenceReceivedDelegates()
    {
        return &OnPresenceReceivedDelegates;
    }

protected:
// ...
    void OnPresenceReceived(const class FUniqueNetId& UserId, const TSharedRef<FOnlineUserPresence>& Presence);

private:
// ...
    FOnPresenceReceived OnPresenceReceivedDelegates;

Now, open the PresenceEssentialsSubsystem_Starter class CPP file and define the OnPresenceReceived() function. When this function is called, it will broadcast the delegate you created earlier to inform that a new presence update has been received.

void UPresenceEssentialsSubsystem_Starter::OnPresenceReceived(const FUniqueNetId& UserId, const TSharedRef<FOnlineUserPresence>& Presence)
{
    const FUniqueNetIdAccelByteUserRef UserABId = StaticCastSharedRef<const FUniqueNetIdAccelByteUser>(UserId.AsShared());
    if (!UserABId->IsValid()) 
    {
        UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Received presence update for but is null"));
        return;
    }

    UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Received presence update for user: %s"), *UserABId->GetAccelByteId());

    OnPresenceReceivedDelegates.Broadcast(UserABId.Get(), Presence);
}

Then, you need to bind the callback function so it will be called when the player presence update is received. You can do this by adding the following code to the Initialize() function, which is the first function called when the subsystem is initialized.

void UPresenceEssentialsSubsystem_Starter::Initialize(FSubsystemCollectionBase& Collection)
{
// ...
    // Listen to presence events.
    if (FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface())
    {
        PresenceInterface->AddOnPresenceReceivedDelegate_Handle(FOnPresenceReceivedDelegate::CreateUObject(this, &ThisClass::OnPresenceReceived));
// ...
    }
}

Finally, you need to unbind the callback function when the subsystem is deinitialized. You can do this by adding the following code.

void UPresenceEssentialsSubsystem_Starter::Deinitialize()
{
// ...
    if (FOnlinePresenceAccelBytePtr PresenceInterface = GetPresenceInterface())
    {
        PresenceInterface->ClearOnPresenceReceivedDelegates(this);
// ...
    }
}

Handle presences on player list updated

When the player's friend list, blocked player list, and game session member list are updated, you also need to update their presences. In this section, you will learn how to do that.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare the following functions:

private:
// ...
    void OnFriendListChange();
    void OnBlockedPlayerListChange(int32 LocalUserNum, const FString& ListName);
    void OnSessionParticipantChange(FName SessionName, const FUniqueNetId& UserId, bool bJoined);

Then, open the PresenceEssentialsSubsystem_Starter class CPP file and define the OnFriendListChange() function first. This function collects the user IDs of friends and performs a bulk query of their presences using the function you created in the previous section.

void UPresenceEssentialsSubsystem_Starter::OnFriendListChange()
{
    FOnlineFriendsAccelBytePtr FriendsInterface = GetFriendsInterface();
    if (!FriendsInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query friends' presences. Friends interface is invalid."));
        return;
    }

    const FUniqueNetIdPtr UserId = GetPrimaryPlayerUserId();
    if (!UserId)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query friends' presences. Current logged-in player's User Id is invalid."));
        return;
    }

    // Get cached friend list.
    TArray<TSharedRef<FOnlineFriend>> OutFriendList;
    if (!FriendsInterface->GetFriendsList(0, TEXT(""), OutFriendList))
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query friends' presences. Cannot get cached friend list."));
        return;
    }
    if (OutFriendList.IsEmpty())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query friends' presences. No friends found."));
        return;
    }

    // Collect their user IDs.
    TArray<FUniqueNetIdRef> FriendIds;
    for (const TSharedRef<FOnlineFriend>& Friend : OutFriendList)
    {
        FriendIds.Add(Friend->GetUserId());
    }

    // Query friends' presences.
    UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Querying friends' presences."));
    BulkQueryPresence(UserId, FriendIds);
}

Next, define the OnBlockedPlayerListChange() function. Similarly, this function collects the user IDs of blocked players and performs a bulk query of their presences.

void UPresenceEssentialsSubsystem_Starter::OnBlockedPlayerListChange(int32 LocalUserNum, const FString& ListName)
{
    FOnlineFriendsAccelBytePtr FriendsInterface = GetFriendsInterface();
    if (!FriendsInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query blocked players' presences. Friends interface is invalid."));
        return;
    }

    const FUniqueNetIdPtr UserId = GetPrimaryPlayerUserId();
    if (!UserId)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query blocked player' presences. Current logged-in player's User Id is invalid."));
        return;
    }

    // Get cached blocked player list.
    TArray<TSharedRef<FOnlineBlockedPlayer>> OutBlockedPlayerList;
    if (!FriendsInterface->GetBlockedPlayers(UserId.ToSharedRef().Get(), OutBlockedPlayerList))
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query blocked players' presences. Cannot get cached blocked player list."));
        return;
    }
    if (OutBlockedPlayerList.IsEmpty())
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to query blocked players' presences. No blocked player found."));
        return;
    }

    // Collect their user IDs.
    TArray<FUniqueNetIdRef> BlockedPlayerIds;
    for (const TSharedRef<FOnlineBlockedPlayer>& BlockedPlayer : OutBlockedPlayerList)
    {
        BlockedPlayerIds.Add(BlockedPlayer->GetUserId());
    }

    // Query blocked players' presences.
    UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Querying blocked players' presences."));
    BulkQueryPresence(UserId, BlockedPlayerIds);
}

Define the OnSessionParticipantChange() function. This function will be called when a player leaves or joins the active game session. When this happens, this function updates the player's presence

void UPresenceEssentialsSubsystem_Starter::OnSessionParticipantChange(FName SessionName, const FUniqueNetId& UserId, bool bJoined)
{
    if(!bJoined)
    {
        UE_LOG_PRESENCEESSENTIALS(Log, TEXT("Update presence when session participant change"));
        GetPresence(UserId.AsShared(),true);
    }
}

Then, you need to bind the functions above so they will be called when the player lists are updated. You can do this by adding the following code to the Initialize() function, which is the first function called when the subsystem is initialized.

void UPresenceEssentialsSubsystem_Starter::Initialize(FSubsystemCollectionBase& Collection)
{
// ...
    // Update presence when friend list, blocked player list, and session member list changed.
    if (FOnlineFriendsAccelBytePtr FriendsInterface = GetFriendsInterface())
    {
        FriendsInterface->AddOnFriendsChangeDelegate_Handle(0, FOnFriendsChangeDelegate::CreateUObject(this, &ThisClass::OnFriendListChange));
        FriendsInterface->AddOnBlockListChangeDelegate_Handle(0, FOnBlockListChangeDelegate::CreateUObject(this, &ThisClass::OnBlockedPlayerListChange));
    }
    if (FOnlineSessionV2AccelBytePtr SessionInterface = GetSessionInterface())
    {
        SessionInterface->AddOnSessionParticipantsChangeDelegate_Handle(FOnSessionParticipantsChangeDelegate::CreateUObject(this, &ThisClass::OnSessionParticipantChange));
    }
// ...
}

Finally, you need to unbind the callback function when the subsystem is deinitialized. You can do this by adding the following code:

void UPresenceEssentialsSubsystem_Starter::Deinitialize()
{
// ...
    if (FOnlineFriendsAccelBytePtr FriendsInterface = GetFriendsInterface())
    {
        FriendsInterface->ClearOnFriendsChangeDelegates(0, this);
        FriendsInterface->ClearOnBlockListChangeDelegates(0, this);
    }
    if (FOnlineSessionV2AccelBytePtr SessionInterface = GetSessionInterface())
    {
        SessionInterface->ClearOnSessionParticipantsChangeDelegates(this);
    }
// ...
}

Handle player's game activity to set player presence status

In this section, you will learn how to set the player presence status based on player's game activity. First, let's understand what player activity means in Byte Wars. Game activity is defined by the level the player is currently in and the activity the player is currently doing. Here is a list of activities you will use to set the player presence status.

Activity	Description
In Main Menu	Player is in the Main Menu.
In Match	Player is in a game session.
In Party	Player is in a party.
Matchmaking	Player is currently matchmaking.
Lobby	Player is in the Match Lobby menu.
Game Mode: <Game Mode Name>	Player is in the gameplay with certain game mode.

Now, implement some functions to set the player presence status with those activities.

Open the PresenceEssentialsSubsystem_Starter class Header file and declare the helper variables and functions to store and update the logged-in player presence status.

protected:
// ...
    void UpdatePrimaryPlayerPresenceStatus();

protected:
// ...
    FString LevelStatus;
    FString ActivityStatus;

private:
    void OnLevelLoaded();

Then, open the PresenceEssentialsSubsystem_Starter class CPP file and define the UpdatePrimaryPlayerPresenceStatus() function. This function updates the logged-in player presence status based on the data stored in the helper variables you declared earlier.

void UPresenceEssentialsSubsystem_Starter::UpdatePrimaryPlayerPresenceStatus()
{
    FOnlineIdentityAccelBytePtr IdentityInterface = GetIdentityInterface();
    if (!IdentityInterface)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to update current logged-in player's presence. Identity interface is invalid."));
        return;
    }

    const FUniqueNetIdPtr UserId = GetPrimaryPlayerUserId();
    if (!UserId)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to update current logged-in player's presence. User Id is invalid."));
        return;
    }

    // Abort if not logged-in.
    if (IdentityInterface->GetLoginStatus(UserId.ToSharedRef().Get()) != ELoginStatus::Type::LoggedIn) 
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to update current logged-in player's presence. Primary player is not logged-in."));
        return;
    }

    /* Only consider player is in a party if the party member is more than one.
     * This is because by the game design, the game always creates a party for the player.*/
    FString PartyStatus;
    if (UAccelByteWarsOnlineSessionBase* OnlineSession = GetOnlineSession())
    {
        PartyStatus = (OnlineSession->GetPartyMembers().Num() > 1) ? TEXT_PRESENCE_ACTIVITY_PARTY.ToString() : FString();
    }

    // Collect and construct presence status in "level - activity, party status" format.
    FString PresenceStatus = LevelStatus;
    if (!ActivityStatus.IsEmpty()) 
    {
        PresenceStatus += FString(" - ") + ActivityStatus;
    }
    if (!PartyStatus.IsEmpty())
    {
        PresenceStatus += (ActivityStatus.IsEmpty() ? FString(" - ") : FString(", ")) + PartyStatus;
    }

    // Set presence status.
    SetPresenceStatus(UserId, PresenceStatus);
}

Next, define the OnLevelLoaded() function. This function checks which level the player is currently in and updates the player's presence status accordingly.

void UPresenceEssentialsSubsystem_Starter::OnLevelLoaded()
{
    const UWorld* World = GetWorld();
    if (!World)
    {
        UE_LOG_PRESENCEESSENTIALS(Warning, TEXT("Unable to update level status presence. World is not valid."));
        return;
    }

    AAccelByteWarsGameState* GameState = Cast<AAccelByteWarsGameState>(World->GetGameState());

    /* In online multiplayer, the game state takes some time to replicate after world creation.
     * Once the game state is replicated and initialized, attempt to update the level status. */
    AAccelByteWarsGameState::OnInitialized.RemoveAll(this);
    if (!GameState) 
    {
        AAccelByteWarsGameState::OnInitialized.AddUObject(this, &ThisClass::OnLevelLoaded);
        return;
    }

    /* In online multiplayer, the game state may be initialized, but the properties may not be replicated yet.
     * Therefore, listen for the game state's game setup replication to attempt updating the level status. */
    GameState->OnGameSetupChanged.RemoveAll(this);
    GameState->OnGameSetupChanged.AddUObject(this, &ThisClass::OnLevelLoaded);

    if (const AAccelByteWarsMainMenuGameState* MainMenuGameState = Cast<AAccelByteWarsMainMenuGameState>(GameState))
    {
        // Set level status to "In Main Menu".
        if (MainMenuGameState->GetNetMode() == ENetMode::NM_Standalone) 
        {
            LevelStatus = TEXT_PRESENCE_LEVEL_MAINMENU.ToString();
            ActivityStatus = FString("");
        }
        /* Already travelled to online session.
         * Set level status to "In Match" and activity status to "In Lobby".*/
        else 
        {
            LevelStatus = TEXT_PRESENCE_LEVEL_GAMEPLAY.ToString();
            ActivityStatus = TEXT_PRESENCE_ACTIVITY_LOBBY.ToString();
        }
    }
    else if (const AAccelByteWarsInGameGameState* InGameGameState = Cast<AAccelByteWarsInGameGameState>(GameState))
    {
        // Set level status to "In Match" and activity status to the current game mode type.
        LevelStatus = TEXT_PRESENCE_LEVEL_GAMEPLAY.ToString();
        ActivityStatus = FText::Format(TEXT_PRESENCE_ACTIVITY_GAMEPLAY, InGameGameState->GameSetup.DisplayName).ToString();
    }
    else
    {
        // Fallback, set status to unknown.
        LevelStatus = TEXT_PRESENCE_ACTIVITY_UNKNOWN.ToString();
        ActivityStatus = FString("");
    }

    UpdatePrimaryPlayerPresenceStatus();
}

Then, add the following code block to the Initialize() function. This code changes the player's presence status by modifying the helper variables based on various events, including matchmaking, level changes, and party status changes. To update the presence status, these events will call the UpdatePrimaryPlayerPresenceStatus() function you defined earlier.

void UPresenceEssentialsSubsystem_Starter::Initialize(FSubsystemCollectionBase& Collection)
{
// ...
    // On world loaded, update level status.
    FWorldDelegates::OnPostWorldInitialization.AddWeakLambda(this, [this](UWorld* World, const UWorld::InitializationValues IVS)
    {
        if (!World) 
        {
            return;
        }

        World->OnWorldBeginPlay.RemoveAll(this);
        World->OnWorldBeginPlay.AddUObject(this, &ThisClass::OnLevelLoaded);
    });

    if (UAccelByteWarsOnlineSessionBase* OnlineSession = GetOnlineSession())
    {
        // On matchmaking started, set matchmaking status.
        if (FOnMatchmakingResponse* OnStartMatchmakingComplete = OnlineSession->GetOnStartMatchmakingCompleteDelegates())
        {
            OnStartMatchmakingComplete->AddWeakLambda(this, [this](FName SessionName, bool bSucceeded)
            {
                ActivityStatus = bSucceeded ? TEXT_PRESENCE_ACTIVITY_MATCHMAKING.ToString() : FString();
                UpdatePrimaryPlayerPresenceStatus();
            });
        }

        // On matchmaking complete, remove matchmaking status.
        if (FOnMatchmakingResponse* OnMatchmakingComplete = OnlineSession->GetOnMatchmakingCompleteDelegates())
        {
            OnMatchmakingComplete->AddWeakLambda(this, [this](FName SessionName, bool bSucceeded)
            {
                ActivityStatus = FString();
                UpdatePrimaryPlayerPresenceStatus();
            });
        }

        // On matchmaking canceled, remove matchmaking status.
        if (FOnMatchmakingResponse* OnCancelMatchmakingComplete = OnlineSession->GetOnCancelMatchmakingCompleteDelegates())
        {
            OnCancelMatchmakingComplete->AddWeakLambda(this, [this](FName SessionName, bool bSucceeded)
            {
                ActivityStatus = FString();
                UpdatePrimaryPlayerPresenceStatus();
            });
        }

        // On party session updated, update party presence status.
        if (FOnJoinSessionComplete* OnJoinPartyComplete = OnlineSession->GetOnJoinPartyCompleteDelegates())
        {
            OnJoinPartyComplete->AddWeakLambda(this, [this](FName SessionName, EOnJoinSessionCompleteResult::Type Result)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }
        if (FOnDestroySessionComplete* OnLeavePartyComplete = OnlineSession->GetOnLeavePartyCompleteDelegates())
        {
            OnLeavePartyComplete->AddWeakLambda(this, [this](FName SessionName, bool bSucceeded)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }

// ...
        if (FOnSessionParticipantJoined* OnPartyMemberJoined = OnlineSession->GetOnPartyMemberJoinedDelegates())
        {
            OnPartyMemberJoined->AddWeakLambda(this, [this](FName SessionName, const FUniqueNetId& Member)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }
        if (FOnSessionParticipantLeft* OnPartyMemberLeft = OnlineSession->GetOnPartyMemberLeftDelegates())
        {
            OnPartyMemberLeft->AddWeakLambda(this, [this](FName SessionName, const FUniqueNetId& Member, EOnSessionParticipantLeftReason Reason)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }
// ...

        if (FOnSessionUpdateReceived* OnPartySessionUpdateReceived = OnlineSession->GetOnPartySessionUpdateReceivedDelegates())
        {
            OnPartySessionUpdateReceived->AddWeakLambda(this, [this](FName SessionName)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }
        if (FOnDestroySessionComplete* OnLeaveSessionComplete = OnlineSession->GetOnLeaveSessionCompleteDelegates())
        {
            OnLeaveSessionComplete->AddWeakLambda(this, [this](FName SessionName, bool bSucceeded)
            {
                UpdatePrimaryPlayerPresenceStatus();
            });
        }
    }

    // Update presence status once the player logged in and connected to lobby.
    if (FOnlineIdentityAccelBytePtr IdentityInterface = GetIdentityInterface()) 
    {
        IdentityInterface->AddOnConnectLobbyCompleteDelegate_Handle(0,
            FOnConnectLobbyCompleteDelegate::CreateWeakLambda(this, [this](int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& Error)
            {
                UpdatePrimaryPlayerPresenceStatus();
            }
        ));
    }
// ...
}

Finally, you need to unbind the events mentioned above when the subsystem is deinitialized. You can do this by adding the following code.

void UPresenceEssentialsSubsystem_Starter::Deinitialize()
{
// ...
    // Clean-up cache.
    LevelStatus = FString();
    ActivityStatus = FString();

    // Unbind events.
    AAccelByteWarsGameState::OnInitialized.RemoveAll(this);

    FWorldDelegates::OnPostWorldInitialization.RemoveAll(this);
    if (GetWorld())
    {
        GetWorld()->OnWorldBeginPlay.RemoveAll(this);
    }

    if (UAccelByteWarsOnlineSessionBase* OnlineSession = GetOnlineSession())
    {
        if (FOnMatchmakingResponse* OnStartMatchmakingComplete = OnlineSession->GetOnStartMatchmakingCompleteDelegates())
        {
            OnStartMatchmakingComplete->RemoveAll(this);
        }

        if (FOnMatchmakingResponse* OnMatchmakingComplete = OnlineSession->GetOnMatchmakingCompleteDelegates())
        {
            OnMatchmakingComplete->RemoveAll(this);
        }

        if (FOnMatchmakingResponse* OnCancelMatchmakingComplete = OnlineSession->GetOnCancelMatchmakingCompleteDelegates())
        {
            OnCancelMatchmakingComplete->RemoveAll(this);
        }

        if (FOnJoinSessionComplete* OnJoinPartyComplete = OnlineSession->GetOnJoinPartyCompleteDelegates())
        {
            OnJoinPartyComplete->RemoveAll(this);
        }

        if (FOnDestroySessionComplete* OnLeavePartyComplete = OnlineSession->GetOnLeavePartyCompleteDelegates())
        {
            OnLeavePartyComplete->RemoveAll(this);
        }

// ...
        if (FOnSessionParticipantJoined* OnPartyMemberJoined = OnlineSession->GetOnPartyMemberJoinedDelegates())
        {
            OnPartyMemberJoined->RemoveAll(this);
        }
        if (FOnSessionParticipantLeft* OnPartyMemberLeft = OnlineSession->GetOnPartyMemberLeftDelegates())
        {
            OnPartyMemberLeft->RemoveAll(this);
        }
// ...

        if (FOnSessionUpdateReceived* OnPartySessionUpdateReceived = OnlineSession->GetOnPartySessionUpdateReceivedDelegates())
        {
            OnPartySessionUpdateReceived->RemoveAll(this);
        }

        if (FOnDestroySessionComplete* OnLeaveSessionComplete = OnlineSession->GetOnLeaveSessionCompleteDelegates())
        {
            OnLeaveSessionComplete->RemoveAll(this);
        }
    }

    if (FOnlineIdentityAccelBytePtr IdentityInterface = GetIdentityInterface())
    {
        IdentityInterface->ClearOnConnectLobbyCompleteDelegates(0, this);
    }
// ...
}

Resources

The files used in this tutorial section are available in the Byte Wars GitHub repository.

Unwrap the subsystem​

What's in the starter pack​

Implement get presence​

Implement bulk get presence​

Implement set presence status​

Handle on presence update received​

Handle presences on player list updated​

Handle player's game activity to set player presence status​

Resources​

On this page

Unwrap the subsystem

What's in the starter pack

Implement get presence

Implement bulk get presence

Implement set presence status

Handle on presence update received

Handle presences on player list updated

Handle player's game activity to set player presence status

Resources