Typing indicator

Typing indicators show users when someone is composing a message. This feature:

• Increases engagement - Users see activity in group chats
• Sets expectations - Users know when to expect a response in 1:1 conversations

You can use PubNub's functionality via Blueprints or directly in C++ code.

• In Blueprints, the whole SDK is managed by a subsystem, so start by initalizing the PubnubChatSubsystem node. Afterwards, you can use the Pubnub Chat object reference.

Blueprint functions

The Blueprints provided in the documentation show how you can structure your application and may contain utility methods and elements like buttons that are not part of the Unreal Chat SDK and are meant to serve as guidance.

• In C++, you can use the PubNub SDK as any other Game Instance Subsystem.

  #include "Kismet/GameplayStatics.h"
  #include "PubnubChatSubsystem.h"
  
  
  UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
  UPubnubChatSubsystem* PubnubChatSubsystem = GameInstance->GetSubsystem<UPubnubChatSubsystem>();
  
  
  UPubnubChat* Chat = PubnubChatSubsystem ->InitChat("demo", "demo", "my_user") // config optional

  Chat now allows you to call all Chat SDK functions, for example:

  Chat->DeleteUser("SomeUserID");

Usage in Blueprints and C++

Not available for public chats

Typing indicator is disabled in public chats. If you try implementing this feature in a public channel type, you'll get the Typing indicators are not supported in Public chats error.

Start typing

StartTyping() activates the typing indicator on a channel.

The method uses a debounce mechanism: signals are sent at intervals rather than on every keystroke. The default timeout is 5000 ms (5 seconds), with a 1000 ms buffer to prevent rapid re-triggering.

Custom timeout

Set a custom timeout with the typingTimeout parameter during initialization.

Method signature

Blueprint

C++ / Input parameters

1Channel->StartTyping();

Output

This method doesn't return any value.

Sample code

Start a typing indicator on the incident-management channel.

1#include "Kismet/GameplayStatics.h"
2#include "PubnubChatSubsystem.h"
3

4UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
5UPubnubChatSubsystem* PubnubChatSubsystem = GameInstance->GetSubsystem<UPubnubChatSubsystem>();
6

7UPubnubChat* Chat = PubnubChatSubsystem ->InitChat("demo", "demo", "my_user");
8

9UPubnubChannel* Channel = Chat->GetChannel("incident-management");
10

11Channel->StartTyping();

Stop typing

StopTyping() deactivates the typing indicator on a channel.

Use this method to disable the typing indicator immediately (for example, when a user deletes a draft message) without waiting for the typingTimeout to end.

Method signature

Blueprint

C++ / Input parameters

1Channel->StopTyping();

Output

This method doesn't return any value.

Sample code

Stop a typing indicator on the incident-management channel.

1#include "Kismet/GameplayStatics.h"
2#include "PubnubChatSubsystem.h"
3

4UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
5UPubnubChatSubsystem* PubnubChatSubsystem = GameInstance->GetSubsystem<UPubnubChatSubsystem>();
6

7UPubnubChat* Chat = PubnubChatSubsystem ->InitChat("demo", "demo", "my_user");
8

9UPubnubChannel* Channel = Chat->GetChannel("incident-management");
10

11Channel->StopTyping();

Get typing events

GetTyping() adds a signal events listener underneath to get all events of type typing. Run it once on a given channel to start listening to typing signals. You can also use it to get a list of typing user IDs. This method also returns a function you can invoke to stop receiving signal events and unsubscribe from the channel.

Method signature

GetTyping() accepts a callback function as an argument. The Unreal Chat SDK invokes this callback whenever someone starts/stops typing. This function takes a single argument of the list of currently typing user IDs.

Blueprint

C++ / Input parameters

1Channel->GetTyping(FOnPubnubChannelTypingReceived TypingCallback);

| Parameter | Type | Required | Default | Description | | :-------- | :-------- | :-------- | :--- | :--- | :--- | | TypingCallback | FOnPubnubChannelTypingReceived | Yes n/a | Callback function passed as a parameter to both methods. It defines the custom behavior to be executed when detecting channel metadata changes. |

Each function in the Unreal Chat SDK that takes a callback as a parameter requires you to handle the response type accordingly.

For example, you can bind a callback function for the Channel->StreamPresence method to its handler in the following way:

1// Create a pubnub response delegate
2// you MUST implement your own callback function to handle the response
3FOnPubnubChannelStreamPresenceReceived PresenceResponse;
4PresenceResponse.BindDynamic(this, &AMyActor::OnPresenceResponseReceived);
5

6Channel->StreamPresence(PresenceResponse);

You can implement the callback function to handle the response as follows:

AMyActor.h

1UFUNCTION()
2void OnPresenceResponseReceived(const TArray<FString> &PresentUsersIDs);

AMyActor.cpp

1void AMyActor::OnPresenceResponseReceived(const TArray<FString> &PresentUsersIDs)
2{
3	for(auto PresentUser : PresentUsersIDs)
4	{
5		UE_LOG(LogTemp, Log, TEXT("Present User ID: "), *PresentUser);
6	}
7}

Handle the response

Output

Type	Description
UPubnubCallbackStop*	Object on which you can call Stop() to stop receiving updates.

Sample code

Get a list of user IDs currently typing on the support channel.

1#include "Kismet/GameplayStatics.h"
2#include "PubnubChatSubsystem.h"
3

4UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
5UPubnubChatSubsystem* PubnubChatSubsystem = GameInstance->GetSubsystem<UPubnubChatSubsystem>();
6

7UPubnubChat* Chat = PubnubChatSubsystem ->InitChat("demo", "demo", "my_user");
8

9UPubnubChannel* Channel = Chat->GetChannel("support");
10

11// Create a pubnub response delegate
12// you MUST implement your own callback function to handle the response
13FOnPubnubChannelTypingReceived TypingResponse;
14TypingResponse.BindDynamic(this, &AMyActor::OnTypingResponseReceived);
15

16Channel->GetTyping(TypingResponse);

show all 16 lines

Other examples

Stop receiving signals on the support channel.

1auto StopUpdates = Channel->GetTyping();
2

3StopUpdates->Stop();