How to Build an Android Chat App using Kotlin

Introduction

In this tutorial, we will explain the steps to build an Android Chat App using MirrorFly SDKs. We’ll cover the basics of building an app, integration of the SDKs, enabling chat features. Also, we will explain how to connect your chat app to the MirrorFly server, to implement direct messaging functionality.

Now, let’s quickly check on the requirements to build the app:

Setup your Application

Basic Requirements for Chat App

This Kotlin tutorial was built with the below requirements,

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

Initial Setup for Kotlin Chat App

The initial setup to build your existing chat app using kotlin involves the below steps,

• Get the SDK license key for your Applications
  • a) Create your free MirrorFly Console account
• Installation setup
• Integration of Chat SDK
• Configure the server with SDK server & Data
• Initialization of Chat SDK
• New User Registration
• Get connected to the Chat Server
• Sending/Receiving of messages

Now, the first initialization process begins with installation, wherein the task of chat SDK implementation is performed at the beginning.

Let's understand this in detail.

1) Get the SDK License Key

Obtaining a license key for your MirrorFly application is one of the utmost steps to be done before moving ahead with integration of MirrorFly chat SDK.

In other words, it is necessary to have an authentication check as to whether the SDKs are authenticated for further processing or not by the MirrorFly server.

So, to get the license key you need to create a MirrorFly account.

a) Create your MirrorFly Console Account for Free

You need to follow the below steps to create your MirrorFly console account,

Step 1 : First you have to create an account by signing into the MirrorFly Console page using Registration Page

Step 2 : The registration process requires your basic details such as your name, organization details, contact number, and work email, etc., to get enrolled.

Step 3 : Great, You get your MirrorFly account! Now you are free to explore every loop and corner of your MirrorFly account to get any required information.

Step 4 : However, this lets you get access to the license key. For this, you can simply click on the ‘Overview page’ where you have your license key available, downloadable Android SDK file to proceed with further integration process.

Step 5 : Copy the license key under the "Application info" section in the "Overview" page and begin with the installation process.

2) Installation Process Kotlin Chat App

To begin with the installation process, the file has to be imported into the project with the support of Kotlin technology. This is carried out using some of the below steps,

Step 1 : To download the latest AAR files from MirrorFly's Android SDKs, you need to first click on the Android SDK.

Step 2 : This will take you to the 'Download button,' available at the top of the guided documentation.

Step 3 : Click on this ‘downloadable button’ and get into the zip folders, now extract the needed AAR files from the zip folder.

3) Integrate Chat SDK Kotlin Chat App

Step 1 : After completing the download of AAR files, it’s time to create a new project or open an existing one in Android Studio.

Step 2 : Add the below given libraries in the app/libs folder in the project.

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

Step 3 : Now, add the below given 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 : Then add the below given 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 : Following this, add the dependencies given below that are 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.4'
                      implementation 'org.igniterealtime.smack:smack-tcp:4.4.4'
                      implementation 'org.igniterealtime.smack:smack-im:4.4.4'
                      implementation 'org.igniterealtime.smack:smack-extensions:4.4.4'
                      implementation 'org.igniterealtime.smack:smack-sasl-provided:4.4.4'
                      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'
                      } 
                     

Step 6 : Add the below codes in the gradle.properties file, mainly to avoid imported library conflicts.

                           android.enableJetifier=true
                     

Step 7 : Once done with the above, open the AndroidManifest.xml and add the below permissions.

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

Configure in app/build.gradle file

                        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"'
                         }
                         }
                        

4) Initialize Chat SDK Kotlin Chat App

To start with the initialization process of the SDK, there is a need for some fundamental data before proceeding further. Therefore, the ChatSDK builder class is made into use to provide these necessary data to the available SDK.

Henceforth, you can call upon the below given ChatSDK Builder in the onCreate() method to provide the necessary data for your application class. Let's have a look in detail,

                     //For chat logging
                     LogMessage.enableDebugLogging(BuildConfig.DEBUG)
                     ChatSDK.Builder()
                     .setDomainBaseUrl(BuildConfig.SDK_BASE_URL)
                     .setLicenseKey(BuildConfig.LICENSE)
                     .setIsTrialLicenceKey(true)
                     .build() 
                     

5) User Registration

For every activity to take place in the messaging app, there is a need for registration, for which you must undergo an authentication process. Thus, to register a new user in the Sandbox Live mode you have to call upon the below method based on the provided setIsTrialLicenseKey.

Here, while registration you must ensure that the method has been called only once before closing the session. However, in this context you must call upon the below registerUser method with the acceptance of FCM_TOKEN to process further.

                              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
CALLBACK	FlyCallback	FlyCallback is used as a callback, implemented and expressed as lambda expression for easy reading

6) Connect to the Chat Server

Before moving ahead with any activity, it is necessary to get connected to the chat server. Thus, you have to establish a connection with the server. Here, we need a chat SDK messaging with the below method to initiate the process.

However, the process stores all the details about the connection to work further automatically.

                  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

Common Terminology for Chat SDK Builder

Let's have a look at some of the common terminologies that are used in the Chat SDK with description,

Keyword	Description
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

Once you have made all the connections with the server now it's the time to perform text messaging within your existing kotlin chat app in android.

7) Send One-to-one Text Message

You can use the below method to send a text message from one user to another,

But, here there is a need to create a unique user id for which you must call the other user's using username method String userJID = FlyUtils.getJid(USERNAME)

                              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 Text Message

To receive a text message, you can extend the FlyBaseActivity from the SDK within your app using the BaseActivity method. In addition, you will also be able to observe all the incoming messages and other features listeners.

                                  class MainActivity :  FlyBaseActivity()    
                     

However, here the listeners would be called only when a new message is received from the other users end.

                              override fun onMessageReceived(message: ChatMessage) {
                               super.onMessageReceived(message)
                               // received message object
                              }
                     

Well, the above are the basic features and functionalities used in any messaging app, but if you are in need of some specific functionalities then our Chat SDK is there to support you with all your needs.

Conclusion

And we’re done! This tutorial took you through the complete process of building a chat app in Kotlin, with the help of MirrorFly Chat SDKs. If you’ve found this guide simple and easy, you may also check out our other features here and experiment with them

If you'd like to get assistance with the SDK installation from our team of experts, write to us and we will get back to you. Until then, happy chat app development!