Chat Android v4
Chat Android
Chat
Android
Home
/
Chat
/
Android
This is the new Docs for Chat SDK v4 for Android. To see the previous Docs, click here.

Send your first message

With Sendbird Chat SDK for Android, you can efficiently integrate real-time chat into a client app. On the client-side implementation, you can initialize and configure the chat with minimal effort. On the server-side, Sendbird ensures reliable infra-management services for your chat within the app.

This page demonstrates how to install the Chat SDK in your app so that you can send your first message in just a few simple steps.

Note: The fastest way to see Sendbird Chat SDK in action is to build your app on top of our sample app. Download the sample app to jumpstart your build. To implement Kotlin in your app, see our tutorials on How to build in-app chat using Kotlin Part 1 and Part 2.


Requirements

The minimum requirements for Chat SDK for Android are:

  • Android 5.0 (API level 21) or higher
  • Java 8 or higher
  • Android Gradle plugin 3.4.2 or higher

Note: Sendbird server supports Transport Layer Security (TLS) from versions 1.0 up to 1.3. For example, in the server regions where TLS 1.3 isn’t available, lower versions from 1.0 to 1.2 will be sequentially supported for secure data transmission.


Before you start

Before installing Sendbird Chat SDK, you need to create a Sendbird application on Sendbird Dashboard, which comprises everything required in a chat service including users, messages, and channels. You will need the Application ID of your Sendbird application from the dashboard when initializing the Chat SDK.

Each Sendbird application can be integrated with a single client app. Within the same application, users can communicate with each other across all platforms, whether they are on mobile devices or on the web.

Sendbird UIKit

UIKit is a Sendbird Chat SDK add-on with user interfaces that enables easy and fast integration of standard chat features into new or existing client apps.

If you would like a sample app with embedded UI, see UIKit Overview for Android.


Get started

To send a message in a client app, you should build and configure an in-app chat using Sendbird Chat SDK, which can be installed through Gradle or by accessing our remote repository.

Step 1 Install the Chat SDK

How to install the SDK using Gradle depends on your Gradle version. If using Gradle 6.8 or higher, add the following code to your settings.gradle file. If using Gradle 6.7 or lower, add the following code to your root build.gradle file. See this release note to learn more about updates to Gradle.

Gradle 6.8 or higherGradle 6.7 or lower
// Add the following to your settings.gradle file.

dependencyResolutionManagement {
    repositories {
        maven { url "https://repo.sendbird.com/public/maven" }
    }
}

Next, for all Gradle versions, add the dependency to your module build.gradle file.

dependencies {
    implementation 'com.sendbird.sdk:sendbird-chat:4.0.4'
}

Step 2 Request to access system permissions

The Chat SDK requires system permissions. These permissions allow the Chat SDK to communicate with Sendbird server and read from and write on a user device’s storage. To request system permissions, add the following lines to your AndroidManifest.xml file.

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

Step 2-1 (Optional) Configure ProGuard to shrink code and resources

If you're building your APK with minifyEnabled true, add the following line to the module's ProGuard rules file.

-dontwarn com.sendbird.android.shadow.**

Step 3 Initialize the Chat SDK

Now, initialize the Chat SDK in the app to allow the Chat SDK to respond to changes in the connection status of Android client apps. Initialization requires App ID, which can be found on the Sendbird Dashboard.

Note: All methods in the following steps are asynchronous. This means that when using asynchronous methods, your client app must receive success callbacks from Sendbird server through their callback handlers in order to proceed to the next step. A good way to do this is the nesting of methods: Go to Step 6: Enter the channel to learn more about how you can nest the openChannel.enter() in the OpenChannel.getChannel() method.

Before initialization, you should determine whether to enable local caching using InitParams and InitResultHandler() in the SendbirdChat.init() method. The useCaching of InitParams determines whether the client app will use the local storage through Sendbird Chat SDK or not. If you want to build a client app with our local caching functionalities, set the useCaching to true.

Note: If you are not using local caching, the onMigrationStarted() and onInitFailed() in the InitResultHandler() won't be called. To learn more, see Initialize the Chat SDK with APP_ID in Authentication.

With local cachingWithout local caching
// When useCaching is set to true.
SendbirdChat.init(
    InitParams(APP_ID, applicationContext, useCaching = true),
    object : InitResultHandler {
        override fun onMigrationStarted() {
            Log.i("Application", "Called when there's an update in Sendbird server.")
        }

        override fun onInitFailed(e: SendbirdException) {
            Log.i("Application", "Called when initialize failed. SDK will still operate properly as if useLocalCaching is set to false.")
        }

        override fun onInitSucceed() {
            Log.i("Application", "Called when initialization is completed.")
        }
    }
)

Note: The SendbirdChat.init() method must be called across a client app at least once. It is recommended to initialize the Chat SDK with the onCreate() method of the Application instance.

Step 4 Connect to Sendbird server

You will need a user in order to send a message to a channel. You can either create a user on our dashboard or you can use a unique ID that hasn’t been taken by any of your Sendbird application users. In the latter case, a new user will be automatically created in your Sendbird application before being connected.

For those who use the Chat SDK with local caching, refer to the sample codes on the first tab. If not, refer to the second tab.

Note: To learn more about authenticating with an access token, go to Authentication.

With local cachingWithout local caching
// When useCaching is set to true.
SendbirdChat.connect(userId) { user, e ->
    if (user != null) {
        if (e != null) {
            // Proceed in offline mode with the data stored in the local database.
            // Later, connection will be made automatically
            // and can be notified through ConnectionHandler.onReconnectSucceeded().
        } else {
            // Proceed in online mode.
        }
    } else {
        // Handle error.
    }
}

Note: You must receive the result of InitResultHandler() before calling the connect(). Any methods can be called once the user is connected to Sendbird server.

Step 5 Create a new open channel

Create an open channel using the following codes. Open channels are where all users in your Sendbird application easily participate without an invitation.

OpenChannel.createChannel(OpenChannelCreateParams()) { channel, e ->
    if (e != null) {
        // Handle error.
    }

    // An open channel is successfully created.
    // Through the channel parameter of the onResult() callback method,
    // you can get the open channel's data from the result object that Sendbird server has passed to the onResult().
}

Note: You can also create a group channel to send a message. To learn more, see Create a channel in the Group channel page.

Step 6 Enter the channel

Enter the channel to send and receive messages.

// The CHANNEL_URL argument below can be retrieved using openChannel.url.
OpenChannel.getChannel(CHANNEL_URL) { channel, e ->
    if (e != null) {
        // Handle error.
    }

    // Call the instance method of the result object in the openChannel parameter\
    // of the onResult() callback method.
    channel?.enter { e ->
        if (e != null) {
            // Handle error.
        }

        // The current user successfully enters the open channel,
        // and can chat with other users in the channel by using APIs.
    }
}

Step 7 Send a message to the channel

Finally, send a message to the channel. To learn more about the message type you can send, see Message Overview in our Platform API Docs.

openChannel.sendUserMessage(UserMessageCreateParams(MESSAGE)) { message, e ->
    if (e != null) {
        // Handle error.
    }

    // The message is successfully sent to the channel.
    // The current user can receive messages from other users
    // through the onMessageReceived() method of an event handler.
}

Step 8 Receive a message

Add the onMessageReceived() channel event handler using the SendbirdChat.addChannelHandler() method so that you can receive the message you just sent to the channel. You can also see the message in our dashboard.

SendbirdChat.addChannelHandler(
    UNIQUE_HANDLER_ID, // Replace UNIQUE_HANDLER_ID with a unique identifier for this handler.
    object : OpenChannelHandler() {
        override fun onMessageReceived(channel: BaseChannel, message: BaseMessage) {}
    }
)