How to Implement Read Receipts On Your Android Chat App?

Step 4 : In order to refrain from conflict among the imported library files, we’ll need to add the below code to the gradle.properties file

                   android.enableJetifier=true 
                  

Step 5 : Next, add the permissions to AndroidManifest.xml

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

Step 6 : Now, we need to add the License key to the 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"' 
                       } 
                   } 
                      
                  

IV. Initializing The Chat SDK

This step will collect all the essential data like client and server details to start the data exchange between user devices.

Step 1 : To kickstart, add the below code to the onCreate() method of the Application class

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

                  

V. Registering The App User

This step is used to register the user in the sandbox or live mode. The below code will check if the license key is on trial and register the user

                     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. 
                       } 
                       }); 
                  

VI. Connecting To Chat Server

To connect the client-side apps, we’ll need a central server that can execute data exchange between the devices. The below SDK method will set up the server connection and start receiving and sending the data on client requests from user devices.

                   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 
                     } 
                   }); 

                  

VII. Sending Messages

Once, the server connection is established, you can start sending messages from a device through the SDK by implementing the following method

                   FlyMessenger.sendTextMessage(TO_JID, TEXT, new SendMessageListener() { 
                     @Override 
                     public void onResponse(boolean isSuccess, @Nullable ChatMessage chatMessage) { 
                         // you will get the message sent success response 
                     } 
                 }); 

                  

VIII. Receiving Messages

This method will be used to notify the user device when new incoming messages are received on the user device.

                    @Override 
                        public void onMessageReceived(@NonNull ChatMessage message) { 
                            super.onMessageReceived(message); 
                            // received message object 
                        } 

                   }); 

                  

IX. Adding The Read Receipt Feature

Once the app can send and receive messages, the user needs the status of the message delivery on the UI. The below method will notify the user when the recipient has opened the sent message.

Before setting this up, we’ll need to make a few configurations with the user jid. Here are the steps:

Step 1 : We’ll need to set the user jid as ongoing chat user in the activity/fragment onResume

                       @Override 
                     public void onResume() { 
                             super.onResume(); 
                             ChatManager.setOnGoingChatUser(JID); 
                         } 


                  

Step 2 : Next, we’ll need to clear the ongoing chat user in the activity/fragment onPause

                   @Override 
                         public void onPause() { 
                               super.onPause(); 
                               ChatManager.setOnGoingChatUser(""); 
                           } 
                  

Step 3 : Now, when the chat window is opened, the recipient jid will be passed to the below method

Step 4 : The SDK will start using the user jid set by the ChatManager.setOnGoingChatUser(jid: String)

                      ChatManager.markAsRead(JID)
                  

X. Observing The Message Events

Using the below method, we can register a listener to update the user UI immediately on any message related events. When a message is sent via the SDK, the message status events will give the respective callbacks.

                   ChatEventsManager.setupMessageEventListener(new MessageEventsListener() { 
                         @Override 
                         public void onMessageReceived(@NotNull ChatMessage message) { 
                           //called when the new message is received 
                         } 
                      
                         @Override 
                         public void onMessageStatusUpdated(@NotNull String messageId) { 
                           //called when the message status is updated 
                           //find the index of message object in list using messageId 
                           //then fetch message object from db using `FlyMessenger.getMessageOfId(messageId)` and notify the item in list 
                         } 
                      
                         @Override 
                         public void onMediaStatusUpdated(@NotNull ChatMessage message) { 
                           //called when the message status is updated 
                           //find the index of message object in list using messageId 
                           //then fetch message object from db using `FlyMessenger.getMessageOfId(messageId)` and notify the item in list 
                         } 
                      
                         @Override 
                         public void onUploadDownloadProgressChanged(@NotNull String messageId, int progressPercentage) { 
                         //called when the media message progress is updated 
                         } 
                      
                         @Override 
                         public void onMessagesClearedOrDeleted(@NotNull ArrayList messageIds) { 
                         //called when the message is deleted 
                         } 
                     }); 


                  

Conclusion

Through this tutorial, we have seen the steps to implement read receipts in an Android chat app , including the respective code samples. To explore more features for your app, we encourage you to check out our Features page.

Also, you can also gain further details and support with the implementation from our team of experts. Contact us now!