android kotlin okhttp3 下载文件 并带下载进度

### 回答1：
在 Android Kotlin 中使用 OkHttp3 下载文件并带有下载进度，可以通过以下步骤实现：

1. 添加 OkHttp3 依赖

在 app module 的 build.gradle 文件中添加以下代码：

dependencies {
    implementation 'com.squareup.okhttp3:okhttp:4.9.0'
}

2. 创建 OkHttp3 客户端

在代码中创建一个 OkHttpClient 客户端：

val client = OkHttpClient()

3. 创建下载请求

使用 OkHttp3 的 Request.Builder 创建一个下载请求，并设置下载 URL 和保存文件的路径：

val request = Request.Builder()
    .url("https://example.com/file.zip")
    .build()

4. 创建下载监听器

定义一个回调接口，用于监听下载进度：

interface DownloadListener {
    fun onDownloadProgress(progress: Int)
}

在代码中实现这个接口，并在其中更新下载进度，例如：

val listener = object : DownloadListener {
    override fun onDownloadProgress(progress: Int) {
        runOnUiThread {
            // 更新下载进度条
            progressBar.progress = progress
        }
    }
}

5. 发起下载请求

使用 OkHttpClient 的 newCall 方法发起下载请求，并在 enqueue 方法中传入一个 Callback 参数，该参数将在下载完成时回调：

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        // 下载失败
    }

    override fun onResponse(call: Call, response: Response) {
        val inputStream: InputStream = response.body?.byteStream() ?: return

        // 保存文件并更新下载进度
        val totalSize: Long = response.body?.contentLength() ?: -1
        var downloadedSize: Long = 0
        val outputStream = FileOutputStream("/storage/emulated/0/Download/file.zip")
        val buffer = ByteArray(8192)

        while (true) {
            val bytes = inputStream.read(buffer)
            if (bytes == -1) break

            outputStream.write(buffer, 0, bytes)
            downloadedSize += bytes

            val progress = (downloadedSize * 100 / totalSize).toInt()
            listener.onDownloadProgress(progress)
        }

        outputStream.close()
        inputStream.close()

        // 下载完成
    }
})

这段代码中，我们首先从 response.body 中获取输入流并创建输出流，然后使用循环逐段读取输入流的数据，再将其写入输出流，并计算下载进度，最后调用 DownloadListener 的 onDownloadProgress 方法更新下载进度。在下载完成后，我们需要关闭输入流和输出流，以及在 onFailure 方法中处理下载失败的情况。

6. 完整代码

最终的代码应该类似于这样：

interface DownloadListener {
    fun onDownloadProgress(progress: Int)
}

val client = OkHttpClient()
val request = Request.Builder()
    .url("https://example.com/file.zip")
    .build()

val listener = object : DownloadListener {
    override fun onDownloadProgress(progress: Int) {
        runOnUiThread {
            // 更新下载进度条
            progressBar.progress = progress
        }
    }
}

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        // 下载失败
    }

    override fun onResponse(call: Call, response: Response) {
        val inputStream: InputStream = response.body?.byteStream() ?: return

        // 保存文件并更新下载进度
        val totalSize: Long = response.body?.contentLength() ?: -1
        var downloadedSize: Long = 0
        val outputStream = FileOutputStream("/storage/emulated/0/Download/file.zip")
        val buffer = ByteArray(8192)

        while (true) {
            val bytes = inputStream.read(buffer)
            if (bytes == -1) break

            outputStream.write(buffer, 0, bytes)
            downloadedSize += bytes

            val progress = (downloadedSize * 100 / totalSize).toInt()
            listener.onDownloadProgress(progress)
        }

        outputStream.close()
        inputStream.close()

        // 下载完成
    }
})

注意，这段代码中保存文件的路径是硬编码的，你需要根据实际需求修改它。另外，为了更新 UI，我们需要在 onDownloadProgress 方法中使用 runOnUiThread 方法，以确保在主线程中执行。

### 回答2：
在Android中使用Kotlin和OkHttp3下载文件并显示下载进度，可以按照以下步骤进行操作：

首先，确保已在项目的build.gradle文件中添加以下依赖项：

implementation 'com.squareup.okhttp3:okhttp:4.10.0'
implementation 'com.squareup.okhttp3:okhttp-urlconnection:4.10.0'

接下来，创建一个下载文件的函数：

fun downloadFile(url: String, saveFilePath: String) {
    val client = OkHttpClient.Builder()
        .addNetworkInterceptor { chain ->
            val originalResponse = chain.proceed(chain.request())
            val responseBody = originalResponse.body()
            if (responseBody != null) {
                originalResponse.newBuilder()
                    .body(DownloadProgressResponseBody(responseBody, object : DownloadProgressListener {
                        override fun update(progress: Int) {
                            // 在这里更新下载进度
                            Log.d("DownloadProgress", "Progress: $progress%")
                        }
                    }))
                    .build()
            } else {
                originalResponse
            }
        }
        .build()
    
    val request = Request.Builder()
        .url(url)
        .build()
    
    val response = client.newCall(request).execute()
    response?.body()?.byteStream()?.use { input ->
        File(saveFilePath).outputStream().use { output ->
            input.copyTo(output)
        }
    }
}

接下来，创建一个自定义的ResponseBody类来监听下载进度：

interface DownloadProgressListener {
    fun update(progress: Int)
}

class DownloadProgressResponseBody(private val responseBody: ResponseBody, private val listener: DownloadProgressListener) :
    ResponseBody() {

    private var bufferedSource: BufferedSource? = null

    override fun contentType(): MediaType? = responseBody.contentType()

    override fun contentLength(): Long = responseBody.contentLength()

    override fun source(): BufferedSource {
        if (bufferedSource == null) {
            bufferedSource = responseBody.source()
                .buffer()
                .let { source ->
                    ForwardingSource(source).apply {
                        addTransferListener(object : ForwardingSource.TransferListener {
                            var totalBytesRead = 0L

                            override fun onTransferStarted(source: ForwardingSource?, transferredBytes: Long, totalBytes: Long) {
                                totalBytesRead = 0L
                            }

                            override fun onBytesTransferred(source: ForwardingSource?, transferredBytes: Long) {
                                totalBytesRead += transferredBytes
                                val progress = (totalBytesRead * 100 / responseBody.contentLength()).toInt()
                                listener.update(progress)
                            }

                            override fun onTransferEnd(source: ForwardingSource?) {
                                listener.update(100)
                            }
                        })
                    }
                }
        }
        return bufferedSource!!
    }
}

最后，你可以在你的活动或片段中调用这个下载函数来下载文件：

val url = "http://example.com/file.mp3"
val saveFilePath = "<保存文件的路径>"

downloadFile(url, saveFilePath)

这样，你就可以使用Android Kotlin和OkHttp3下载文件并显示下载进度了。

### 回答3：
在Android中使用Kotlin编程语言通过OkHttp3下载文件并带有下载进度可通过以下步骤实现：

1. 添加OkHttp3依赖库到项目的build.gradle文件中：

dependencies {
    implementation 'com.squareup.okhttp3:okhttp:版本号'
}

2. 在需要下载文件的地方，创建一个OkHttpClient实例并设置进度监听器：

val client = OkHttpClient.Builder()
    .addNetworkInterceptor { chain ->
        val originalResponse = chain.proceed(chain.request())
        originalResponse.newBuilder()
            .body(ProgressResponseBody(originalResponse.body()!!, object : ProgressListener {
                override fun update(bytesRead: Long, contentLength: Long, done: Boolean) {
                    val progress = (100 * bytesRead / contentLength).toInt()
                    //更新下载进度
                }
            }))
            .build()
    }
    .build()

3. 创建一个自定义的ResponseBody类ProgressResponseBody，实现进度监听功能：

class ProgressResponseBody(
    private val responseBody: ResponseBody,
    private val progressListener: ProgressListener
) : ResponseBody() {

    private var bufferedSource: BufferedSource? = null

    override fun contentType(): MediaType? {
        return responseBody.contentType()
    }

    override fun contentLength(): Long {
        return responseBody.contentLength()
    }

    override fun source(): BufferedSource {
        if (bufferedSource == null) {
            bufferedSource = source(responseBody.source()).buffer()
        }
        return bufferedSource as BufferedSource
    }

    private fun source(source: Source): Source {
        return object : ForwardingSource(source) {
            var totalBytesRead = 0L

            override fun read(sink: Buffer, byteCount: Long): Long {
                val bytesRead = super.read(sink, byteCount)
                totalBytesRead += if (bytesRead != -1L) bytesRead else 0L
                progressListener.update(
                    totalBytesRead,
                    responseBody.contentLength(),
                    bytesRead == -1L
                )
                return bytesRead
            }
        }
    }
}

4. 创建一个ProgressListener接口，用于更新下载进度：

interface ProgressListener {
    fun update(bytesRead: Long, contentLength: Long, done: Boolean)
}

5. 使用OkHttpClient发送下载请求并进行文件下载：

val request = Request.Builder()
    .url("文件下载链接")
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        //下载失败处理
    }

    override fun onResponse(call: Call, response: Response) {
        val inputStream = response.body()?.byteStream()
        val file = File(Environment.getExternalStorageDirectory(), "下载文件名")
        val outputStream = FileOutputStream(file)

        val buffer = ByteArray(4096)
        var readCount: Int
        var totalRead = 0L

        while (inputStream?.read(buffer).also { readCount = it ?: -1 } != -1) {
            outputStream.write(buffer, 0, readCount)
            totalRead += readCount
            //更新下载进度
            val progress = (100 * totalRead / response.body()?.contentLength()!!).toInt()
        }

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

        //下载完成处理
    }
})

通过以上步骤，我们可以在Android使用Kotlin和OkHttp3下载文件，并在下载过程中实时更新下载进度。