StreamChatClientComponent.h

// Copyright 2026 Stream.IO, Inc. All Rights Reserved.
 
#pragma once
 
#include "Channel/ChannelProperties.h"
#include "Channel/ChannelSortOption.h"
#include "Channel/ChatChannel.h"
#include "Channel/Filter.h"
#include "ChannelFlags.h"
#include "ChatSocketEvents.h"
#include "Components/ActorComponent.h"
#include "CoreMinimal.h"
#include "Engine/LatentActionManager.h"
#include "Event/Notification/NotificationMutesUpdatedEvent.h"
#include "IChatSocket.h"
#include "Moderation/BanPaginationOptions.h"
#include "PaginationOptions.h"
#include "Templates/IsInvocable.h"
#include "User/OwnUser.h"
#include "User/User.h"
 
#include "StreamChatClientComponent.generated.h"
 
struct FBan;
class FChatApi;
class FTokenManager;
class ITokenProvider;
class UChatChannel;
struct FUserRef;
struct FChannelStateResponseFieldsDto;
struct FConnectionRecoveredEvent;
struct FMessage;
struct FDevice;
struct FUserPresenceChangedEvent;
 
UCLASS(ClassGroup = (Stream), meta = (BlueprintSpawnableComponent))
class STREAMCHAT_API UStreamChatClientComponent final : public UActorComponent
{
    GENERATED_BODY()
 
public:
    UStreamChatClientComponent();
 
    void ConnectUser(const FUser& User, TUniquePtr<ITokenProvider> TokenProvider, TFunction<void(const FOwnUser&)> Callback = {});
 
    void ConnectUser(const FUser& User, const FString& Token, TFunction<void(const FOwnUser&)> Callback = {});
 
    void ConnectAnonymousUser(TFunction<void(const FOwnUser&)> Callback = {});
 
    void ConnectGuestUser(const FUser& User, TFunction<void(const FOwnUser&)> Callback = {});
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void DisconnectUser();
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void UpsertUsers(const TArray<FUser>& Users);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    UChatChannel* NewChat();
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void CancelNewChat();
 
    void QueryChannels(
        TOptional<FFilter> Filter = {},
        const TArray<FChannelSortOption>& SortOptions = {},
        const EChannelFlags Flags = EChannelFlags::State | EChannelFlags::Watch,
        const FPaginationOptions& PaginationOptions = {},
        TFunction<void(const TArray<UChatChannel*>&)> Callback = {});
 
    void CreateChannel(const FChannelProperties& ChannelProperties, TFunction<void(UChatChannel*)> Callback);
 
    void WatchChannel(const FChannelProperties& ChannelProperties, TFunction<void(UChatChannel*)> Callback);
 
    void QueryChannel(const FChannelProperties& ChannelProperties, const EChannelFlags Flags, TFunction<void(UChatChannel*)> Callback = {});
 
    void QueryAdditionalChannels(int32 Limit = 10, TFunction<void()> Callback = {});
 
    void QueryUsers(
        const FFilter& Filter = {},
        const TArray<FUserSortOption>& Sort = {},
        bool bPresence = true,
        const TOptional<FPaginationOptions> PaginationOptions = {},
        TFunction<void(const TArray<FUserRef>&)> Callback = {}) const;
 
    void SearchMessages(
        const FFilter& ChannelFilter = {},
        const TOptional<FString>& Query = {},
        const TOptional<FFilter>& MessageFilter = {},
        const TArray<FMessageSortOption>& Sort = {},
        TOptional<uint32> MessageLimit = {},
        TFunction<void(const TArray<FMessage>&)> Callback = {}) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client")
    void MarkAllRead() const;
 
    UFUNCTION(BlueprintPure, Category = "Stream Chat|Client")
    const TArray<UChatChannel*>& GetChannels() const;
 
    UFUNCTION(BlueprintPure, Category = "Stream Chat|Client")
    static FString DevToken(const FString& UserId);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void AddDevice(const FString& DeviceId, EPushProvider PushProvider) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void RemoveDevice(const FString& DeviceId) const;
 
    void ListDevices(TFunction<void(TArray<FDevice>)> Callback) const;
 
    UPROPERTY(EditAnywhere, Config, Category = "Stream Chat", meta = (DisplayName = "API Key"))
    FString ApiKey;
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FChannelsUpdatedDelegate, const TArray<UChatChannel*>&, Channels);
 
    UPROPERTY(BlueprintAssignable, Category = "Stream Chat|Channel")
    FChannelsUpdatedDelegate ChannelsUpdated;
 
private:
    // Called when the game starts
    virtual void BeginPlay() override;
 
    void ConnectUserInternal(const FUser& User, TFunction<void(const FOwnUser&)> Callback);
    UChatChannel* CreateChannelObject(const FChannelStateResponseFieldsDto&);
 
    void OnConnectionRecovered(const FConnectionRecoveredEvent&);
    void OnUserPresenceChanged(const FUserPresenceChangedEvent&);
    void OnNewMessage(const FMessageNewEvent&);
    void OnMutesUpdated(const FNotificationMutesUpdatedEvent&);
 
    void AddChannels(const TArray<UChatChannel*>& InChannels);
 
    TSharedPtr<FTokenManager> TokenManager;
    TSharedPtr<FChatApi> Api;
 
    UPROPERTY(Transient)
    TArray<UChatChannel*> Channels;
 
#pragma region Blueprint
public:
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void ConnectUser(const FUser& User, const FString& Token, const UObject* WorldContextObject, FLatentActionInfo LatentInfo, FOwnUser& OutUser);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void ConnectAnonymousUser(const UObject* WorldContextObject, FLatentActionInfo LatentInfo, FOwnUser& OutUser);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void ConnectGuestUser(const FUser& User, const UObject* WorldContextObject, FLatentActionInfo LatentInfo, FOwnUser& OutUser);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void QueryChannels(
        FFilter Filter,
        const TArray<FChannelSortOption>& SortOptions,
        const UObject* WorldContextObject,
        FLatentActionInfo LatentInfo,
        TArray<UChatChannel*>& OutChannels,
        UPARAM(meta = (Bitmask, BitmaskEnum = EChannelFlags)) const int32 Flags = 3);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo, AdvancedDisplay = Id))
    void WatchChannel(const FChannelProperties& ChannelProperties, const UObject* WorldContextObject, FLatentActionInfo LatentInfo, UChatChannel*& OutChannel);
 
#pragma endregion Blueprint
 
#pragma region Events
public:
    template <class TEvent>
    using TEventMulticastDelegate = TMulticastDelegate<void(const TEvent& Event)>;
    template <class TEvent>
    using TEventDelegate = typename TEventMulticastDelegate<TEvent>::FDelegate;
    template <class TEvent, class UserClass>
    using TEventDelegateUObjectMethodPtr = typename TEventDelegate<TEvent>::template TMethodPtr<UserClass>;
    template <class TEvent, class UserClass>
    using TEventDelegateSpMethodPtr = typename TEventDelegate<TEvent>::template TMethodPtr<UserClass>;
 
    template <class TEvent>
    FDelegateHandle On(TEventDelegate<TEvent> Callback);
 
    template <class TEvent, class UserClass>
    typename TEnableIf<TIsDerivedFrom<UserClass, UObject>::IsDerived, FDelegateHandle>::Type On(
        UserClass* Obj,
        TEventDelegateUObjectMethodPtr<TEvent, UserClass> Method);
 
    template <class TEvent, class UserClass>
    typename TEnableIf<!TIsDerivedFrom<UserClass, UObject>::IsDerived, FDelegateHandle>::Type On(
        UserClass* Obj,
        TEventDelegateSpMethodPtr<TEvent, UserClass> Method);
 
    template <class TEvent, typename FunctorType, typename... VarTypes>
    typename TEnableIf<TIsInvocable<FunctorType, const TEvent&, VarTypes...>::Value, FDelegateHandle>::Type On(FunctorType&& Functor, VarTypes... Vars);
 
    template <class TEvent>
    bool Unsubscribe(FDelegateHandle) const;
 
private:
    TSharedPtr<IChatSocket> Socket;
 
#pragma endregion Events
 
#pragma region Moderation
public:
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client|Moderation", DisplayName = "Ban User")
    void BanUserBP(const FUserRef& User, FTimespan Timeout, const FString& Reason, bool bIpBan) const;
    void BanUser(const FUserRef& User, const TOptional<FTimespan>& Timeout = {}, const TOptional<FString>& Reason = {}, bool bIpBan = false) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client|Moderation")
    void UnbanUser(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client|Moderation", DisplayName = "Shadow Ban User")
    void ShadowBanUserBP(const FUserRef& User, FTimespan Timeout) const;
    void ShadowBanUser(const FUserRef& User, const TOptional<FTimespan>& Timeout = {}) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client|Moderation")
    void ShadowUnbanUser(const FUserRef& User) const;
 
    void QueryBannedUsers(
        const FFilter& Filter,
        const TArray<FBanSortOption>& SortOptions = {},
        const TOptional<FBanPaginationOptions> PaginationOptions = {},
        const TFunction<void(const TArray<FBan>&)> Callback = {});
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client")
    void FlagMessage(const FMessage& Message) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client")
    void FlagUser(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Client", DisplayName = "Mute User")
    void MuteUserBP(const FUserRef& User, FTimespan Timeout) const;
    void MuteUser(const FUserRef& User, const TOptional<FTimespan>& Timeout = {}) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client")
    void UnmuteUser(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client|Moderation")
    void BlockUser(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Client|Moderation")
    void UnblockUser(const FUserRef& User) const;
 
    void GetBlockedUsers(TFunction<void(const TArray<FString>&)> Callback) const;
 
#pragma endregion Moderation
};
 
#pragma region Events
 
template <class TEvent>
FDelegateHandle UStreamChatClientComponent::On(TEventDelegate<TEvent> Callback)
{
    return Socket->Events().SubscribeLambda<TEvent>(
        [this, Callback](const TEvent& Event)
        {
            // TODO can we enforce client-only events?
            Callback.ExecuteIfBound(Event);
        });
}
 
template <class TEvent, class UserClass>
typename TEnableIf<TIsDerivedFrom<UserClass, UObject>::IsDerived, FDelegateHandle>::Type UStreamChatClientComponent::On(
    UserClass* Obj,
    TEventDelegateUObjectMethodPtr<TEvent, UserClass> Method)
{
    const TEventDelegate<TEvent> Delegate = TEventDelegate<TEvent>::CreateUObject(Obj, Method);
    return On<TEvent>(Delegate);
}
 
template <class TEvent, class UserClass>
typename TEnableIf<!TIsDerivedFrom<UserClass, UObject>::IsDerived, FDelegateHandle>::Type UStreamChatClientComponent::On(
    UserClass* Obj,
    TEventDelegateSpMethodPtr<TEvent, UserClass> Method)
{
    const TEventDelegate<TEvent> Delegate = TEventDelegate<TEvent>::CreateSP(Obj, Method);
    return On<TEvent>(Delegate);
}
 
template <class TEvent, typename FunctorType, typename... VarTypes>
typename TEnableIf<TIsInvocable<FunctorType, const TEvent&, VarTypes...>::Value, FDelegateHandle>::Type UStreamChatClientComponent::On(
    FunctorType&& Functor,
    VarTypes... Vars)
{
    const TEventDelegate<TEvent> Delegate = TEventDelegate<TEvent>::CreateLambda(Forward<FunctorType>(Functor), Vars...);
    return On<TEvent>(Delegate);
}
 
template <class TEvent>
bool UStreamChatClientComponent::Unsubscribe(const FDelegateHandle Handle) const
{
    return Socket->Events().Unsubscribe<TEvent>(Handle);
}
#pragma endregion Events