ChatChannel.h

// Copyright 2026 Stream.IO, Inc. All Rights Reserved.
 
#pragma once
 
#include "ChannelProperties.h"
#include "ChannelSortOption.h"
#include "ChannelState.h"
#include "ChatApi.h"
#include "ChatSocketEvents.h"
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "Engine/LatentActionManager.h"
#include "Filter.h"
#include "IChatSocket.h"
#include "Message.h"
#include "MessagePaginationOptions.h"
#include "PaginationOptions.h"
#include "Templates/IsInvocable.h"
#include "User/UserPaginationOptions.h"
#include "User/UserRef.h"
 
#include "ChatChannel.generated.h"
 
class UStreamChatClientComponent;
struct FChannelEvent;
struct FChannelStateResponseDto;
struct FChannelStateResponseFieldsDto;
struct FMessageDeletedEvent;
struct FMessageEvent;
struct FMessageNewEvent;
struct FMessageReadEvent;
struct FMessageUpdatedEvent;
struct FNotificationMarkReadEvent;
struct FNotificationMessageNewEvent;
struct FReactionDeletedEvent;
struct FReactionNewEvent;
struct FReactionUpdatedEvent;
struct FTypingStartEvent;
struct FTypingStopEvent;
struct FUserBannedEvent;
struct FUserUnbannedEvent;
 
UENUM(BlueprintType)
enum class ETypingIndicatorState : uint8
{
    StartTyping,
    StopTyping
};
 
UENUM(BlueprintType, meta = (BitFlags))
enum class EPaginationDirection : uint8
{
    None UMETA(Hidden),
 
    Top = 1 << 0,
    Bottom = 1 << 1,
};
ENUM_CLASS_FLAGS(EPaginationDirection);
 
UENUM(BlueprintType)
enum class EHttpRequestState : uint8
{
    Started,
    Ended
};
 
UCLASS(BlueprintType)
class STREAMCHAT_API UChatChannel final : public UObject
{
    GENERATED_BODY()
 
public:
    static UChatChannel* Create(UObject* Outer, const TSharedRef<FChatApi>, const TSharedRef<IChatSocket>, const FChannelStateResponseFieldsDto&);
    static UChatChannel* Create(UObject* Outer, const TSharedRef<FChatApi>, const TSharedRef<IChatSocket>);
 
    bool IsValid() const;
 
    void Delete(TFunction<void()> Callback = {}) const;
 
    void PartialUpdate(const TSharedRef<FJsonObject>& Set = {}, const TArray<FString>& Unset = {}, TFunction<void()> Callback = {});
 
    void Update(const FAdditionalFields& Data, const TOptional<FMessage>& Message = {}, TFunction<void()> Callback = {});
 
    void Truncate(
        bool bHardDelete = false,
        const TOptional<FDateTime>& TruncatedAt = {},
        const TOptional<FMessage>& Message = {},
        bool bSkipPush = false,
        TFunction<void()> Callback = {});
 
    void QueryMembers(
        const FFilter& Filter = {},
        const TArray<FUserSortOption>& Sort = {},
        const FMessagePaginationOptions& Pagination = {},
        TFunction<void(const TArray<FMember>&)> Callback = {});
 
    void AddMembers(const TArray<FString>& MemberIds, const TOptional<FMessage>& Message = {}, TFunction<void()> Callback = {});
 
    void RemoveMembers(const TArray<FString>& MemberIds, const TOptional<FMessage>& Message = {}, TFunction<void()> Callback = {});
 
    void Hide(bool bClearHistory = false, TFunction<void()> Callback = {}) const;
 
    void Show(TFunction<void()> Callback = {}) const;
 
    void StopWatching(TFunction<void()> Callback = {}) const;
 
    UPROPERTY(BlueprintReadOnly, Category = "Stream Chat|Channel")
    FChannelProperties Properties;
 
    UPROPERTY(BlueprintReadOnly, Category = "Stream Chat|Channel")
    FChannelState State;
 
private:
    void MergeState(const FChannelStateResponseFieldsDto&);
 
    TSharedPtr<FChatApi> Api;
    TSharedPtr<IChatSocket> Socket;
 
#pragma region Event
public:
    template <class TEvent>
    void SendEvent(const TEvent&);
 
    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;
 
#pragma endregion Event
 
#pragma region Message
public:
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Message", DisplayName = "Send Message", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void SendMessageBP(const FMessage& Message, const UObject* WorldContextObject, FLatentActionInfo LatentInfo, bool& bSuccess);
    void SendMessage(const FMessage& Message, const TFunction<void(const bool& bSuccess)> = {});
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Message", DisplayName = "Get Message", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo))
    void GetMessageBP(const FString& MessageId, const UObject* WorldContextObject, FLatentActionInfo LatentInfo, FMessage& OutMessage);
    void GetMessage(const FString& MessageId, const TFunction<void(const FMessage&)> Callback = {});
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Message")
    void UpdateMessage(const FMessage& Message);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Message")
    void DeleteMessage(const FMessage& Message);
 
    void QueryAdditionalMessages(EPaginationDirection Direction = EPaginationDirection::Top, int32 Limit = 20, TFunction<void()> Callback = {});
 
    void MarkRead(const TOptional<FMessage>& Message = {});
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Message", meta = (AutoCreateRefTerm = Message))
    void MarkRead(const FMessage& Message);
 
    void MarkReadLocal();
 
    void Query(
        EChannelFlags Flags = EChannelFlags::State,
        const TOptional<FMessagePaginationOptions> MessagePagination = {},
        const TOptional<FUserPaginationOptions> MemberPagination = {},
        const TOptional<FUserPaginationOptions> WatcherPagination = {},
        TFunction<void()> Callback = {});
 
    void SearchMessages(
        const TOptional<FString>& Query = {},
        const TOptional<FFilter>& MessageFilter = {},
        const TArray<FMessageSortOption>& Sort = {},
        TOptional<uint32> MessageLimit = {},
        TFunction<void(const TArray<FMessage>&)> Callback = {}) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel", meta = (Latent, WorldContext = WorldContextObject, LatentInfo = LatentInfo, AutoCreateRefTerm = "Sort,MessageFilter"))
    void SearchMessages(
        const FString& Query,
        const FFilter& MessageFilter,
        const TArray<FMessageSortOption>& Sort,
        int32 MessageLimit,
        const UObject* WorldContextObject,
        FLatentActionInfo LatentInfo,
        TArray<FMessage>& OutMessages);
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE(FMessagesUpdatedDelegate);
    UPROPERTY(BlueprintAssignable, Category = "Stream Chat|Channel")
    FMessagesUpdatedDelegate MessagesUpdated;
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FMessageDelegate, const FMessage&, Messages);
    UPROPERTY(BlueprintAssignable, Category = "Stream Chat|Channel")
    FMessageDelegate MessageSent;
 
    UPROPERTY(BlueprintAssignable, Category = "Stream Chat|Channel")
    FMessageDelegate MessageReceived;
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FUnreadChangedDelegate, int32, UnreadCount);
    UPROPERTY(BlueprintAssignable, Category = "Stream Chat|Channel")
    FUnreadChangedDelegate UnreadChanged;
 
private:
    void AddMessage(const FMessage&);
    void MarkRead(const TOptional<FString>& MessageId);
 
    void OnMessageUpdated(const FMessageUpdatedEvent&);
    void OnMessageDeleted(const FMessageDeletedEvent&);
 
    void OnMessageNew(const FMessageNewEvent&);
    void OnNotificationMessageNew(const FNotificationMessageNewEvent&);
    void HandleNewMessageEvent(const FMessageEvent&);
 
    void OnMessageRead(const FMessageReadEvent&);
    void OnNotificationMessageRead(const FNotificationMarkReadEvent&);
    void UpdateUnread(const FUserRef& User, int32 UnreadCount, const FDateTime& LastRead);
 
#pragma endregion Message
 
#pragma region Reaction
public:
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Reaction")
    FReaction SendReaction(const FMessage& Message, const FName& ReactionType, int32 Score = 1, bool bEnforceUnique = false);
 
    void GetReactions(const FMessage& Message, const FPaginationOptions& Pagination = {}, TFunction<void(const TArray<FReaction>&)> Callback = {});
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Reaction")
    void DeleteReaction(const FMessage& Message, const FReaction& Reaction);
 
private:
    void OnReactionNew(const FReactionNewEvent&);
    void OnReactionUpdated(const FReactionUpdatedEvent&);
    void OnReactionDeleted(const FReactionDeletedEvent&);
 
#pragma endregion Reaction
 
#pragma region Typing
public:
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Typing", meta = (AdvancedDisplay = ParentMessageId))
    void KeyStroke(const FString& ParentMessageId = TEXT(""));
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Typing", meta = (AdvancedDisplay = ParentMessageId))
    void StopTyping(const FString& ParentMessageId = TEXT(""));
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FTypingIndicatorDelegate, ETypingIndicatorState, TypingState, const FUserRef&, User);
    UPROPERTY(BlueprintAssignable)
    FTypingIndicatorDelegate OnTypingIndicator;
 
private:
    void SendStopTypingEvent(const FString& ParentMessageId = TEXT(""));
    void OnTypingStart(const FTypingStartEvent&);
    void OnTypingStop(const FTypingStopEvent&);
 
    float TypingTimeout = 2.f;
    TOptional<FDateTime> LastKeystrokeAt;
    FTimerHandle TypingTimerHandle;
 
#pragma endregion Typing
 
#pragma region Moderation
public:
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Channel|Moderation", DisplayName = "Ban Member")
    void BanMemberBP(const FUserRef& User, FTimespan Timeout, FString Reason, bool bIpBan) const;
    void BanMember(const FUserRef& User, const TOptional<FTimespan>& Timeout = {}, const TOptional<FString>& Reason = {}, bool bIpBan = false) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Moderation")
    void UnbanMember(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Channel|Moderation", DisplayName = "Shadow Ban Member")
    void ShadowBanMemberBP(const FUserRef& User, FTimespan Timeout) const;
    void ShadowBanMember(const FUserRef& User, const TOptional<FTimespan>& Timeout = {}) const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Stream Chat|Channel|Moderation")
    void ShadowUnbanMember(const FUserRef& User) const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Moderation", DisplayName = "Mute")
    void MuteBP(FTimespan Timeout);
    void Mute(const TOptional<FTimespan>& Timeout = {});
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Moderation")
    void Unmute() const;
 
    UFUNCTION(BlueprintPure, Category = "Stream Chat|Channel|Moderation")
    bool IsMuted() const;
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Moderation")
    void EnableSlowMode(FTimespan Cooldown);
 
    UFUNCTION(BlueprintCallable, Category = "Stream Chat|Channel|Moderation")
    void DisableSlowMode();
 
private:
    void OnUserBanned(const FUserBannedEvent&);
    void OnUserUnbanned(const FUserUnbannedEvent&);
 
#pragma endregion Moderation
};
 
template <class TEvent>
void UChatChannel::SendEvent(const TEvent& Event)
{
    Api->SendChannelEvent(Properties.Type, Properties.Id, Event);
}
 
template <class TEvent>
FDelegateHandle UChatChannel::On(TEventDelegate<TEvent> Callback)
{
    return Socket->Events().SubscribeLambda<TEvent>(
        [this, Callback](const TEvent& Event)
        {
            // TODO static assert with nice error message
            // https://stackoverflow.com/questions/1005476/how-to-detect-whether-there-is-a-specific-member-variable-in-class
            if (Event.Cid == Properties.Cid)
            {
                Callback.ExecuteIfBound(Event);
            }
        });
}
 
template <class TEvent, class UserClass>
typename TEnableIf<TIsDerivedFrom<UserClass, UObject>::IsDerived, FDelegateHandle>::Type UChatChannel::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 UChatChannel::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 UChatChannel::On(
    FunctorType&& Functor,
    VarTypes... Vars)
{
    const TEventDelegate<TEvent> Delegate = TEventDelegate<TEvent>::CreateLambda(Forward<FunctorType>(Functor), Vars...);
    return On<TEvent>(Delegate);
}
 
template <class TEvent>
bool UChatChannel::Unsubscribe(const FDelegateHandle Handle) const
{
    return Socket->Events().Unsubscribe<TEvent>(Handle);
}