🤖
Android
  • Chat SDK Android
  • Getting Started
    • Chat SDK Quickstart
    • Add the Chat SDK to a Firebase app
    • Add the Chat SDK to a non-Firebase app
  • Setup
    • Add Chat SDK to your project
    • Firebase Setup
    • Chat SDK Initialization
    • Set the Chat SDK Theme
    • Enable Location Messages
    • Authentication Screen
    • Add Additional Modules
    • Module Configuration
    • Proguard
  • API
    • Overriding Activities and Fragments
    • Events
    • Theming
    • Customizing the Icons
    • Tab Customization
    • Add a Chat Option
    • Message Customization
    • Integrating Chat SDK User profiles with your app
    • Overriding the Push Notification Handler
    • Handling Structured Meta Data
  • Chat SDK v4
    • Development Guide
    • Updating from v4 to v5
Powered by GitBook
On this page
  • Events
  • EventHandler
  • Hooks

Was this helpful?

  1. API

Events

How to handle notifications from the messaging server

Events

Chat SDK has two main event systems.

EventHandler

You can access the event handler using:

ChatSDK.events()

There are then three main methods:

ChatSDK.events().sourceOnMain().subscribe(event -> {

});

Listen to events on the main thread.

ChatSDK.events().source().subscribe(event -> {

});

Listen to events on a background thread.

ChatSDK.events().errorSourceOnMain().subscribe(throwable -> {

});

Listen for global errors.

List of available events

public enum EventType {
    ThreadAdded,
    ThreadRemoved,
    ThreadDetailsUpdated,
    ThreadMetaUpdated,
    MessageAdded,
    MessageUpdated,
    MessageRemoved,
    MessageSendStatusUpdated,
    ThreadUsersUpdated,
    ThreadUserRoleUpdated,
    UserMetaUpdated,
    UserPresenceUpdated,
    ContactAdded,
    ContactDeleted,
    ContactsUpdated,
    TypingStateUpdated,
    Logout,
    ThreadRead,
    MessageReadReceiptUpdated,
    NearbyUserAdded,
    NearbyUserMoved,
    NearbyUserRemoved,
    NearbyUsersUpdated,
    Error
}

Filtering

If you want to listen for a particular event type you can use the following:

Predicate<NetworkEvent> filter = NetworkEvent.filterType(EventType.ContactAdded, EventType.ContactDeleted);

ChatSDK.events().sourceOnMain().filter(filter).subscribe(event -> {

});

Accessing Event Object

Different event types have different associated objects. For example, a message added event will also provide the message:

ChatSDK.events().sourceOnMain().filter(NetworkEvent.filterType(EventType.MessageAdded)).subscribe(event -> {
    Message message = event.getMessage();
    if (message != null) {

    }
});

Removing the listener

If you want to remove an event listener you can use:

// Add listener
Disposable d = ChatSDK.events().sourceOnMain().subscribe(event -> {

});

// Remove listener
d.dispose()

Hooks

The second way to access events is using the hook system. The difference is that events are read-only whereas with hooks, you can change the functionality of the core library. For example, using a hook, you could intercept the message sent event, make an API call to remove offensive language, modify the message object and then resume message sending.

Sync vs Async

Before demonstrating the API, there is an important thing to understand. Hooks come in two forms, synchronous and asynchronous.

  • Synchronous: This means that processing will be resumed as soon as your block of code finishes. This should be used if you are not calling an external API

  • Asynchronous: This means that processing will be suspended until your completable completes. This is good if you need to call an external server API

Sync

Add a synchronous hook:

Hook hook = Hook.sync(data -> {

});
ChatSDK.hook().addHook(hook, HookEvent.DidAuthenticate);

Async

Hook hook = Hook.async(data -> {
    return Completable.create(emitter -> {
        YourLongRunningAPI.call(() -> {
            emitter.onComplete();
        });
    });
});

ChatSDK.hook().addHook(hook, HookEvent.DidAuthenticate);

This time we are using a completable. That means that execution in the main app will be paused until you call emitter.onComplete(). So in this case, the app will pause until YourLongRunningAPI.call() has finished.

Be aware, if you don't call onComplete() the app will never continue execution.

Available Hooks

public static String DidAuthenticate = "DidAuthenticate";

public static String UserOn = "UserOn";

public static String MessageReceived = "MessageReceived";
public static String MessageWillSend = "MessageWillSend";
public static String MessageSent = "MessageSent";
public static String IsNew_Boolean = "IsNew_Boolean";

public static String DidLogout = "DidLogout";
public static String WillLogout = "WillLogout";

public static String UserDidConnect = "UserDidConnect";
public static String UserWillDisconnect = "UserWillDisconnect";

public static String ContactWillBeAdded = "ContactWillBeAdded";
public static String ContactWasAdded = "ContactWasAdded";
public static String ContactWillBeDeleted = "ContactWillBeDeleted";
public static String ContactWasDeleted = "ContactWasDeleted";

Access data from the hook

Hooks can also provide data. You can access using the following:

public static String User = "User";
public static String Thread = "Thread";
public static String Message = "Message";
public static String Object = "Object";

So:

Hook hook = Hook.sync(data -> {
    Object messageObject = data.get(HookEvent.Message);
    if (messageObject instanceof Message) {
        Message message = (Message) messageObject;
    }
});
ChatSDK.hook().addHook(hook, HookEvent.MessageReceived);

Remove a hook

You can also remove a hook:

ChatSDK.hook().removeHook(hook, HookEvent.MessageReceived);
PreviousOverriding Activities and FragmentsNextTheming

Last updated 4 years ago

Was this helpful?

You can look at the enum. Here is a summary of the events that exist at the present time:

You can see a list of the available hooks in the class.

EventType
HookEvent