How to implement WebSocket with authentication in Kotlin Android

How to implement WebSocket with authentication in Kotlin Android.

In this tutorial, we will learn how to implement WebSocket with authentication in a Kotlin Android application. We will use the kotlinx.coroutines library to handle asynchronous tasks and the OkHttp library to establish the WebSocket connection.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Kotlin and Android development. You will also need to have the following dependencies added to your project:

• kotlinx.coroutines library
• OkHttp library

Step 1: Add Dependencies

Open your project's build.gradle file and add the following dependencies:

dependencies {
    // other dependencies
    
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.1'
    implementation 'com.squareup.okhttp3:okhttp:4.9.1'
}

Sync your project to download the newly added dependencies.

Step 2: Create WebSocketManager Class

Create a new Kotlin class called WebSocketManager. This class will handle the WebSocket connection and authentication logic. Add the following code to the class:

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import okhttp3.*
import java.util.concurrent.TimeUnit

class WebSocketManager(private val url: String, private val authToken: String) {
    private var webSocket: WebSocket? = null

    fun connect() {
        val request = Request.Builder()
            .url(url)
            .addHeader("Authorization", authToken)
            .build()
        
        val client = OkHttpClient.Builder()
            .readTimeout(0, TimeUnit.MILLISECONDS)
            .build()

        webSocket = client.newWebSocket(request, object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
                super.onOpen(webSocket, response)
                // WebSocket connection established
            }

            override fun onMessage(webSocket: WebSocket, text: String) {
                super.onMessage(webSocket, text)
                // Handle incoming messages
            }

            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
                super.onClosed(webSocket, code, reason)
                // WebSocket connection closed
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                super.onFailure(webSocket, t, response)
                // Handle connection failure
            }
        })
    }

    fun disconnect() {
        webSocket?.cancel()
    }

    fun sendMessage(message: String) {
        webSocket?.send(message)
    }
}

In the WebSocketManager class, we create a WebSocket connection using the provided URL and authentication token. The connect() method establishes the WebSocket connection by creating a Request object with the URL and auth token, and then using the OkHttpClient to create a new WebSocket and provide a WebSocketListener.

The WebSocketListener is an abstract class that we override to handle different WebSocket events such as onOpen, onMessage, onClosed, and onFailure. You can add your own logic inside these overridden methods.

The disconnect() method cancels the WebSocket connection, and the sendMessage() method sends a message to the WebSocket server.

Step 3: Implement WebSocket Authentication

To implement WebSocket authentication, we need to modify the connect() method in the WebSocketManager class. Update the method as follows:

fun connect() {
    val request = Request.Builder()
        .url(url)
        .build()

    val client = OkHttpClient.Builder()
        .readTimeout(0, TimeUnit.MILLISECONDS)
        .authenticator { _, response ->
            response.request.newBuilder()
                .header("Authorization", authToken)
                .build()
        }
        .build()

    webSocket = client.newWebSocket(request, object : WebSocketListener() {
        // WebSocket event listeners
    })
}

In the updated connect() method, we remove the explicit addition of the Authorization header from the initial request. Instead, we use the OkHttpClient's authenticator to add the Authorization header to subsequent requests when challenged by the server.

Step 4: Connect and Disconnect WebSocket

Now that we have implemented the WebSocketManager class, we can connect and disconnect from the WebSocket server. In your Android Activity or Fragment, create an instance of the WebSocketManager class and call the connect() method to establish the connection. Don't forget to provide the WebSocket server URL and authentication token.

val webSocketManager = WebSocketManager("wss://example.com/ws", "YOUR_AUTH_TOKEN")
webSocketManager.connect()

To disconnect from the WebSocket server, call the disconnect() method:

webSocketManager.disconnect()

Step 5: Sending and Receiving Messages

To send a message to the WebSocket server, use the sendMessage() method:

webSocketManager.sendMessage("Hello, server!")

To handle incoming messages, update the onMessage() method in the WebSocketManager class:

override fun onMessage(webSocket: WebSocket, text: String) {
    super.onMessage(webSocket, text)
    // Handle incoming messages
    println("Received message: $text")
}

Conclusion

In this tutorial, we learned how to implement WebSocket with authentication in a Kotlin Android application. We created a WebSocketManager class to handle the WebSocket connection and authentication logic. We used the kotlinx.coroutines library for asynchronous tasks and the OkHttp library to establish the WebSocket connection. We also learned how to connect and disconnect from the WebSocket server, send and receive messages.