Invite users to channels

Requires App Context

Enable App Context for your keyset in the Admin Portal.

Invite users to private or group conversations, creating their channel membership. Invitations trigger an invite event that you can listen to and notify invited users.

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++

To send notifications on invitations, implement custom logic to:

• Create and send custom events when invitations are sent
• Let invited users receive these events

Invite one user

Request a user to join a channel with Invite().

Method signature

Blueprint

C++ / Input parameters

1Channel->Invite(UPubnubUser* User);

Input

* required

Parameter	Description
User * Type: UPubnubUser* Default: n/a	User that you want to invite to a 1:1 channel.

Output

Type	Description
UPubnubMembership*	Returned (modified) object containing the membership data.

Sample code

Invite support-agent-15 to join the high-prio-incidents 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("high-prio-incidents");
10

11// Define user ID
12FString UserID = "support_agent_15";
13

14// Get the user and save the reference
15UPubnubUser* User = Chat->GetUser(UserID);
16

17Channel->Invite(User);

show all 17 lines

Invite multiple users

Request multiple users to join a channel with InviteMultiple(). Maximum 100 users per call.

Method signature

Blueprint

C++ / Input parameters

1Channel->InviteMultiple(TArray<UPubnubUser*> Users);

Input

* required

Parameter	Description
Users * Type: TArray<UPubnubUser*> Default: n/a	Array of users you want to invite to the group channel. You can invite up to 100 users in one call.

Output

Type	Description
TArray<UPubnubMembership*>	Returned (modified) array of objects containing the membership data.

Sample code

Invite support-agent-15 and support-agent-16 to join the high-prio-incidents 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("high-prio-incidents");
10

11// Define user IDs
12FString UserID1 = "support_agent_15";
13FString UserID2 = "support_agent_16";
14

15// Get the user and save the reference
16UPubnubUser* User1 = Chat->GetUser(UserID1);
17UPubnubUser* User2 = Chat->GetUser(UserID2);
18

19TArray<UPubnubUser*> Users;
20Users.Add(User1);
21Users.Add(User2);
22

23Channel->InviteMultiple(Users);

show all 23 lines

Listen to invite events

Monitor invitation events with ListenForEvents() and send notifications to invited users.

Events documentation

See Chat events for details on invite events.

Method signature

Blueprint

C++ / Input parameters

1Chat->ListenForEvents(
2    FString ChannelID, 
3    EPubnubChatEventType ChatEventType, 
4    FOnPubnubEventReceived EventCallback
5);

* required

Parameter	Description
ChannelID * Type: FString Default: n/a	Channel to listen for new invite events.
ChatEventType Type: EPubnubChatEventType Default: n/a	Type of events. PCET_INVITE is the type defined for all events emitted when an offensive message is flagged/reported.
EventCallback * Type: FOnPubnubEventReceived Default: n/a	Callback function passed as a parameter. It defines the custom behavior to be executed whenever an invite event type is detected on the specified channel.

EPubnubChatEventType

Value	Description
PCET_TYPING	Indicates a user is typing a message. Displayed as Typing.
PCET_REPORT	Represents an event where a message has been flagged or reported for offensive content. Displayed as Report.
PCET_RECEIPT	Confirms receipt of a message or event. Displayed as Receipt.
PCET_MENTION	Indicates that a user has been mentioned in a message. Displayed as Mention.
PCET_INVITE	Represents an invitation event typically sent to a specific user. Displayed as Invite.
PCET_CUSTOM	Custom event type for specialized behavior or use cases. Displayed as Custom.
PCET_MODERATION	Represents an event related to content moderation actions. Displayed as Moderation.

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

This method doesn't return any value.

Sample code

Listen for invitations received 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

9FString ChannelID = "support";
10

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

16Chat->ListenForEvents(
17    ChannelID,
18    EPubnubChatEventType::PCET_INVITE,
19    ListenResponse
20);

show all 20 lines