Skip to main content

Notifications

Last updated on

Overview​

AccelByte Cloud's Notification service enables administrators or publishers to send text-based notifications to players. Notifications can be sent from service to service or from service to the client application. Notifications are sent using REST API and are relayed through a WebSocket connection, to ensure that they've been received in real-time. The main features of our Notification service are listed below.

  • Freeform and Template notification types allow you to control the content of your notifications. Freeform notifications can be used for ad-hoc cases where the publishers need to send a notification instantly to their players. Templated notifications include draft and localization features that are suitable for more planned use cases, such as game updates or promotional announcements.

  • Notification Topics can group notifications of similar types to keep them organized.

Permissions​

Permissions are used to grant access to specific resources within our services. Make sure your account has the following permissions before you attempt to manage notification in the Admin Portal.

UsageResourceAction
Create a Notification TopicADMIN:NAMESPACE:{namespace}:NOTIFICATIONCreate
Send a Freeform Notification to a UserADMIN:NAMESPACE:{namespace}:NOTIFICATIONCreate
Create a Notification TemplateADMIN:NAMESPACE:{namespace}:NOTIFICATIONCreate
Send a Templated NotificationADMIN:NAMESPACE:{namespace}:NOTIFICATIONCreate

Permissions work slightly differently depending on whether they are assigned to IAM Clients or Roles assigned to users. For more information, read the Authentication and Authorization documentation.

Manage Notifications in the Admin Portal​

The Admin Portal gives community managers and game admins an easy way to manage players' notifications.

Create a Notification Topic​

To create or maintain notification topics in the Admin Portal, follow the steps below.

  1. In the Game Management section of the Admin Portal, go to the Push Notifications section and click the Topics menu. Then click the New Topic button to add a new topic.

  2. The Add New Topic form will appear. Fill in the required fields as seen below.

    • Topic. The new topic that you wanted to set

    • Description. The Description of the new topic that you're gonna create.

  3. The newly created topic will be visible in the Notification Topics panel. You can view and edit the topic by clicking the Edit button or delete the topic by clicking the Delete button.

Send a Freeform Notification​

By default, sending freeform notifications to individual players from the Admin Portal utilizes synchronous notification. This means that the targeted player must be online to retrieve the message. However, the broadcast feature does not require the player to be online as it sends the message to all players in a namespace, regardless of online status.

  1. On the Template page of the Admin Portal, click the Send Freeform button.

  2. In the Send Freeform window, select which type of user you are going to send the template to. If you select Single User, you need to input the target player's User ID. If you select All User, the notification will be delivered to all players in the selected namespace.

    • Type Choose Single User or All User for sending a freeform notification. If you choose a single user, you need to input a specific user id from the player.

    • Topic You can choose any topic if you want. Topic is the one that you created before from the topic panel. it depends on your game logic to handle the notification.

    • Notification Message What message that you want to send to the player. It can be a new update message, new event message, banned user, and other stuff that depends on what your game logic is.

    Once completed, click the Send button to send the notification template or click the Cancel button to cancel the process.

Create a Notification Template​

Template notifications utilize an asynchronous method to send a notification to either a single-player or to all players. To send a templated notification, create a template by following the steps below.

  1. On the Templates page of the Admin Portal, click the New Template button.

  2. Fill in the Add New Template form with the required fields.

    • Input the template's name in the Template field with the appropriate format.

    • Select the template's Language from the dropdown menu.

    • Input the Notification Message.

    Click the Add button. The newly created template will appear on the Notification Templates page.

  3. On the Templates page, you can choose your newly created template and click the View button to open the Template Localization page.

  4. Here you can create a draft of the notification message before you publish it.

    After you have created a template for your notification, you are ready to send templated notifications to players.

Send a Templated Notification​

  1. On the Template page of the Admin Portal, click the Send Template button.

  2. In the Send Template window, select which type of player you are going to send the notification to. If you select Single User, you need to input the player's User ID. If you select All User, the notification will be delivered to all players in the selected namespace.

    When you're done, click the Send button to send the notification or click the Cancel button to cancel the process.

Implement Notifications with the Client SDKs​

Notifications can be retrieved either synchronously or asynchronously.

Retrieve Synchronous Notifications​

To retrieve a synchronous notification using the SDK, you need to add the notification delegate.

const auto NotificationDelegate = AccelByte::Api::Lobby::FMessageNotif::CreateLambda([](const FAccelByteModelsNotificationMessage& Result)
{
UE_LOG(LogTemp, Log, TEXT("There is an incoming notification."));
UE_LOG(LogTemp, Log, TEXT("From: %s \nTo: %s\nTopic: %s"), *Result.From, *Result.To, *Result.Topic);
UE_LOG(LogTemp, Log, TEXT("Notification: %s"), *Result.Payload);
});

AccelByte::FRegistry::Lobby.SetMessageNotifDelegate(NotificationDelegate);
AccelByte::FRegistry::Lobby.Connect();

You can also filter notifications by topic.

const auto NotificationDelegate = AccelByte::Api::Lobby::FMessageNotif::CreateLambda([](const FAccelByteModelsNotificationMessage& Result)
{
UE_LOG(LogTemp, Log, TEXT("There is an incoming notification."));
if(Result.Topic == “INGAME”)
{
    UE_LOG(LogTemp, Log, TEXT("Game notification: %s"), *result.Payload);
}
Else if(Result.Topic == “EVENT”)
{
    UE_LOG(LogTemp, Log, TEXT("Event notification: %s"), *result.Payload);
}
});

Retrieve Asynchronous Notifications​

To retrieve an asynchronous notification, just call the get asynchronous function and all stored notifications will be sent to your notification delegate.

AccelByte::FRegistry::Lobby.GetAllAsyncNotification();

Connect Custom Services to Notifications using the Server SDKs​

SDK Initialization​

Before using the Cloud Notifications service from the SDK, you will need to initialize your server-side SDK to ensure you are authorized and able to perform create, read, update, and delete actions.

Golang SDK Initialization​

Before using the Notifications service from the Golang SDK, you will need to initialize the SDK by following the steps below:

notificationService := &service.NotificationServiceWebsocket{
    Client:            &repository.ConfigRepositoryImpl{},
    TokenRepository:   &repository.TokenRepositoryImpl{},
    ConnectionManager: &utils.ConnectionManagerImpl{},
}

Once completed, you can use the Golang SDK to create, read, update, and delete Notifications from your serverless app.

Python SDK Initialization​

Before using the Notifications service from the Python SDK, you will need to initialize the SDK by following the steps below:

Once completed, you can use the Python SDK to create, read, update, and delete Notifications from your serverless app.

.NET (C#) SDK Initialization​

Use following .NET namespaces:

using AccelByte.Sdk.Api.Lobby;
using AccelByte.Sdk.Api.Lobby.WSModel;

The Lobby WebSocket service works slightly differently to other AccelByte services. Before using the Lobby WebSocket service, you will need to create a LobbyService object.

LobbyService lobby = new LobbyService(sdk.Configuration);
lobby.OnReceiveError = (eMessage) =>
{
    is_error = true;
    //handle if error occurs here
};

Once completed, you can connect and listen to the Lobby WebSocket service.

Task connectTask = lobby.Connect(false);
connectTask.Wait();

Task listenTask = Task.Run(() => lobby.Listen());

Java SDK Initialization​

Before usin

WebSocket Setup​

Some of the features in the Notifications service use WebSocket to enable the connection. Make sure you've set up WebSocket using our CLI. Once you've set up the CLI, you can use the GetNotificationMessage() wrapper to initialize the Notification service from the Lobby service.

Send a Freeform Notification​

Use the following function to send a freeform notification:

err := notificationService.FreeFormNotification(input)
if err != nil {
  return err
}
return nil

Receive Parsed Web Socket Messages​

Use the following function to receive a parsed websocket message from the server:

//messageHandler is callback function how to handle incoming ws message
var messageHandler = func(dataByte []byte) {
  message, err := parser.UnmarshalResponse(dataByte)
  if err != nil {...}

  // print all incoming message type
  logrus.Infof("Message type: %v", message.Type())

  marshal, err := json.Marshal(message)
  if err != nil {...}

  // print all incoming message content
  logrus.Infof("Message content: %v", string(marshal))

  // if you want to specify the message type and write logic for each of it
  switch message.Type() {
  case model.TypeNotificationMessage:
     notificationMsg := message.(model.NotificationMessage)
     logrus.Infof("Notification is coming from %s to %s", notificationMsg.From, notificationMsg.To)

  case model.TypeKickResponse:
     kickMessage := message.(model.KickResponse)
     logrus.Infof("Message id is: %s", kickMessage.MessageID)
  }
}

Retrieve Offline Notifications using Web Socket​

Use the following function to retrieve an offline notification:

err := notificationService.GetNotificationMessage()
if err != nil {
  return err
}
return nil

Send a create party request message​

Use the following function to send a party request message:

lobby.OnPartyCreateResponse = (PartyCreateResponse resp) =>
{
    is_response_received = true;
    //create party response

};

Task sendTask = lobby.SendPartyCreateRequest(new PartyCreateRequest()
{
    Id = request_id
}, 0);
sendTask.Wait();

When you are finished, disconnect from the Lobby WebSocket service.
Task disconnectTask = lobby.Disconnect();
disconnectTask.Wait();