Let's integrate our SDK in few minutes

Quick Start

Download SDK Files

Download

Chat SDKs for Android

With CONTUS MirrorFly Chat SDK for Android, you can efficiently integrate the desired real-time chat features into a client app.

When it comes to the client-side implementation, you can initialize and configure the chat with minimal efforts. With the server-side, MirrorFly ensures reliable infra-management services for the chat within the app. This page will let you know how to install the chat SDK in your app.

Note : If you're looking for the fastest way in action with CONTUS MirrorFly Chat SDKs, then you need to build your app on top of our sample version. Simply download the sample app and commence your app development. To download sample app click here

Requirements

The requirements for chat SDK for Android are:

• Android Lollipop 5.0 (API Level 21) or above
• Java 7 or higher
• Gradle 4.1.0 or higher

Things to be Noted Before Making a Start

SDK License Key

Before integrating CONTUS MirrorFly Chat SDK, you need to have a SDK license key for your MirrorFly application. This SDK needs to be authenticated by the MirrorFly server using the license key for further processing.

Follow the below steps to get your license key:

Step 1: Let’s Create an Account - Sign up into MirrorFly Console page (https://console.mirrorfly.com/register) for free MirrorFly account

Step 2: Create an account with your basic details including your name, organization details, work email, and contact number

Step 3: Once you’re in! You get access to your MirrorFly account ‘Overview page’ where you can find the downloadable Android SDK for further integration process

Step 4: To download the AAR files from the Android SDKs, click on ‘Download’ which will take you to the top of the guided documentation page, here, click on the ‘Download button’ and extract the AAR files from the ZIP folder

Step 5: Once finished with the download, now it's time to start with the integration process that begins with creating a new project to develop a chat app.

Integrate the Chat SDK

As soon as the AAR files have been imported from the zip file using Kotlin, you can start over with the integration process.

Step 1: Create a new project or Open an existing project in Android Studio

Step 2: Add the following libraries in app/libs folder in the project

• appbase.aar
• flycommons.aar
• flynetwork.aar
• flydatabase.aar
• videocompression.aar
• xmpp.aar

Step 3: Add the below code in the app/build.gradle file.

plugins {

...

id 'kotlin-android'

id 'kotlin-kapt'

}

android {

compileOptions {

sourceCompatibility JavaVersion.VERSION_1_8

targetCompatibility JavaVersion.VERSION_1_8

}

kotlinOptions {

jvmTarget = '1.8'

}

packagingOptions {

exclude 'META-INF/AL2.0'

exclude 'META-INF/DEPENDENCIES'

exclude 'META-INF/LICENSE'

exclude 'META-INF/LICENSE.txt'

exclude 'META-INF/license.txt'

exclude 'META-INF/NOTICE'

exclude 'META-INF/NOTICE.txt'

exclude 'META-INF/notice.txt'

exclude 'META-INF/ASL2.0'

exclude 'META-INF/LGPL2.1'

exclude("META-INF/*.kotlin_module")

}

}

Step 4: Add the following dependencies in the app/build.gradle file.

dependencies {

... // your app dependencies

implementation files('libs/appbase.aar')

implementation files('libs/flycommons.aar')

implementation files('libs/flynetwork.aar')

implementation files('libs/flydatabase.aar')

implementation files('libs/videocompression.aar')

implementation files('libs/xmpp.aar')

}

Step 5: Add the below dependencies required by the SDK in the app/build.gradle file.

dependencies {

... // your app dependencies

configurations {

all {

exclude group: 'org.json', module: 'json'

exclude group: 'xpp3', module: 'xpp3'

}

}

//For lifecycle listener

implementation 'android.arch.lifecycle:extensions:1.1.1'

annotationProcessor 'android.arch.lifecycle:compiler:1.1.1'

//For GreenDao

implementation 'de.greenrobot:greendao:2.1.0'

//For gson parsing

implementation 'com.google.code.gson:gson:2.8.1'

//for smack implementation

implementation ('org.igniterealtime.smack:smack-android:4.4.6')

implementation ('org.igniterealtime.smack:smack-tcp:4.4.6')

implementation 'org.igniterealtime.smack:smack-im:4.4.6'

implementation 'org.igniterealtime.smack:smack-extensions:4.4.6'

implementation 'org.igniterealtime.smack:smack-sasl-provided:4.4.6'

implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'

implementation 'androidx.multidex:multidex:2.0.1'

implementation 'com.google.android.gms:play-services-location:17.0.0'

//Dagger Dependencies

api 'com.google.dagger:dagger:2.40.5'

kapt 'com.google.dagger:dagger-compiler:2.40.5'

api 'com.google.dagger:dagger-android:2.40.5'

api 'com.google.dagger:dagger-android-support:2.40.5'

kapt 'com.google.dagger:dagger-android-processor:2.40.5'

//coroutines

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.8'

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.8'

//apicalls

implementation 'com.squareup.retrofit2:retrofit:2.6.1'

implementation 'com.squareup.retrofit2:converter-gson:2.6.1'

implementation 'com.squareup.okhttp3:okhttp:4.2.0'

implementation 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2'

//stetho interceptor

implementation 'com.facebook.stetho:stetho-okhttp3:1.3.1'

//okhttp interceptor

implementation 'com.squareup.okhttp3:logging-interceptor:3.14.3'

//shared preference encryption

implementation 'androidx.security:security-crypto:1.1.0-alpha03'

//for mobile number formatting

implementation 'io.michaelrocks:libphonenumber-android:8.10.1'

}

Step 6: Add the below line in the project level build.gradle file, to resolve library dependencies.

Step 7: Add the below line in the gradle.properties file, to avoid imported library conflicts.

android.enableJetifier=true

Step 8: Open the AndroidManifest.xml and add below permissions.

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Configure in app/build.gradle file

You can copy the license key from the 'Overview’ section in the Console dashboard.

buildTypes {

debug {

buildConfigField 'String', 'SDK_BASE_URL', '"https://api-preprod-sandbox.mirrorfly.com/api/v1/"'

buildConfigField 'String', 'LICENSE', '"xxxxxxxxxxxxxxxxxxxxxxxxx"'

buildConfigField 'String', 'WEB_CHAT_LOGIN', '"https://webchat-preprod-sandbox.mirrorfly.com/"'

buildConfigField "String", "SUPPORT_MAIL", '"contussupport@gmail.com"'

}

}

Initialize Chat SDK

To start using the sdk, there is a need for some basic requirements before proceeding with the initialization process. Thus, the ChatSDK builder class is used to provide the necessary data to the SDK. In your Application class, inside the onCreate() method use the below ChatSDK Builder to provide the necessary data.

Java

//For chat logging

LogMessage.enableDebugLogging(BuildConfig.DEBUG);

new ChatSDK.Builder()

.setDomainBaseUrl(BuildConfig.SDK_BASE_URL)

.setLicenseKey(BuildConfig.LICENSE)

.setIsTrialLicenceKey(true)

.build();

Kotlin

//For chat logging

LogMessage.enableDebugLogging(BuildConfig.DEBUG)

ChatSDK.Builder()

.setDomainBaseUrl(BuildConfig.SDK_BASE_URL)

.setLicenseKey(BuildConfig.LICENSE)

.setIsTrialLicenceKey(true)

.build()

Chat Builder Function Description

Function	Parameter Type	Description
setDomainBaseUrl	String	Url is provided to make API calls
setLicenseKey	String	License key is required to proceed with registration
setIsTrialLicenceKey	boolean	If the provided license key is for trial version, display the text as ‘true’ else ‘false’
build	n/a	Initializes the chat configuration

caution

The base URL must have the Http/Https protocol which must be closed with a ‘slash (/)’, if not an exception - a bug message will pop up.

Registration

The below method to register a user in sandbox Live mode based on setIsTrialLicenceKey provided.

info

Unless you log out the session, make a note that should never call the registration method more than once in an application

Note: While registration, the below registerUser method will accept the FCM_TOKEN and FORCE_REGISTER as an optional param and pass it across.

Java

FlyCore.registerUser(USER_IDENTIFIER, (isSuccess, throwable, data ) -> {

if(isSuccess) {

Boolean isNewUser = (Boolean) data.get("is_new_user");

JSONObject responseObject = (JSONObject) data.get("data");

// Get Username and password from the object

} else {

// Register user failed print throwable to find the exception details.

}

});

Kotlin

FlyCore.registerUser(USER_IDENTIFIER) { isSuccess, throwable, data ->

if(isSuccess) {

val isNewUser = data["is_new_user"] as Boolean

val responseObject = data.get("data") as JSONObject

// Get Username and password from the object

} else {

// Register user failed print throwable to find the exception details.

}

}

Argument	Type	Description
USER_IDENTIFIER	String	A unique Id to Register the User
FCM_TOKEN	String	A registration token that is generated by FCM SDK for the user's app instance to send message for free
FORCE_REGISTER	boolean	default value true provide true to force the logout of the old session If the registered user has reached the maximum no of multi-sessions or provide false to allow registration till the maximum no of multi-sessions
CALLBACK	FlyCallback	FlyCallback is used as a callback, implemented and expressed as lambda expression for easy reading

caution

If FORCE_REGISTER is false and it reached the maximum no of multi-sessions then registration will not succeed it will throw a 405 exception, Either FORCE_REGISTER should be true or one of the existing session need to be logged out to continue registration.

Connect to the Chat Server

In order to send messages using the Chat SDK, at first you need to establish the connection to the server. SDK provides methods for initialize the chat connection.

Note: The ChatManager.connect() method should be called only once in an application. SDK will handle the chat server connection and disconnection automatically.

Java

ChatManager.connect(new ChatConnectionListener() {

@Override

public void onConnected() {

// Write your success logic here to navigate Profile Page or

// To Start your one-one chat with your friends

}

@Override

public void onDisconnected() {

// Connection disconnected

//No need implementations

}

@Override

public void onConnectionNotAuthorized() {

// Connection Not authorized

//No need implementations

}

});

Kotlin

ChatManager.connect(object : ChatConnectionListener {

override fun onConnected() {

// Write your success logic here to navigate Profile Page or

// To Start your one-one chat with your friends

}

override fun onDisconnected() {

// Connection disconnected

//No need implementations

}

override fun onConnectionNotAuthorized() {

// Connection Not authorized

//No need implementations

}

})

Argument	Type	Description
CALLBACK	ChatConnectionListener	callback listener for chat connection

Terminology

Some of the most common terminologies used in Chat SDK with description

keyword	Explanation
userID/userBareID	Unique ID assigned for each user Ex: 12345678 (any alphanumeric). The below characters is not allowed in userId: U+0022 (") U+0026 (&) U+0027 (') U+002F (/) U+003A (:) U+003C (<) U+003E (>) U+0040 (@) userID should follow below specification: https://xmpp.org/extensions/xep-0106.html
userJid (or) JID	userID+@+domain of the chat server Ex. 12345678@xmpp.chatsystem.dev.contus.us
groupID/groupBareID	Unique ID assigned for each group Ex: group123456 (any alphanumeric). GroupJID = groupID +@mix.+domain of the chat server Ex: group123456@mix.xmpp.mirrorfly.dev.contus.us`

info

SDK will have built-in functions to prepare the JID, Group JID, and more.

Send a One-to-One Message

Use the below method to send a text message to other user,

Note: To generate a unique user id, you must call the other user's username method String userJID = FlyUtils.getJid(USERNAME)

Java

FlyMessenger.sendTextMessage(TO_JID, TEXT, new SendMessageListener() {

@Override

public void onResponse(boolean isSuccess, @Nullable ChatMessage chatMessage) {

// you will get the message sent success response

}

});

Kotlin

FlyMessenger.sendTextMessage(TO_JID, TEXT, listener = object : SendMessageListener {

override fun onResponse(isSuccess: Boolean, chatMessage: ChatMessage?) {

// you will get the message sent success response

}

})

Argument	Type	Description
TO_JID	String	JID of the end user
TEXT	String	Indicates the text message that needs to be sent
REPLY_MESSAGE_ID	String	Specifies the Message ID of replied message
CALLBACK	SendMessageListener	callback to observe the action status

Receive a One-to-One Message

You can extend the FlyBaseActivity from SDK into your app BaseActivity, and observe all the incoming messages and other feature listeners.

Java

public class MainActivity extends FlyBaseActivity { }

Kotlin

class MainActivity : FlyBaseActivity()

Moreover, here the listeners would be called only when a new message is received from other user. To get more details please visit this callback listeners

Java

@Override

public void onMessageReceived(@NonNull ChatMessage message) {

super.onMessageReceived(message);

// received message object

}

Kotlin

override fun onMessageReceived(message: ChatMessage) {

super.onMessageReceived(message)

// received message object

}