// service which methods will accept callbacks to deliver result, the request will be performed in the background delivering result in UI thread.
service = client.service().messaging();

// service which methods will return observables you need to subscribe to
service = client.rxService().messaging();

Messaging service API

Create conversation

ConversationCreate request = ConversationCreate.builder()
   // Unique conversation identifier.
   .setId("1234")
   // Description
   .setDescription("This is my first conversation")
   // Name 
   .setName("Awesome chat")
   // Is this conversation visible to users not being participants.
   .setPublic(false)
   /* Sets what permissions 'owner' and 'participant' will have in this conversation
      You can set if they will can: add new participants, remove participants, send messages.
      By default 'owner' and 'participant' can send messages, can add participants, cannot remove participants.
      Here we added CanRemoveParticipants permission for the 'owner'. */
   .setRoles(new Roles(Role.builder().setCanRemoveParticipants().build(), new Role()))
   .build();

then pass this object to our services:

service.createConversation(request,
   new Callback<ComapiResult<ChatResult>>(){/* implement */});

rxService.createConversation(conversation)
   .subscribe(new Observer<ComapiResult<ChatResult>>(){/* implement */});

Update conversation

ConversationUpdate update = ConversationUpdate.builder()
                .setDescription("New description")
                .setName("Different name")
                .setRoles(roles)
                .setPublic(false)
                .build();

then pass this object to our services:

service.updateConversation(conversationId, update, eTag,
   new Callback<ComapiResult<ChatResult>>(){/* implement */});

rxService.updateConversation(conversationId, update, eTag)
   .subscribe(new Observer<ComapiResult<ChatResult>>(){/* implement */});

Delete conversation

service.deleteConversation(conversationId, eTag,
   new Callback<ComapiResult<Void>>(){/* implement */});

rxService.deleteConversation(conversationId, eTag)
   .subscribe(new Observer<ComapiResult<Void>>(){/* implement */});

Synchronise store

The SDK automatically synchronises local app data with the server when the app becomes foregrounded or the socket reconnected. However, we recommend that you call below method when the screen with a list of conversations becomes visible, or when a user triggers a refresh, for example, by using swipe to refresh the widget.

service.synchroniseStore(new Callback<Boolean>(){/* implement */});

rxService.synchroniseStore()
   .subscribe(new Observer<Boolean>(){/* implement */});

You can also synchronise the local state of a single conversation

service.synchroniseConversation(conversationId, new Callback<Boolean>(){/* implement */});

rxService.synchroniseConversation(conversationId)
   .subscribe(new Observer<Boolean>(){/* implement */});

Conversation participants

Get all participants for a particular conversation:

service.getParticipants(conversationId, 
   new Callback<List<ChatParticipant>>(){/* implement */});

rxService.getParticipants(conversationId)
   .subscribe(new Observer<List<ChatParticipant>>(){/* implement */});

Add participants to a conversation

service.addParticipants(conversationId, participants,
   new Callback<ChatResult>(){/* implement */});

rxService.addParticipants(conversationId, participants)
   .subscribe(new Observer<ChatResult>(){/* implement */});

Remove participants from a conversation

Provide a list of profile IDs to be removed from a conversation:

service.removeParticipants(conversationId, ids,
   new Callback<ChatResult>(){/* implement */});

rxService.removeParticipants(conversationId, ids)
   .subscribe(new Observer<ChatResult>(){/* implement */});

Send message in conversation

service.sendMessage(conversationId, body,
   new Callback<ChatResult>(){/* implement */});

rxService.sendMessage(conversationId, body)
   .subscribe(new Observer<ChatResult>(){/* implement */});

You can also send messages with additional parts, FCM and APNS push notifications, or custom metadata:

Map<String, Object> data = new HashMap<>();
data.put("key","value");

Map<String, Object> fcm = new HashMap<>();
fcm.put("data", data);
fcm.put("notification", "{ \"title\":\"Message\", \"body\":\"Hi!\" } ");

Map<String, Object> apns = new HashMap<>();
apns.put("alert", "Hi!");

Part part = Part.builder()
               .setData("Hi")
               .setName("body")
               .setSize("Hi".length())
               .setType("text/plain")
               .build();

MessageToSend message = MessageToSend.builder()
   .setAlert(fcm, apns)
   .setMetadata(data)
   .addPart(part)
   .build();

then call:

service.sendMessage(conversationId, message, 
   new Callback<ComapiResult<MessageSentResponse>>(){/* implement */});

rxService.sendMessage(conversationId, message)
   .subscribe(new Observer<ComapiResult<MessageSentResponse>>(){/* implement */});

Send message with attachments

service.sendMessage(conversationId, message, attachents,
   new Callback<ComapiResult<MessageSentResponse>>(){/* implement */});

rxService.sendMessage(conversationId, message, attachemnts)
   .subscribe(new Observer<ComapiResult<MessageSentResponse>>(){/* implement */});

where attachments can be created by one of the static constructors:

Attachment.create(file, type, folder, name);

Attachment.create(byteArray, type, folder, name);

Attachment.create(base64string, type, folder, name);

Update message status

You can mark the message as being read by the user, this information will be send to all participants of the coversation.

service.markMessagesAsRead(conversationId, messageIds, 
   new Callback<ChatResult>(){/* implement */});

rxService.markMessagesAsRead(conversationId, messageIds)
   .subscribe(new Observer<ChatResult>(){/* implement */});

Get message page

The chat SDK implements a logic to obtain the next page of messages starting from the latest messages and working backwards.

service.getPreviousMessages(conversationId,
   new Callback<ChatResult>(){/* implement */});

rxService..getPreviousMessages(conversationId)
   .subscribe(new Observer<ChatResult>(){
      /* implement */});

Send user is typing event

To send notification to conversation participants that the user started or finished typing a new message:

service.isTyping(conversationId, isTyping, 
   new Callback<ComapiResult<Void>>(){/* implement */});

rxService.isTyping(conversationId, isTyping)
   .subscribe(new Observer<ComapiResult<Void>>(){/* implement */});