Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Kotlin

Android Networking Kotlin Samples

Android Kotlin networking examples including HTTP requests, file download/upload, and WebSocket connections

Samples

Entries inside this sample collection

CodekotlinSimple

HTTP Requests

Send GET and POST requests using HttpURLConnection and OkHttp libraries with proper error handling

Difficulty

6/10

Estimated time

30 min

Tags

kotlin, android, networking, http

Prerequisites

Basic Kotlin knowledge, Internet permission in manifest

kotlin
// Android Kotlin HTTP Request Examples
// Using HttpURLConnection and OkHttp

import android.content.Context
import kotlinx.coroutines.*
import java.io.*
import java.net.*
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

// 1. HttpURLConnection Examples
class HttpURLConnectionExample(private val context: Context) {

    // Simple GET request
    suspend fun simpleGetRequest(url: String): String? = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(url)
            connection = urlObj.openConnection() as HttpURLConnection
            connection.requestMethod = "GET"
            connection.connectTimeout = 10000
            connection.readTimeout = 10000

            val responseCode = connection.responseCode
            println("Response Code: $responseCode")

            if (responseCode == HttpURLConnection.HTTP_OK) {
                val response = connection.inputStream.bufferedReader().use { it.readText() }
                println("Response: $response")
                return@withContext response
            } else {
                println("Error response code: $responseCode")
                return@withContext null
            }
        } catch (e: Exception) {
            println("GET Request Error: ${e.message}")
            return@withContext null
        } finally {
            connection?.disconnect()
        }
    }

    // POST request with JSON body
    suspend fun postJsonRequest(url: String, jsonData: JSONObject): String? = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(url)
            connection = urlObj.openConnection() as HttpURLConnection
            connection.requestMethod = "POST"
            connection.setRequestProperty("Content-Type", "application/json")
            connection.doOutput = true

            // Write JSON body
            val outputStream = connection.outputStream
            outputStream.write(jsonData.toString().toByteArray(Charsets.UTF_8))
            outputStream.flush()
            outputStream.close()

            val responseCode = connection.responseCode
            println("POST Response Code: $responseCode")

            if (responseCode == HttpURLConnection.HTTP_OK || responseCode == HttpURLConnection.HTTP_CREATED) {
                val response = connection.inputStream.bufferedReader().use { it.readText() }
                println("POST Response: $response")
                return@withContext response
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("POST Request Error: ${e.message}")
            return@withContext null
        } finally {
            connection?.disconnect()
        }
    }

    // POST request with form data
    suspend fun postFormData(url: String, params: Map<String, String>): String? = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(url)
            connection = urlObj.openConnection() as HttpURLConnection
            connection.requestMethod = "POST"
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
            connection.doOutput = true

            // Build form data
            val formData = params.map { "${URLEncoder.encode(it.key, "UTF-8")}=${URLEncoder.encode(it.value, "UTF-8")}" }
                .joinToString("&")

            val outputStream = connection.outputStream
            outputStream.write(formData.toByteArray(Charsets.UTF_8))
            outputStream.flush()
            outputStream.close()

            val responseCode = connection.responseCode
            if (responseCode == HttpURLConnection.HTTP_OK) {
                val response = connection.inputStream.bufferedReader().use { it.readText() }
                return@withContext response
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("Form POST Error: ${e.message}")
            return@withContext null
        } finally {
            connection?.disconnect()
        }
    }

    // GET request with headers
    suspend fun getRequestWithHeaders(url: String, headers: Map<String, String>): String? = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(url)
            connection = urlObj.openConnection() as HttpURLConnection
            connection.requestMethod = "GET"

            // Add custom headers
            headers.forEach { (key, value) ->
                connection.setRequestProperty(key, value)
            }

            val responseCode = connection.responseCode
            if (responseCode == HttpURLConnection.HTTP_OK) {
                val response = connection.inputStream.bufferedReader().use { it.readText() }
                return@withContext response
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("GET with Headers Error: ${e.message}")
            return@withContext null
        } finally {
            connection?.disconnect()
        }
    }
}

// 2. OkHttp Examples
class OkHttpExample(private val context: Context) {

    private val client = OkHttpClient.Builder()
        .connectTimeout(10, java.util.concurrent.TimeUnit.SECONDS)
        .readTimeout(10, java.util.concurrent.TimeUnit.SECONDS)
        .build()

    // Simple GET with OkHttp
    suspend fun simpleGet(url: String): String? = withContext(Dispatchers.IO) {
        try {
            val request = Request.Builder()
                .url(url)
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("OkHttp GET Error: ${e.message}")
            return@withContext null
        }
    }

    // Async GET with callback
    fun asyncGet(url: String, callback: (String?) -> Unit) {
        val request = Request.Builder()
            .url(url)
            .build()

        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                println("Async GET failed: ${e.message}")
                callback(null)
            }

            override fun onResponse(call: Call, response: Response) {
                val body = response.body?.string()
                callback(body)
            }
        })
    }

    // POST with JSON body
    suspend fun postJson(url: String, json: JSONObject): String? = withContext(Dispatchers.IO) {
        try {
            val mediaType = "application/json".toMediaType()
            val body = json.toString().toRequestBody(mediaType)

            val request = Request.Builder()
                .url(url)
                .post(body)
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("OkHttp POST Error: ${e.message}")
            return@withContext null
        }
    }

    // POST with form data
    suspend fun postForm(url: String, params: Map<String, String>): String? = withContext(Dispatchers.IO) {
        try {
            val formBody = FormBody.Builder()
            params.forEach { (key, value) ->
                formBody.add(key, value)
            }

            val request = Request.Builder()
                .url(url)
                .post(formBody.build())
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("Form POST Error: ${e.message}")
            return@withContext null
        }
    }

    // PUT request
    suspend fun putRequest(url: String, json: JSONObject): String? = withContext(Dispatchers.IO) {
        try {
            val mediaType = "application/json".toMediaType()
            val body = json.toString().toRequestBody(mediaType)

            val request = Request.Builder()
                .url(url)
                .put(body)
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("PUT Error: ${e.message}")
            return@withContext null
        }
    }

    // DELETE request
    suspend fun deleteRequest(url: String): Boolean = withContext(Dispatchers.IO) {
        try {
            val request = Request.Builder()
                .url(url)
                .delete()
                .build()

            val response = client.newCall(request).execute()
            return@withContext response.isSuccessful
        } catch (e: Exception) {
            println("DELETE Error: ${e.message}")
            return@withContext false
        }
    }

    // Request with custom headers
    suspend fun requestWithHeaders(
        url: String,
        headers: Map<String, String>,
        method: String = "GET"
    ): String? = withContext(Dispatchers.IO) {
        try {
            val requestBuilder = Request.Builder()
                .url(url)

            // Add headers
            headers.forEach { (key, value) ->
                requestBuilder.addHeader(key, value)
            }

            // Set method
            when (method.uppercase()) {
                "POST" -> {
                    val mediaType = "application/json".toMediaType()
                    val body = "{}".toRequestBody(mediaType)
                    requestBuilder.post(body)
                }
                "PUT" -> {
                    val mediaType = "application/json".toMediaType()
                    val body = "{}".toRequestBody(mediaType)
                    requestBuilder.put(body)
                }
                "DELETE" -> requestBuilder.delete()
            }

            val response = client.newCall(requestBuilder.build()).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("Request with Headers Error: ${e.message}")
            return@withContext null
        }
    }
}

// 3. Advanced HTTP Operations
class AdvancedHttpExample(private val context: Context) {

    private val client = OkHttpClient()

    // Multipart upload
    suspend fun uploadMultipart(
        url: String,
        file: File,
        fileParamName: String = "file",
        params: Map<String, String> = emptyMap()
    ): String? = withContext(Dispatchers.IO) {
        try {
            val requestBody = MultipartBody.Builder()
                .setType(MultipartBody.FORM)

            // Add parameters
            params.forEach { (key, value) ->
                requestBody.addFormDataPart(key, value)
            }

            // Add file
            val mediaType = "multipart/form-data".toMediaType()
            requestBody.addFormDataPart(
                fileParamName,
                file.name,
                file.asRequestBody(mediaType)
            )

            val request = Request.Builder()
                .url(url)
                .post(requestBody.build())
                .build()

            val response = client.newCall(request).execute()
            return@withContext response.body?.string()
        } catch (e: Exception) {
            println("Multipart Upload Error: ${e.message}")
            return@withContext null
        }
    }

    // Download file with progress
    suspend fun downloadFileWithProgress(
        url: String,
        outputFile: File,
        onProgress: (Long, Long) -> Unit
    ): Boolean = withContext(Dispatchers.IO) {
        try {
            val request = Request.Builder().url(url).build()
            val response = client.newCall(request).execute()

            if (!response.isSuccessful) {
                return@withContext false
            }

            val inputStream = response.body?.byteStream() ?: return@withContext false
            val contentLength = response.body?.contentLength() ?: 0

            outputFile.outputStream().use { output ->
                val buffer = ByteArray(8192)
                var bytesRead: Int
                var totalBytesRead = 0L

                while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                    output.write(buffer, 0, bytesRead)
                    totalBytesRead += bytesRead

                    if (contentLength > 0) {
                        onProgress(totalBytesRead, contentLength)
                    }
                }
            }

            return@withContext true
        } catch (e: Exception) {
            println("Download Error: ${e.message}")
            return@withContext false
        }
    }

    // Retry mechanism
    suspend fun requestWithRetry(
        url: String,
        maxRetries: Int = 3,
        delayMillis: Long = 1000
    ): String? = withContext(Dispatchers.IO) {
        var lastException: Exception? = null

        repeat(maxRetries) { attempt ->
            try {
                val request = Request.Builder().url(url).build()
                val response = client.newCall(request).execute()

                if (response.isSuccessful) {
                    return@withContext response.body?.string()
                }
            } catch (e: Exception) {
                lastException = e
                println("Attempt $attempt failed: ${e.message}")

                if (attempt < maxRetries - 1) {
                    delay(delayMillis)
                }
            }
        }

        println("All $maxRetries attempts failed")
        return@withContext null
    }

    // Caching configuration
    fun createCachedClient(cacheDir: File, cacheSize: Long = 10 * 1024 * 1024): OkHttpClient {
        val cache = Cache(cacheDir, cacheSize)

        return OkHttpClient.Builder()
            .cache(cache)
            .build()
    }

    // Request with timeout
    suspend fun requestWithTimeout(
        url: String,
        timeoutSeconds: Int = 30
    ): String? = withContext(Dispatchers.IO) {
        try {
            val client = OkHttpClient.Builder()
                .connectTimeout(timeoutSeconds.toLong(), java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(timeoutSeconds.toLong(), java.util.concurrent.TimeUnit.SECONDS)
                .build()

            val request = Request.Builder().url(url).build()
            val response = client.newCall(request).execute()

            return@withContext response.body?.string()
        } catch (e: Exception) {
            println("Timeout Error: ${e.message}")
            return@withContext null
        }
    }
}

// 4. REST API Client
class RestClient(private val baseUrl: String, private val context: Context) {

    private val client = OkHttpClient()

    suspend fun get(endpoint: String): String? = withContext(Dispatchers.IO) {
        try {
            val url = "$baseUrl$endpoint"
            val request = Request.Builder()
                .url(url)
                .get()
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("GET $endpoint Error: ${e.message}")
            return@withContext null
        }
    }

    suspend fun post(endpoint: String, data: JSONObject): String? = withContext(Dispatchers.IO) {
        try {
            val url = "$baseUrl$endpoint"
            val mediaType = "application/json".toMediaType()
            val body = data.toString().toRequestBody(mediaType)

            val request = Request.Builder()
                .url(url)
                .post(body)
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("POST $endpoint Error: ${e.message}")
            return@withContext null
        }
    }

    suspend fun put(endpoint: String, data: JSONObject): String? = withContext(Dispatchers.IO) {
        try {
            val url = "$baseUrl$endpoint"
            val mediaType = "application/json".toMediaType()
            val body = data.toString().toRequestBody(mediaType)

            val request = Request.Builder()
                .url(url)
                .put(body)
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("PUT $endpoint Error: ${e.message}")
            return@withContext null
        }
    }

    suspend fun delete(endpoint: String): Boolean = withContext(Dispatchers.IO) {
        try {
            val url = "$baseUrl$endpoint"
            val request = Request.Builder()
                .url(url)
                .delete()
                .build()

            val response = client.newCall(request).execute()
            return@withContext response.isSuccessful
        } catch (e: Exception) {
            println("DELETE $endpoint Error: ${e.message}")
            return@withContext false
        }
    }
}

// Main demonstration
suspend fun demonstrateHTTPRequests(context: Context) {
    println("=== Android Kotlin HTTP Request Examples ===\n")

    // 1. HttpURLConnection examples
    println("--- 1. HttpURLConnection Examples ---")
    val httpExample = HttpURLConnectionExample(context)

    // Note: Replace with actual API endpoints for testing
    // val getResult = httpExample.simpleGetRequest("https://api.example.com/data")
    // println("GET Result: $getResult")

    // 2. OkHttp examples
    println("\n--- 2. OkHttp Examples ---")
    val okHttpExample = OkHttpExample(context)

    // val okHttpGet = okHttpExample.simpleGet("https://api.example.com/data")
    // println("OkHttp GET: $okHttpGet")

    // 3. Advanced operations
    println("\n--- 3. Advanced HTTP Operations ---")
    val advancedExample = AdvancedHttpExample(context)

    // 4. REST client
    println("\n--- 4. REST API Client ---")
    val restClient = RestClient("https://api.example.com", context)

    println("\n=== All HTTP Request Examples Completed ===")
}
CodekotlinIntermediate

File Download/Upload

Download and upload files with progress tracking, pause/resume functionality, and background task management

Difficulty

7/10

Estimated time

35 min

Tags

kotlin, android, networking, download, upload

Prerequisites

Intermediate Kotlin, Storage permissions

kotlin
// Android Kotlin File Download/Upload Examples
// Using DownloadManager, WorkManager, and OkHttp

import android.app.DownloadManager
import android.content.Context
import android.database.Cursor
import android.net.Uri
import android.os.Environment
import android.webkit.MimeTypeMap
import androidx.work.*
import kotlinx.coroutines.*
import okhttp3.*
import java.io.*
import java.net.HttpURLConnection
import java.net.URL

// 1. DownloadManager (System-managed downloads)
class SystemDownloadExample(private val context: Context) {

    private val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager

    // Simple download using DownloadManager
    fun downloadFile(url: String, title: String, description: String): Long {
        val request = DownloadManager.Request(Uri.parse(url)).apply {
            setTitle(title)
            setDescription(description)
            setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
            setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI or DownloadManager.Request.NETWORK_MOBILE)

            // Set destination
            val fileName = URL(url).file.substringAfterLast("/")
            val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
                fileName.substringAfterLast('.')
            )
            setMimeType(mimeType)

            // Save to external storage
            setDestinationInExternalFilesDir(
                context,
                Environment.DIRECTORY_DOWNLOADS,
                fileName
            )
        }

        return downloadManager.enqueue(request)
    }

    // Query download status
    fun getDownloadStatus(downloadId: Long): Int {
        val query = DownloadManager.Query().setFilterById(downloadId)
        val cursor: Cursor = downloadManager.query(query)

        var status = -1
        if (cursor.moveToFirst()) {
            status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
        }
        cursor.close()

        return status
    }

    // Get download progress
    fun getDownloadProgress(downloadId: Long): Int {
        val query = DownloadManager.Query().setFilterById(downloadId)
        val cursor: Cursor = downloadManager.query(query)

        var progress = 0
        if (cursor.moveToFirst()) {
            val bytesDownloaded = cursor.getInt(
                cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR)
            )
            val bytesTotal = cursor.getInt(
                cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES)
            )

            if (bytesTotal > 0) {
                progress = (bytesDownloaded * 100 / bytesTotal)
            }
        }
        cursor.close()

        return progress
    }

    // Cancel download
    fun cancelDownload(downloadId: Long) {
        downloadManager.remove(downloadId)
    }
}

// 2. Manual Download with Progress
class ManualDownloadExample(private val context: Context) {

    // Download file with progress callback
    suspend fun downloadFile(
        url: String,
        outputFile: File,
        onProgress: (bytesRead: Long, contentLength: Long) -> Unit
    ): Boolean = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(url)
            connection = urlObj.openConnection() as HttpURLConnection
            connection.connectTimeout = 10000
            connection.readTimeout = 10000
            connection.requestMethod = "GET"

            val responseCode = connection.responseCode
            if (responseCode != HttpURLConnection.HTTP_OK) {
                return@withContext false
            }

            val contentLength = connection.contentLengthLong
            val inputStream = connection.inputStream
            val outputStream = FileOutputStream(outputFile)

            val buffer = ByteArray(8192)
            var bytesRead: Int
            var totalBytesRead = 0L

            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                outputStream.write(buffer, 0, bytesRead)
                totalBytesRead += bytesRead

                onProgress(totalBytesRead, contentLength)
            }

            outputStream.flush()
            outputStream.close()
            inputStream.close()

            return@withContext true
        } catch (e: Exception) {
            println("Download Error: ${e.message}")
            return@withContext false
        } finally {
            connection?.disconnect()
        }
    }

    // Download with OkHttp
    private val okHttpClient = OkHttpClient()

    suspend fun downloadWithOkHttp(
        url: String,
        outputFile: File,
        onProgress: (bytesRead: Long, contentLength: Long) -> Unit
    ): Boolean = withContext(Dispatchers.IO) {
        try {
            val request = Request.Builder().url(url).build()
            val response = okHttpClient.newCall(request).execute()

            if (!response.isSuccessful) {
                return@withContext false
            }

            val inputStream = response.body?.byteStream() ?: return@withContext false
            val contentLength = response.body?.contentLength() ?: 0

            outputFile.outputStream().use { output ->
                val buffer = ByteArray(8192)
                var bytesRead: Int
                var totalBytesRead = 0L

                while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                    output.write(buffer, 0, bytesRead)
                    totalBytesRead += bytesRead

                    onProgress(totalBytesRead, contentLength)
                }
            }

            return@withContext true
        } catch (e: Exception) {
            println("OkHttp Download Error: ${e.message}")
            return@withContext false
        }
    }

    // Resumeable download
    data class DownloadState(
        val url: String,
        val outputFile: File,
        val downloadedBytes: Long = 0
    )

    suspend fun resumeableDownload(
        state: DownloadState,
        onProgress: (bytesRead: Long, contentLength: Long) -> Unit
    ): Boolean = withContext(Dispatchers.IO) {
        var connection: HttpURLConnection? = null
        try {
            val urlObj = URL(state.url)
            connection = urlObj.openConnection() as HttpURLConnection

            // Set range header for resume
            if (state.downloadedBytes > 0 && state.outputFile.exists()) {
                connection.setRequestProperty(
                    "Range",
                    "bytes=${state.downloadedBytes}-"
                )
            }

            connection.connectTimeout = 10000
            connection.readTimeout = 10000

            val responseCode = connection.responseCode
            if (responseCode !in listOf(HttpURLConnection.HTTP_OK, HttpURLConnection.HTTP_PARTIAL)) {
                return@withContext false
            }

            val contentLength = if (responseCode == HttpURLConnection.HTTP_PARTIAL) {
                connection.contentLength + state.downloadedBytes
            } else {
                state.downloadedBytes
            }

            val inputStream = connection.inputStream
            val outputStream = if (state.downloadedBytes > 0) {
                FileOutputStream(state.outputFile, true)
            } else {
                FileOutputStream(state.outputFile)
            }

            val buffer = ByteArray(8192)
            var bytesRead: Int
            var totalBytesRead = state.downloadedBytes

            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                outputStream.write(buffer, 0, bytesRead)
                totalBytesRead += bytesRead

                onProgress(totalBytesRead, contentLength)
            }

            outputStream.flush()
            outputStream.close()
            inputStream.close()

            return@withContext true
        } catch (e: Exception) {
            println("Resumeable Download Error: ${e.message}")
            return@withContext false
        } finally {
            connection?.disconnect()
        }
    }
}

// 3. File Upload
class FileUploadExample(private val context: Context) {

    private val client = OkHttpClient()

    // Upload single file
    suspend fun uploadFile(
        url: String,
        file: File,
        paramName: String = "file",
        additionalParams: Map<String, String> = emptyMap()
    ): String? = withContext(Dispatchers.IO) {
        try {
            val requestBody = MultipartBody.Builder()
                .setType(MultipartBody.FORM)

            // Add additional parameters
            additionalParams.forEach { (key, value) ->
                requestBody.addFormDataPart(key, value)
            }

            // Add file
            val mimeType = getMimeType(file)
            requestBody.addFormDataPart(
                paramName,
                file.name,
                file.asRequestBody(mimeType.toMediaTypeOrNull())
            )

            val request = Request.Builder()
                .url(url)
                .post(requestBody.build())
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("Upload Error: ${e.message}")
            return@withContext null
        }
    }

    // Upload multiple files
    suspend fun uploadMultipleFiles(
        url: String,
        files: List<File>,
        paramName: String = "files"
    ): String? = withContext(Dispatchers.IO) {
        try {
            val requestBody = MultipartBody.Builder()
                .setType(MultipartBody.FORM)

            files.forEach { file ->
                val mimeType = getMimeType(file)
                requestBody.addFormDataPart(
                    paramName,
                    file.name,
                    file.asRequestBody(mimeType.toMediaTypeOrNull())
                )
            }

            val request = Request.Builder()
                .url(url)
                .post(requestBody.build())
                .build()

            val response = client.newCall(request).execute()
            if (response.isSuccessful) {
                return@withContext response.body?.string()
            } else {
                return@withContext null
            }
        } catch (e: Exception) {
            println("Multiple Upload Error: ${e.message}")
            return@withContext null
        }
    }

    // Upload with progress
    suspend fun uploadFileWithProgress(
        url: String,
        file: File,
        paramName: String = "file",
        onProgress: (bytesWritten: Long, contentLength: Long) -> Unit
    ): Boolean = withContext(Dispatchers.IO) {
        try {
            // Create counting request body
            val countingRequestBody = object : RequestBody() {
                override fun contentType(): okhttp3.MediaType? {
                    return getMimeType(file).toMediaTypeOrNull()
                }

                override fun writeTo(sink: BufferedSink) {
                    val source = file.source().buffer()
                    val contentLength = file.length()
                    var bytesWritten = 0L

                    val buffer = ByteArray(8192)
                    var bytesRead: Int

                    while (source.read(buffer).also { bytesRead = it } != -1) {
                        sink.write(buffer, 0, bytesRead)
                        bytesWritten += bytesRead
                        onProgress(bytesWritten, contentLength)
                    }
                }

                override fun contentLength(): Long = file.length()
            }

            val requestBody = MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart(paramName, file.name, countingRequestBody)
                .build()

            val request = Request.Builder()
                .url(url)
                .post(requestBody)
                .build()

            val response = client.newCall(request).execute()
            return@withContext response.isSuccessful
        } catch (e: Exception) {
            println("Upload with Progress Error: ${e.message}")
            return@withContext false
        }
    }

    private fun getMimeType(file: File): String {
        val extension = file.extension.lowercase()
        return when (extension) {
            "jpg", "jpeg" -> "image/jpeg"
            "png" -> "image/png"
            "gif" -> "image/gif"
            "pdf" -> "application/pdf"
            "txt" -> "text/plain"
            "json" -> "application/json"
            "mp4" -> "video/mp4"
            "mp3" -> "audio/mpeg"
            else -> "application/octet-stream"
        }
    }
}

// 4. Background Upload with WorkManager
class UploadWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        val fileUrl = inputData.getString("fileUrl") ?: return Result.failure()
        val uploadUrl = inputData.getString("uploadUrl") ?: return Result.failure()

        val file = File(fileUrl)
        val uploader = FileUploadExample(applicationContext)

        val result = uploader.uploadFile(uploadUrl, file)

        return if (result != null) {
            Result.success(workDataOf("response" to result))
        } else {
            Result.failure()
        }
    }

    companion object {
        fun enqueueUpload(context: Context, file: File, uploadUrl: String): UUID {
            val data = workDataOf(
                "fileUrl" to file.absolutePath,
                "uploadUrl" to uploadUrl
            )

            val constraints = Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresBatteryNotLow(true)
                .build()

            val uploadRequest = OneTimeWorkRequestBuilder<UploadWorker>()
                .setConstraints(constraints)
                .setInputData(data)
                .build()

            WorkManager.getInstance(context).enqueue(uploadRequest)
            return uploadRequest.id
        }
    }
}

// Main demonstration
suspend fun demonstrateFileDownloadUpload(context: Context) {
    println("=== Android Kotlin File Download/Upload Examples ===\n")

    // 1. System download
    println("--- 1. System Download (DownloadManager) ---")
    val systemDownload = SystemDownloadExample(context)

    // Note: Replace with actual URL
    // val downloadId = systemDownload.downloadFile(
    //     url = "https://example.com/file.pdf",
    //     title = "File Download",
    //     description = "Downloading file..."
    // )

    // 2. Manual download with progress
    println("\n--- 2. Manual Download with Progress ---")
    val manualDownload = ManualDownloadExample(context)

    // val outputFile = File(context.getExternalFilesDir(null), "downloaded_file.pdf")
    // manualDownload.downloadFile(
    //     url = "https://example.com/file.pdf",
    //     outputFile = outputFile,
    //     onProgress = { bytesRead, totalBytes ->
    //         val progress = (bytesRead * 100 / totalBytes).toInt()
    //         println("Download progress: $progress%")
    //     }
    // )

    // 3. File upload
    println("\n--- 3. File Upload ---")
    val uploadExample = FileUploadExample(context)

    // val fileToUpload = File(context.filesDir, "upload.txt")
    // uploadExample.uploadFile(
    //     url = "https://example.com/upload",
    //     file = fileToUpload,
    //     additionalParams = mapOf("userId" to "123")
    // )

    println("\n=== All File Download/Upload Examples Completed ===")
}
CodekotlinIntermediate

WebSocket Connection

Establish WebSocket connections, send/receive messages, and handle connection lifecycle

Difficulty

7/10

Estimated time

30 min

Tags

kotlin, android, networking, websocket

Prerequisites

Intermediate Kotlin, OkHttp library

kotlin
// Android Kotlin WebSocket Examples
// Using OkHttp WebSocket and Java-WebSocket

import android.content.Context
import kotlinx.coroutines.*
import okhttp3.*
import okio.ByteString
import org.json.JSONObject
import java.util.concurrent.TimeUnit

// 1. Basic WebSocket with OkHttp
class BasicWebSocketExample(private val context: Context) {

    private val client = OkHttpClient.Builder()
        .readTimeout(0, TimeUnit.MILLISECONDS)
        .build()
    private var webSocket: WebSocket? = null

    // Connect to WebSocket
    fun connect(url: String) {
        val request = Request.Builder()
            .url(url)
            .build()

        val listener = object : WebSocketListener() {
            override fun onOpen(ws: WebSocket, response: Response) {
                println("WebSocket Connected")
                println("Server response: ${response.message}")

                // Send welcome message
                ws.send("Hello from Android!")
            }

            override fun onMessage(ws: WebSocket, text: String) {
                println("Received text: $text")
            }

            override fun onMessage(ws: WebSocket, bytes: ByteString) {
                println("Received bytes: ${bytes.hex()}")
            }

            override fun onClosing(ws: WebSocket, code: Int, reason: String) {
                println("Closing: $code $reason")
                ws.close(code, reason)
            }

            override fun onClosed(ws: WebSocket, code: Int, reason: String) {
                println("WebSocket Closed: $code $reason")
            }

            override fun onFailure(ws: WebSocket, t: Throwable, response: Response?) {
                println("WebSocket Error: ${t.message}")
            }
        }

        webSocket = client.newWebSocket(request, listener)
    }

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

    // Send JSON message
    fun sendJson(json: JSONObject) {
        webSocket?.send(json.toString())
    }

    // Send binary data
    fun sendBinary(data: ByteArray) {
        webSocket?.send(ByteString.of(*data))
    }

    // Close connection
    fun close() {
        webSocket?.close(1000, "Goodbye!")
        webSocket = null
    }
}

// 2. Advanced WebSocket with Reconnection
class AdvancedWebSocketExample(
    private val context: Context,
    private val url: String
) {
    private val client = OkHttpClient.Builder()
        .readTimeout(0, TimeUnit.MILLISECONDS)
        .build()

    private var webSocket: WebSocket? = null
    private var isConnected = false
    private var reconnectAttempts = 0
    private val maxReconnectAttempts = 5
    private val reconnectDelay = 3000L // 3 seconds

    private val messageQueue = mutableListOf<String>()

    // Message callback interface
    interface WebSocketCallback {
        fun onConnected()
        fun onMessage(text: String)
        fun onMessage(bytes: ByteString)
        fun onDisconnected()
        fun onError(error: String)
    }

    private var callback: WebSocketCallback? = null

    fun setCallback(cb: WebSocketCallback) {
        this.callback = cb
    }

    // Connect with auto-reconnect
    fun connect() {
        val request = Request.Builder()
            .url(url)
            .addHeader("Origin", context.packageName)
            .build()

        val listener = object : WebSocketListener() {
            override fun onOpen(ws: WebSocket, response: Response) {
                println("WebSocket Connected")
                isConnected = true
                reconnectAttempts = 0

                callback?.onConnected()

                // Send queued messages
                synchronized(messageQueue) {
                    messageQueue.forEach { message ->
                        ws.send(message)
                    }
                    messageQueue.clear()
                }
            }

            override fun onMessage(ws: WebSocket, text: String) {
                println("Received: $text")
                callback?.onMessage(text)
            }

            override fun onMessage(ws: WebSocket, bytes: ByteString) {
                println("Received bytes: ${bytes.hex()}")
                callback?.onMessage(bytes)
            }

            override fun onClosing(ws: WebSocket, code: Int, reason: String) {
                println("Closing: $code $reason")
            }

            override fun onClosed(ws: WebSocket, code: Int, reason: String) {
                println("WebSocket Closed: $code $reason")
                isConnected = false
                callback?.onDisconnected()

                // Attempt reconnection
                attemptReconnect()
            }

            override fun onFailure(ws: WebSocket, t: Throwable, response: Response?) {
                println("WebSocket Error: ${t.message}")
                isConnected = false
                callback?.onError(t.message ?: "Unknown error")

                // Attempt reconnection
                attemptReconnect()
            }
        }

        webSocket = client.newWebSocket(request, listener)
    }

    // Attempt reconnection
    private fun attemptReconnect() {
        if (reconnectAttempts < maxReconnectAttempts) {
            reconnectAttempts++

            CoroutineScope(Dispatchers.IO).launch {
                delay(reconnectDelay)
                println("Reconnecting... Attempt $reconnectAttempts")
                connect()
            }
        } else {
            println("Max reconnection attempts reached")
        }
    }

    // Send message with queueing
    fun sendMessage(message: String) {
        if (isConnected) {
            webSocket?.send(message)
        } else {
            // Queue message for later
            synchronized(messageQueue) {
                messageQueue.add(message)
            }
            println("Message queued: $message")
        }
    }

    // Close connection
    fun close() {
        reconnectAttempts = maxReconnectAttempts // Stop reconnection
        webSocket?.close(1000, "User closing")
        webSocket = null
        isConnected = false
    }
}

// 3. WebSocket Chat Example
class ChatWebSocket(private val context: Context) {

    private val client = OkHttpClient.Builder()
        .readTimeout(0, TimeUnit.MILLISECONDS)
        .build()

    private var webSocket: WebSocket? = null

    data class ChatMessage(
        val type: String, // "join", "message", "leave"
        val username: String,
        val content: String,
        val timestamp: Long = System.currentTimeMillis()
    )

    interface ChatCallback {
        fun onMessage(message: ChatMessage)
        fun onUserJoined(username: String)
        fun onUserLeft(username: String)
        fun onConnectionStatus(connected: Boolean)
    }

    private var callback: ChatCallback? = null

    fun setCallback(cb: ChatCallback) {
        this.callback = cb
    }

    // Connect to chat server
    fun connect(serverUrl: String, username: String) {
        val request = Request.Builder()
            .url(serverUrl)
            .build()

        val listener = object : WebSocketListener() {
            override fun onOpen(ws: WebSocket, response: Response) {
                println("Chat Connected as: $username")
                callback?.onConnectionStatus(true)

                // Send join message
                val joinMessage = ChatMessage(
                    type = "join",
                    username = username,
                    content = ""
                )
                ws.send(toJson(joinMessage))
            }

            override fun onMessage(ws: WebSocket, text: String) {
                val message = fromJson(text)
                message?.let {
                    when (it.type) {
                        "join" -> callback?.onUserJoined(it.username)
                        "leave" -> callback?.onUserLeft(it.username)
                        "message" -> callback?.onMessage(it)
                    }
                }
            }

            override fun onClosed(ws: WebSocket, code: Int, reason: String) {
                println("Chat Closed")
                callback?.onConnectionStatus(false)
            }

            override fun onFailure(ws: WebSocket, t: Throwable, response: Response?) {
                println("Chat Error: ${t.message}")
                callback?.onConnectionStatus(false)
            }
        }

        webSocket = client.newWebSocket(request, listener)
    }

    // Send chat message
    fun sendMessage(username: String, content: String) {
        val message = ChatMessage(
            type = "message",
            username = username,
            content = content
        )
        webSocket?.send(toJson(message))
    }

    // Leave chat
    fun leave(username: String) {
        val leaveMessage = ChatMessage(
            type = "leave",
            username = username,
            content = ""
        )
        webSocket?.send(toJson(leaveMessage))

        // Close connection
        webSocket?.close(1000, "User leaving")
        webSocket = null
    }

    private fun toJson(message: ChatMessage): String {
        val json = JSONObject()
        json.put("type", message.type)
        json.put("username", message.username)
        json.put("content", message.content)
        json.put("timestamp", message.timestamp)
        return json.toString()
    }

    private fun fromJson(json: String): ChatMessage? {
        return try {
            val obj = JSONObject(json)
            ChatMessage(
                type = obj.optString("type"),
                username = obj.optString("username"),
                content = obj.optString("content"),
                timestamp = obj.optLong("timestamp", System.currentTimeMillis())
            )
        } catch (e: Exception) {
            null
        }
    }
}

// 4. WebSocket Heartbeat/Ping
class HeartbeatWebSocket(
    private val context: Context,
    private val url: String
) {
    private val client = OkHttpClient.Builder()
        .readTimeout(0, TimeUnit.MILLISECONDS)
        .pingInterval(30, TimeUnit.SECONDS) // Send ping every 30 seconds
        .build()

    private var webSocket: WebSocket? = null
    private var heartbeatJob: Job? = null

    // Connect with heartbeat
    fun connect() {
        val request = Request.Builder()
            .url(url)
            .build()

        val listener = object : WebSocketListener() {
            override fun onOpen(ws: WebSocket, response: Response) {
                println("Heartbeat WebSocket Connected")
                startHeartbeat(ws)
            }

            override fun onMessage(ws: WebSocket, text: String) {
                println("Received: $text")
            }

            override fun onClosing(ws: WebSocket, code: Int, reason: String) {
                stopHeartbeat()
            }

            override fun onClosed(ws: WebSocket, code: Int, reason: String) {
                stopHeartbeat()
            }

            override fun onFailure(ws: WebSocket, t: Throwable, response: Response?) {
                stopHeartbeat()
            }
        }

        webSocket = client.newWebSocket(request, listener)
    }

    // Start heartbeat
    private fun startHeartbeat(ws: WebSocket) {
        heartbeatJob = CoroutineScope(Dispatchers.IO).launch {
            while (isActive) {
                delay(15000) // Send custom heartbeat every 15 seconds
                val heartbeat = JSONObject().apply {
                    put("type", "heartbeat")
                    put("timestamp", System.currentTimeMillis())
                }
                ws.send(heartbeat.toString())
                println("Heartbeat sent")
            }
        }
    }

    // Stop heartbeat
    private fun stopHeartbeat() {
        heartbeatJob?.cancel()
        heartbeatJob = null
    }

    // Close connection
    fun close() {
        stopHeartbeat()
        webSocket?.close(1000, "Closing")
        webSocket = null
    }
}

// 5. WebSocket Manager (Singleton)
class WebSocketManager private constructor(private val context: Context) {

    companion object {
        @Volatile
        private var instance: WebSocketManager? = null

        fun getInstance(context: Context): WebSocketManager {
            return instance ?: synchronized(this) {
                instance ?: WebSocketManager(context.applicationContext).also { instance = it }
            }
        }
    }

    private val connections = mutableMapOf<String, WebSocket>()

    data class WebSocketConfig(
        val url: String,
        val key: String = url,
        val autoReconnect: Boolean = true,
        val reconnectDelay: Long = 3000L
    )

    // Connect with config
    fun connect(config: WebSocketConfig, listener: WebSocketListener) {
        val client = OkHttpClient.Builder()
            .readTimeout(0, TimeUnit.MILLISECONDS)
            .build()

        val request = Request.Builder()
            .url(config.url)
            .build()

        val ws = client.newWebSocket(request, listener)
        connections[config.key] = ws
    }

    // Send message
    fun send(key: String, message: String) {
        connections[key]?.send(message)
    }

    // Close specific connection
    fun close(key: String) {
        connections[key]?.close(1000, "Closing")
        connections.remove(key)
    }

    // Close all connections
    fun closeAll() {
        connections.values.forEach { it.close(1000, "Closing all") }
        connections.clear()
    }
}

// Main demonstration
fun demonstrateWebSocket(context: Context) {
    println("=== Android Kotlin WebSocket Examples ===\n")

    // 1. Basic WebSocket
    println("--- 1. Basic WebSocket ---")
    val basicWs = BasicWebSocketExample(context)
    // basicWs.connect("wss://echo.websocket.org")
    // basicWs.sendMessage("Hello WebSocket!")

    // 2. Advanced WebSocket with reconnection
    println("\n--- 2. Advanced WebSocket with Reconnection ---")
    val advancedWs = AdvancedWebSocketExample(context, "wss://echo.websocket.org")
    // advancedWs.setCallback(object : AdvancedWebSocketExample.WebSocketCallback {
    //     override fun onConnected() { println("Connected!") }
    //     override fun onMessage(text: String) { println("Message: $text") }
    //     override fun onMessage(bytes: ByteString) { println("Bytes received") }
    //     override fun onDisconnected() { println("Disconnected") }
    //     override fun onError(error: String) { println("Error: $error") }
    // })
    // advancedWs.connect()

    // 3. Chat WebSocket
    println("\n--- 3. Chat WebSocket ---")
    val chatWs = ChatWebSocket(context)
    // chatWs.connect("wss://chat.example.com", "User123")
    // chatWs.sendMessage("User123", "Hello everyone!")

    // 4. WebSocket Manager
    println("\n--- 4. WebSocket Manager ---")
    val wsManager = WebSocketManager.getInstance(context)
    // wsManager.connect(
    //     WebSocketManager.WebSocketConfig("wss://echo.websocket.org"),
    //     listener
    // )

    println("\n=== All WebSocket Examples Completed ===")
}

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Self-Hosted Giveaway Widget Review and Embed Handoff

Review giveaway configuration, merchant response samples, contrast and responsive layouts, then hand off identified widget files with browser acceptance evidence.

Hub

JSON to Typed Code Generators

Generate typed models from JSON or schema evidence for TypeScript, Go, Rust, Kotlin, Java, C#, and Zod validation workflows.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Development

JSON to Kotlin Data Class Converter

Convert JSON data into Kotlin data classes with @SerializedName annotations, nullable handling, and nested type inference

Design

Figma iOS Android pt dp sp Responsive Design Spec Card

Convert a Figma px value into iOS pt, Android dp/sp, web rem/vw with a fluid clamp() snippet, a density-bucket render table and a touch-target accessibility audit, as a developer spec card.

Development

API Request Code Snippet Generator

Generate cURL and common language code snippets from a request URL, method, headers, query parameters, and body

Development

HTTP Headers Analyzer

Analyze HTTP headers, security configurations, and response information

Kotlin

Android Web Features Kotlin Samples

Android Kotlin web-specific examples including URL routing, middleware handling, and static file serving

Kotlin

Android Mobile Features Kotlin Samples

Android Kotlin mobile-specific examples including device information, network status, and vibration control

Java

Android Networking Java Samples

Android Java networking examples including HTTP requests, file download/upload, and WebSocket connections

Java

Android Web Features Java Samples

Android Java web features including HTTP requests, URL handling, and web view integration

Python

Web Networking Python Samples

Web Python networking examples including HTTP requests, HTTP server, and TCP socket programming

TypeScript

Web Networking TypeScript Samples

Web TypeScript networking examples including HTTP requests, WebSocket connections, and API communication