Write your First mesibo Enabled Application - Android
Estimated reading time: 24 minutes- Introduction
- Create Access Tokens
- Android
- iOS
- Xamarin
- Flutter
- Javascript
- C++
- Python
- Hosting Media & Files
- Sync Messages
- Authentication
In this part, we will create a simple real-time messaging and calling app for Android. This app will let you log in as two different users so that you can try various mesibo features.
We will quickly explore the following
-
Sending and Receiving Messages
-
Voice and Video Calls
-
Group Messaging
-
Group Calls (Conferencing)
-
Reading Messages from database
-
Using UI Modules
Prerequisites and Download Source Code
- Read the section Create Users to learn about creating an app in mesibo console and creating users & access tokens for your app.
- Knowledge of using Android Studio and making basic Android Apps
- Download the source code for the First mesibo Android App from GitHub for Java and Kotlin.
- [Optional] You can download and run mesibo messenger app on one of your phones so that you can use it to test the First App.
Configure and Build First Android App
In this step, we will configure and build the First App. Once you run it, we will get into more details.
Step 1 Open Project
Start Android Studio and open the project that you downloaded from GitHub.
This project already has all the mesibo SDKs configured. However, in the future, if you are creating a new project, you can add mesibo SDKs to your project by adding Gradle dependency and performing Gradle sync as explained in installation instructions.
Step 2 Configure Mesibo Tokens
Before we can build and run the app, we need to configure app with valid mesibo user tokens as explained in Create Users section.
Create tokens for two users, each with the User Address 123
and 456
and App ID com.mesibo.firstapp
and configure two demo users in the source code with the tokens you have generated.
For example, in Java
DemoUser mUser1 = new DemoUser("<token 1>", "User-1", "123");
DemoUser mUser2 = new DemoUser("<token 2>", "User-2", "456");
Example, in Kotlin
internal var mUser1 = DemoUser("<token 1>", "User-1", "123")
internal var mUser2 = DemoUser("<token-2>", "User-2", "456")
Step 3 Build and Run
Build and Run the project. It may take a few seconds and then you should see the following screen
You should install the app on two devices. On the first device, click on the Login as User1
button and on another device, click on the Login as User2
button.
If you add a breakpoint on Mesibo_onConnectionStatus
, you will see that it cycles through various status information. Finally, you should receive status=1
which indicates that your app is successfully connected to the mesibo real-time server and ready to send and receive real-time messages.
You can now send messages to each other and can also make voice and video calls.
If you check the logs or add a breakpoint on Mesibo_onMessage
, you can see that you got the message in Mesibo_onMessage
listener.
Once you have tried all the demo features, you can start going into details below.
Code Explanation
Initialize mesibo
Before you send and receive real-time messages and calls, you need to initialize mesibo. The initialization involves the following steps:
- Use
setAccessToken
to set the user’s access token that you obtained while creating the user - Set up mesibo to invoke your listener class using
addListener
- Set up database to store sent and received messages using
setDatabase
(Optional) - Start mesibo
Note that, except
addListener
, all other initialization functions should be only called once.
Sample mesibo initialization code in Java
Mesibo api = Mesibo.getInstance();
api.init(getApplicationContext());
Mesibo.addListener(this);
Mesibo.setAccessToken(user.token);
Mesibo.setDatabase("mydb", 0);
Mesibo.start();
//... Refer to the Sample Code on GitHub ...//
Sample mesibo initialization code in Kotlin
val api: Mesibo = Mesibo.getInstance()
api.init(applicationContext)
Mesibo.addListener(this)
Mesibo.setAccessToken(user.token)
Mesibo.setDatabase("mydb", 0)
Mesibo.start()
//... Refer to the Sample Code on GitHub...//
Extend your activity to Implement mesibo.MessageListener
and mesibo.ConnectionListner
class and implement listeners. The easiest way is to click on the Code
menu and click on Implement Methods
and it will automatically generate the code for all the methods.
Sample mesibo Listeners in Java,
public class MainActivity extends AppCompatActivity implements mesibo.MessageListener,
Mesibo.ConnectionListener {
@Override
public void Mesibo_onConnectionStatus(int status) {
// You will receive the connection status here
Log.d(TAG, "on Mesibo Connection: " + status);
}
@Override
public void Mesibo_onMessage(MesiboMessage msg) {
// You will receive messages here
/* Messaging documentation https://mesibo.com/documentation/api/messaging/ */
if(msg.isIncoming()) {
/* Profile documentation https://mesibo.com/documentation/api/users-and-profiles/ */
MesiboProfile sender = msg.profile;
// check if this message belongs to a group
/* Group Management - https://mesibo.com/documentation/api/group-management/ */
if(msg.isGroupMessage()) {
MesiboProfile group = msg.groupProfile;
}
// check if this message is realtime or read from the database
if(msg.isRealtimeMessage()) {
toast("You have got a message from " + sender.getNameOrAddress("") + ": " + msg.message);
}
} else if(msg.isOutgoing()) {
/* messages you sent */
} else if(msg.isMissedCall()) {
}
return true;
}
@Override
public void Mesibo_onMessageUpdate(MesiboMessage msg) {
// You will receive message updates here
return true;
}
@Override
public void Mesibo_onMessageStatus(MesiboMessage msg) {
// You will receive status of sent messages here
}
}
Sample mesibo Listeners in Kotlin,
override fun Mesibo_onConnectionStatus(status: Int) {
// You will receive the connection status here
}
override fun Mesibo_onMessage(message: MesiboMessage) {
// You will receive messages here
// A simple example of message processing
/* Messaging documentation https://mesibo.com/documentation/api/messaging/ */
if (msg.isIncoming()) {
/* Profile documentation https://mesibo.com/documentation/api/users-and-profiles/ */
val sender: MesiboProfile = msg.profile;
// check if this message belongs to a group
/* Group Management - https://mesibo.com/documentation/api/group-management/ */
if(msg.isGroupMessage()) {
val group: MesiboProfile = msg.groupProfile;
}
// check if this message is realtime or read from the database
if(msg.isRealtimeMessage()) {
toast(
"You have got a message from " + sender.getNameOrAddress("")
.toString() + ": " + msg.message
)
}
} else if (msg.isOutgoing()) {
/* messages you sent */
} else if (msg.isMissedCall()) {
}
}
override fun Mesibo_onMessageUpdate(message: MesiboMessage) {
// You will receive message updates here
}
override fun Mesibo_onMessageStatus(message: MesiboMessage) {
// You will receive the status of sent messages here
}
That’s it - you are now ready to send and receive your first real-time message.
Select Destination
As explained earlier, mesibo has two types of destinations, individual users and groups. Every valid mesibo user and group in your app are represented by MesiboProfile
object. The MesiboProfile
object has all the information about the user or group, for example, name, status, photo, etc. You can get a profile for any user or group by calling getProfile
API. For example,
In Java,
mProfile = Mesibo.getProfile(address);
In Kotlin,
mProfile = Mesibo.getProfile(address)
Once you have the profile, you can perform various APIs like accessing profile information, sending messages to the destination, etc.
Sending and Receiving Messages
Now we will quickly learn how to send messages in real-time.
To send messages, you only need to create a MesiboMessage
object for the destination, add your content (text message, files, location, etc.) and call send
method. You can create a MesiboMessage
object by calling
MesiboMessage message = profile.newMessage();
OR,
MesiboMessage message = new MesiboMessage(profile);
where the profile
is the user or group profile to whom you want to send a message. Once you create a MesiboMessage
object, all you need to do is to add your message content and call send()
. There is no difference between how you send messages to an individual user or a group, the destination is set based on the profile you have used to create MesiboMessage
.
MesiboMessage msg = profile.createMessage();
msg.title = "Trying Mesibo";
msg.message = "My First Message";
msg.send();
You can also add a file using file path, URL, or Android Bitmap as required. For example,
msg.setContent("/file/path");
msg.send();
You can also geotag your messages by adding location information,
msg.latitude = 37.4275;
msg.longitude = 122.1697;
msg.send();
Once you send a message, the recipient will receive the message through Mesibo_onMessage
. mesibo will inform the sender of the message about the status of the message - sent, delivered, or read through the listener Mesibo_onMessageStatus
.
Voice and Video Calls
mesibo allows you to enable peer-to-peer HD video and voice calls between your users in just a few lines of code. As with messaging, mesibo video and voice calls are encrypted and hence secure. mesibo does not charge any additional amount for the voice or video call APIs.
Making and receiving voice & video calls with mesibo is simple. You only need to initialize MesiboCall once using just two lines of code! Then, mesibo will automatically handle incoming calls. For outgoing calls, you can invoke call API as required.
You can use mesibo voice and video calls as it is. But, if you wish, you can customize it to your needs. For example, you can customize the call screen UI, filter incoming calls, etc. Refer to Call API Reference to learn more.
To initialize in Java
MesiboCall.init(context);
MesiboCall.getInstance().setDefaultUiTitle("your app name");
To make a call in Java
MesiboCall.getInstance().callUi(this, profile, true);
Initialization In Kotlin
MesiboCall.getInstance().init(applicationContext)
MesiboCall.getInstance().setDefaultUiTitle('mesibo first app')
To make a call in Kotlin
MesiboCall.getInstance().callUi(this, profile, true)
In the first app tutorial we have now learned about two of the most fundamental mesibo APIs - the messaging API and call API. In the upcoming sections, we will learn more about various mesibo APIs and features that you can use. Such as group messaging, group calls, reading stored messages, UI Modules, etc.
Group Messaging and Group Calls
In this section, we will learn about group messaging and group calls(conferencing). The group messaging API is similar to the one-to-one messaging API and the group call API is similar to the one-to-one voice and video call API.
Group Messaging
Group messaging is no different from the one-to-one messaging. You can invoke the same messaging APIs to send a group message, instead of the user’s profile, you need to use group profile.
For example, here is an example of how you can send a message to a group. Let’s say you have a group with the group-id 96568
. Now, you use the same function that you use for sending a one-to-one message, but instead of using the user profile, you first get the group profile using the group-id and use it to send a group message.
Using Java,
profile = Mesibo.getProfile(96568);
MesiboMessage msg = profile.createMessage();
msg.message = "My First Group Message";
msg.send();
A message sent will be delivered to all members of the group and you will get the message delivery and read status for each user.
Creating a Group
To create a group and add members, you need to use the Group Management APIs. This is the recommended approach. However, you can also create a group and add/remove members by using backend APIs and mesibo console if requires.
You can create a new group by calling createGroup
API, with name and the Group Listener Object.
In Java,
Mesibo.createGroup("My Group", 0, this);
In Kotlin
Mesibo.createGroup("My Group", 0, this);
It will send a request to the server to create a new group. When a group is created, callback function in the listener will be called with the group profile. You can then add members to the group using group profile APIs.
@Override
public void Mesibo_onGroupCreated(MesiboProfile profile) {
Log.d(TAG, "New group " + groupProfile.groupid);
}
You can now use this new group profile for messaging, adding more members or changing group name, description, picture, etc.
Adding members to a Group
You can add members, and admins to the group by calling addMembers
API of the group profile. You need to pass the addresses of the users to be added as group members, permissions to be granted and admin permissions if you are adding them as group admins.
For example,
String[] members = {"18005550001", "18005550002", "18005550003"};
MesiboGroupProfile gp = profile.getGroupProfile();
gp.getGroupProfile().addMembers(members, MESIBO_MEMBERFLAG_ALL, 0);
Group Calls (Conferencing)
mesibo group calling simply extends the existing features of group messaging with additional permissions and control, for example, room resolution, talk detection, who can publish and who can video, voice+video or voice only, etc. Your existing groups will now have additional conferencing settings.
To add mesibo Group Calling to your app, here is an overview of steps to follow:
- Have a group of members with required permissions
- Create a group call object with
groupCall()
- To publish your stream to the group, get a Participant object using
createPublisher
and make acall()
- To subscribe to other users’ streams, get their call object in
MesiboGroupCall_OnPublisher
and make acall()
- Display the stream using
setVideoView
For detailed documentation and examples for conferencing refer to Mesibo Conferencing Docs and download the example source code for conferencing from GitHub
You can also try a live demo of a Zoom-like conferencing app, Mesibo Live built using mesibo conferencing and streaming API. The source code of the app is available on Github. You can download it, modify or rebrand it, and integrate it into your app or website.
Reading Messages & Call History
mesibo provides a set of APIs to read messages and call history stored in the database and sending read receipts. A read receipt is an acknowledgment that the user has read the message.
To read stored messages from the database, you need to create a read session and set the criteria to read messages; for example,
- read all messages
- read call history
- read messages from a sender
- read messages for a particular group
- read messages matching a search query etc.
The read session you create filters the messages in the database based on the criteria provided and gives the resulting list of messages to you.
Reading Modes
There are two modes of operation:
- Read Messages and call logs. This mode is enabled by default
- Read Summary (active conversations), read the latest message from each user and group. This allows you to get a snapshot of all the communicating users and groups. You can then create another read session to read messages for any of those users or groups.
Reading Order
Once you set a read session, you can start reading messages by calling read
API. You can read messages in the first-in-first-out (FIFO) mode or the last-in-first-out (LIFO) mode. In the first-in-first-out model, the oldest messages are read first. By default, the first-in-first-out mode is disabled.
Read Receipts
You can enable the automatic sending of read-receipts every time you read a message. This can be achieved by enabling a read-receipt for the read session. On reading or receiving a message, read receipts will be automatically sent if
- The app is set to be in the foreground
- Sending Read Receipt is enabled for the reading session, AND
- Read receipt requested by the sender, AND
- A new real-time or database message matches the read session.
A call to
read
will return the number of messages read. You can callread
on demand. For example, in the case of a messaging app, you only need to show the latest messages on the screen initially. So, first, you can callread(10)
to load the last 10 messages. As the user scrolls up the chat history, you can callread
again. All subsequent calls toread
will read older messages.
To read messages and call history for a user or a group, in Java
// Read receipts are enabled only when App is set to be in foreground
Mesibo.setAppInForeground(this, 0, true);
MesiboReadSession mReadSession = profile.createReadSession(this);
mReadSession.enableReadReceipt(true);
mReadSession.read(100);
To read the last message from each user and group (summary), in Java
MesiboReadSession mReadSession = new MesiboReadSession(this);
mDbSession.enableSummary(true);
mReadSession.enableReadReceipt(false);
mReadSession.enableMissedCalls(mShowMissedCalls);
mReadSession.read(100);
To read messages and call history for a user or a group, in Kotlin
// Read receipts are enabled only when App is set to be in foreground
Mesibo.setAppInForeground(this, 0, true)
MesiboReadSession mReadSession = profile?.createReadSession(this);
mReadSession?.enableReadReceipt(true)
mReadSession?.read(100)
To read last message from each user and group (summary), in Kotlin
mReadSession = MesiboReadSession(this)
mReadSession?.enableReadReceipt(true)
mReadSession?.enableMissedCalls(true)
mReadSession?.read(100)
Ready to use UI Modules
mesibo provides a variety of pre-built UI components that allow you to quickly add messaging, voice & video call graphical user interface in your app. mesibo UI modules are completely customizable. You can not only customize colors, icons, etc but also customize how each message is rendered. This enables you to create powerful chatbots in no-time.
mesibo UI modules are available as:
- Fragment (Android)
- ViewController (iOS)
- Individual Views (android and ios)
One of the key advantages of mesibo UI modules is that they are well tested and you only need to write minimal code to create fully-functional UIs. Any future enhancements are also automatically available to you.
![]() |
![]() |
![]() |
To use mesibo UI modules, you need to perform the following steps:
- Add UI modules to your project
- Initialize mesibo API with access token as described in the Android, or iOS section
- Launch mesibo UI modules, for example,
MesiboUI.launch(context, 0, false, true);
That’s it.
The best way to learn how to use mesibo UI modules is to refer to the open-source messenger app for Android, iOS, and Javascript source code which uses mesibo UI modules for various functionalities like welcome screen, login, media picker, one-to-one and group messaging, user list, group management, showing profiles, etc.
Source Code of mesibo UI modules
You can also access the complete source code of UI modules here:
mesibo Messaging UI module for Android uses Google Map SDK for location. Hence, you’ll need to get your own Google Map Key to use location features. Refer to mesibo installation instruction for your platform to learn more.
In the following sections, we will explain how you can launch mesibo UI modules for messaging and calls. The code examples are taken from source code available on GitHub - First mesibo App for Android
Launching Messaging UI in Android
-
Install mesibo UI Modules by following Instructions for Android
- Import the messaging-UI Module.
import com.mesibo.messaging.MesiboUI;
- In the case of one-to-one messaging, you will need to launch the message UI for each user. For example, if there is a user named
User2
, you will need to launch the messaging UI like below
To launch the messaging UI for a user, you need to pass the address to that user.
Here, is an example in Java
public void onLaunchMessagingUi(View view) {
MesiboUI.launchMessageView(this, profile, 0);
}
Here, is an example in Kotlin
fun onLaunchMessagingUi(view: View?) {
MesiboUI.launchMessageView(this, profile, 0)
}
If you want to learn more about messaging UI modules and how you can customize them see Using mesibo Messaging UI Modules
Push Notifications and Webhooks
Your app can use push notifications to alert a user about important events. For example, when the user is offline, and there is a new message, you can display a push notification so that the user can click on it and view the message. To send push notifications, you can use FCM( Firebase Cloud Messaging) or APN(Apple Push Notification). You can send all types of push notifications — background push notifications(silent notifications) and alerts through mesibo. All you need to do is configure your FCM/APN push credentials in the console. Then, mesibo will automatically send push notifications to your users on behalf of you.
You can learn more about using Push Notifications with mesibo here.
A WebHook is an HTTP(S) URL that will be invoked with POST data in real-time by mesibo when something happens; for example, an offline message, a user comes online or goes offline, etc. You can learn more about using webhooks with mesibo here.
First mesibo Application: iOS >>
mesibo, android