Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Kotlin

Ejemplos de Programación de Red Android Kotlin

Ejemplos de programación de red Android Kotlin incluyendo solicitudes HTTP, descarga/subida de archivos y conexiones WebSocket

Ejemplos

Entradas de esta colección

CódigokotlinSimple

Solicitudes HTTP

Enviar solicitudes GET y POST usando HttpURLConnection y biblioteca OkHttp con manejo de errores apropiado

Dificultad

6/10

Tiempo estimado

30 min

Etiquetas

kotlin, android, networking, http

Requisitos previos

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 ===")
}
CódigokotlinIntermedio

Descarga/Subida de Archivos

Descargar y subir archivos con seguimiento de progreso, funcionalidad de pausa/reanudación y gestión de tareas en segundo plano

Dificultad

7/10

Tiempo estimado

35 min

Etiquetas

kotlin, android, networking, download, upload

Requisitos previos

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 ===")
}
CódigokotlinIntermedio

Conexión WebSocket

Establecer conexiones WebSocket, enviar/recibir mensajes y manejar el ciclo de vida de la conexión

Dificultad

7/10

Tiempo estimado

30 min

Etiquetas

kotlin, android, networking, websocket

Requisitos previos

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 ===")
}

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Deteccion de PII y revision de redaccion de logs

Detecta datos personales probables en logs, texto y PDF, redacta copias candidatas, valida patrones y exige aprobacion humana antes de compartir.

Tema

Relleno de bordes, reducción de ruido y enfoque final de imágenes

Prepara una imagen para una proporción fija sin alterar la composición principal: conserva el original, añade bordes controlados, reduce el ruido con moderación y enfoca solo al tamaño de entrega.

Tema

Limpieza de imagen, redimensionado y mejora de detalle

Prepara imágenes revisadas corrigiendo orientación, recortando bordes, reduciendo ruido, redimensionando con precisión y recuperando nitidez.

Tema

Calculadoras de ecologia de poblaciones, biodiversidad y redes troficas

Explora modelos educativos de crecimiento poblacional, capacidad de carga, interacciones, biodiversidad muestreada y transferencia de energia trofica.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Development

JSON a Kotlin Data Class

Convierte datos JSON en data classes de Kotlin con anotaciones @SerializedName, manejo de nulos e inferencia de tipos anidados

Design

Tarjeta de especificación responsive Figma iOS Android pt dp sp

Convierte valores px de Figma a las unidades correctas por plataforma y genera una spec card para desarrolladores: pt de iOS (@1x/@2x/@3x con px renderizado por escala), dp/sp de Android (tabla de renderizado mdpi…xxxhdpi y escala de fuente), rem/vw web con snippet clamp() fluido; audita objetivos táctiles mínimos (44pt iOS / 48dp Android / 44px y 24px WCAG) y anota clases de ventana de Material y breakpoints de Tailwind.

Development

Generador de Snippets de Solicitudes API

Genera cURL y snippets de lenguajes comunes a partir de una URL, metodo, headers, query y body

Development

Analizador de Encabezados HTTP

Analiza encabezados HTTP, configuraciones de seguridad e información de respuesta

Kotlin

Ejemplos de Funciones Web Android Kotlin

Ejemplos de funciones web Android Kotlin incluyendo enrutamiento URL, manejo de middleware y servicio de archivos estáticos

Kotlin

Ejemplos de Funciones Móviles Android Kotlin

Ejemplos de funciones móviles Android Kotlin incluyendo información del dispositivo, estado de la red y control de vibración

Java

Ejemplos de Programación de Red Android Java

Ejemplos de programación de red Android Java incluyendo solicitudes HTTP, descarga/subida de archivos y conexiones WebSocket

Java

Ejemplos de Características Web Android Java

Ejemplos de características web Android Java incluyendo solicitudes HTTP, manejo de URL e integración WebView

Python

Ejemplos de Red Web Python

Ejemplos de red Web Python incluyendo solicitudes HTTP, servidor HTTP y programación de sockets TCP

TypeScript

Ejemplos de Red Web TypeScript

Ejemplos de red Web TypeScript incluyendo solicitudes HTTP, conexiones WebSocket y comunicación API