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
You can look at the EventType enum. Here is a summary of the events that exist at the present time:
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
You can see a list of the available hooks in the HookEvent class.
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);
API - Previous
Overriding Activities and Fragments
Next - API
Theming
Last modified 2yr ago