Compose Multiplatform+kotlin Multiplatfrom第三弹

宝杰X72024-09-14 9:26

前言

上篇文章kmp实战2很多通用业务功能，这篇续着发布队列文件断点下载保存到本地。

kotlin 复制代码 
package com.your.pkName.utils

import com.benasher44.uuid.uuid4
import io.ktor.client.call.body
import io.ktor.client.request.headers
import io.ktor.client.request.prepareGet
import io.ktor.client.utils.DEFAULT_HTTP_BUFFER_SIZE
import io.ktor.http.ContentType
import io.ktor.http.HttpHeaders
import io.ktor.http.contentLength
import io.ktor.http.contentType
import io.ktor.utils.io.ByteReadChannel
import io.ktor.utils.io.core.isEmpty
import io.ktor.utils.io.core.readBytes
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.CoroutineStart
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.IO
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch
import kotlinx.datetime.Clock
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import okio.SYSTEM
import okio.buffer
import okio.use
import kotlin.concurrent.Volatile

/**
 * @author by jason-何伟杰，2024/6/17
 * des:队列下载管理
 */
data class DownloadTask(
    val url: String,
    val savePath: String? = null,
    val progress: ProgressListener,//进度、速度，进度由于1024换算大概率重复
    val callback: (Boolean, String, String?) -> Unit //是否成功，suc-路径，fail-日志
) : Comparable<DownloadTask> {
    var job: Job? = null

    var id = uuid4().toString() //唯一id
    val timestamp: Long = Clock.System.now().toEpochMilliseconds()

    @Volatile
    var state: TaskState = TaskState.Pending

    //比较优先级
    override fun compareTo(other: DownloadTask): Int {
        return (timestamp - other.timestamp).toInt()
    }

    //临时地址转换？ .tmp
    override fun toString(): String {
        return "{$url ,$savePath ,$job}"
    }
}

sealed class TaskState {
    object Pending : TaskState()
    object Downloading : TaskState()
    object Paused : TaskState()
    object Completed : TaskState()
    data class Failed(val msg: String?) : TaskState()
}

object DownloadApi {
    private val downloadQueue: MutableSet<DownloadTask> = HashSet()
    private val client = createHttpClient(null) //用平台引擎的特性客户端才可以下https
    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private var lastProgressTimestamp: Long = 0
    private const val progressInterval: Long = 1600

    private fun tempFile(task: DownloadTask): String {
        //临时文件夹都是FileSystem,不是平台特性，无法直接下载到下载目录下，后续优化
//        return "${GlobalCode.getFileCacheDir()}/${GlobalCode.subFormatUrl(task.url)}.tmp"
        return GlobalCode.getGlobalDCIMPath(task.url, isCopy = true) + "/${
            GlobalCode.setUniqueFileName(
                GlobalCode.subFormatUrl(
                    task.url
                ), GlobalCode.getGlobalDCIMPath(task.url, isCopy = true)
            )
        }.tmp"
    }

    /**添加一个新任务并开始*/
    fun addTask(task: DownloadTask) {
        downloadQueue.add(task)
        processNext()
    }

    /**添加新任务队列并开始*/
    fun startTaskList(taskList: List<DownloadTask>) {
        if (!taskList.isNullOrEmpty()) {
            downloadQueue.addAll(taskList)
            processNext()
        }
    }

    /**打印存在的任务队列*/
    fun printTaskList() {
        if (downloadQueue.size == 0) {
            printLogW("downloadQueue>isEmpty")
        }
        downloadQueue.forEach { task ->
            printLogW("task>$task")
        }
    }

    /**开启任务*/
    fun startTask(task: DownloadTask?) {
//        if (task?.job == null || task.job?.isCompleted == true) {
        if (task?.job == null || task.state != TaskState.Completed) {
            task?.let {
                task.job = createDownloadJob(task)
            }
            task?.job?.start()
        }
    }

    /**重新开始任务队列*/
    fun reStartQueueTask() {
        processNext()
    }

    /**根据id查询任务实体对象*/
    fun queryTask(taskId: String): DownloadTask? {
        for (request in downloadQueue) {
            if (request.id == taskId) {
                return request
            }
        }
        return null
    }

    fun queryTaskByUrl(url: String): DownloadTask? {
        for (request in downloadQueue) {
            if (request.url == url) {
                return request
            }
        }
        return null
    }

    fun pauseTask(task: DownloadTask?) {
        task?.state = TaskState.Paused
        task?.job?.cancel()
    }

    //按照id控制比较好
    fun pauseTask(taskId: String) {
        pauseTask(queryTask(taskId))
    }

    fun pauseTaskByUrl(url: String) {
        pauseTask(queryTaskByUrl(url))
    }

    fun stopAllDownload() {
        downloadQueue.forEach {
            pauseTask(it)
        }
    }

    fun resumeTask(task: DownloadTask?) {
        downloadQueue.forEach { task ->
            if (task.state == TaskState.Downloading) {
                task.state = TaskState.Paused
                task.job?.cancel() //内部嵌套的job,要注意下有无问题
            } else if (task.state == TaskState.Completed) {
                task.state = TaskState.Completed
            } else {
                task.state = TaskState.Pending
            }
        }
        task?.state = TaskState.Downloading
        startTask(task)
    }

    fun resumeTask(taskId: String) {
        resumeTask(queryTask(taskId))
    }

    fun deleteTask(taskId: String) {
        queryTask(taskId)?.let {
            it.state = TaskState.Paused
            it.job?.cancel()
            downloadQueue.remove(it)
        }
    }

    fun clearTask() {
        downloadQueue.forEach {
            it.state = TaskState.Paused
            it.job?.cancel()
        }
        downloadQueue.clear()
    }

    //这里是每次轮询任务的逻辑
    private fun processNext() {
        val task = downloadQueue.firstOrNull() { it.job == null || it.state != TaskState.Completed }
//        printLogW("task>$task ${task?.job} ${task?.job?.isCompleted}")
        task?.let { startTask(it) }
    }

    private fun createDownloadJob(task: DownloadTask): Job {
        return scope.launch(start = CoroutineStart.LAZY, context = Dispatchers.IO) {
            try {
                if (task.url.isEmpty()) {
                    throw Exception("cannot download null url")
                } else {
                    //优先创建缓存目录，不然报错
                    createPlatformRootDir()
                    //构建文件路径
                    var tmpFile: Path
                    if (task.savePath.isNullOrEmpty()) {
                        tmpFile = tempFile(task).toPath()
                    } else {
                        tmpFile = (task.savePath + ".tmp").toPath()
                    }
                    printLogW("file>$tmpFile") //应该用临时格式后缀，最后再转
                    createPlatformFile(tmpFile.toString())
                    task.state = TaskState.Downloading
                    val existLength = FileSystem.SYSTEM.metadataOrNull(tmpFile)?.size
                    var sumBytes: Long = 0
                    var startSize: Long = existLength ?: 0 //计算速度
                    lastProgressTimestamp = Clock.System.now().toEpochMilliseconds()
                    client.prepareGet(task.url) {
                        headers {
                            getCacheStr(KmmConfig.DATA_SINGLE_COOKIE)?.let {
                                append("Cookie", it)
                            }
                            existLength?.let {//断点下载剩下的全部
                                if (existLength != 0L)
                                    append(HttpHeaders.Range, "bytes=$existLength-")
                            }
                        }
                        contentType(ContentType.Any)
//                        timeout {  //不设置会更好不
//                            requestTimeoutMillis = 30 * 1000
//                            connectTimeoutMillis = 300 * 1000  //下载大文件超时会报错 600
//                        }
                    }.execute { httpResponse ->
                        val channel: ByteReadChannel = httpResponse.body()
                        if (httpResponse.contentLength() == null || httpResponse.contentLength() == 0L) {
                            (GlobalCode.getOneParameter(task.url, "sum"))?.let {
                                sumBytes = (it.toDouble() * 1024).toLong()
                            }
                        }
                        var pp = 0
                        FileSystem.SYSTEM.appendingSink(tmpFile, true).buffer().use { sink ->
                            while (!channel.isClosedForRead && task.state != TaskState.Paused) {//!task.isPaused
                                val packet =
                                    channel.readRemaining(DEFAULT_HTTP_BUFFER_SIZE.toLong())
                                //捕抓网络突然中断的问题
                                if (packet.isEmpty) {
                                    updateFailed(task, "channel packet isEmpty")
                                    return@use
                                }
                                while (!packet.isEmpty) {
                                    val bytes = packet.readBytes()
                                    sink.write(bytes)
                                    val now = Clock.System.now().toEpochMilliseconds()
                                    if ((now - lastProgressTimestamp) < progressInterval) {

                                    } else {
                                        //计算速度
                                        var speed = 0
                                        val deltaTime = (now - lastProgressTimestamp + 1).toInt()

                                        FileSystem.SYSTEM.metadataOrNull(tmpFile)?.size?.let { size ->
                                            speed =
                                                ((size - startSize) * 1000 / deltaTime).toInt()
                                            startSize = size
//                                            printLogW("speed>$speed")
                                        }
                                        lastProgressTimestamp = now
                                        //获取进度
                                        if ((httpResponse.contentLength() == null || httpResponse.contentLength() == 0L)
                                            && sumBytes != 0L
                                        ) {
                                            //用流下载是无法提前知道文件总长度
//                                    printLogD("total>${channel.totalBytesRead} ")
                                            var tp = 0L
                                            FileSystem.SYSTEM.metadataOrNull(tmpFile)?.size?.let { l ->
                                                tp = l
                                            }
//                                            printLogW("onprogress1>")
                                            task.progress.onProgress(
                                                (tp * 100 / sumBytes).toInt()
                                                    .apply { pp = this },
                                                speed = speed,
                                                url = task.url
                                            )
                                        } else {
//                                            printLogW("onprogress2>")
                                            task.progress.onProgress(
                                                (channel.totalBytesRead * 100 / httpResponse.contentLength()!!).toInt()
                                                    .apply { pp = this }, speed, url = task.url
                                            )
                                        }
                                    }
                                }
                                if (task.state == TaskState.Paused) { //not try
                                    httpResponse.cancel()
                                }
                            }
                            //下载结束，计算的文件总大小不准，有误差
                            if (channel.isClosedForRead) { //&& pp > 95 ,速度过快进度会中间会少值
                                //如果突然中断网络也是close,status也是200
                                if (FileSystem.SYSTEM.exists(tmpFile)) {
//                                    val cur = Clock.System.now()
                                    val desPath = tmpFile.toString().replace(".tmp", "")
//                                    FileSystem.SYSTEM.atomicMove( //这耗时太大了，是移动文件，不算改名
//                                        tmpFile,
//                                        desPath.toPath()
//                                    )
//                                    saveStr(GlobalCode.subFormatUrl(task.url), desPath)
//                                    task.callback(true, desPath)

                                    //如果文件已存在，重命名也耗时，尴尬
                                    renameFile(tmpFile.toString(), desPath)
                                    saveStr(GlobalCode.subFormatUrl(task.url), desPath)
                                    printLogW("callback???")
                                    task.callback(true, task.url, desPath) //结束
//                                    injectAct()
//                                    printLogW("cost-time>${Clock.System.now() - cur}")
                                    if (GlobalCode.canPreview2DCIM(
                                            GlobalCode.getFileTypeByUrl(task.url).toUpperCase()
                                        )
                                    ) {
                                        if (task.url.contains("water=true")) {
                                            createWaterPic(desPath, task.url)
                                        } else {
                                            val path1 = saveMedia2Gallery(desPath, callback = { s ->
//                                                printLogW("copyPath>$s")
                                                s?.let {
                                                    saveStr(GlobalCode.subFormatUrl(task.url), s)
                                                }
                                             //   DownloadHelper.upGradeDownload(task.url, s)
                                            })
//                                            printLogW("path1>$path1")
                                            //通知更新ui
                                          //  EventHelper.post(Event.RefreshEvent)
                                        }
                                    } else {
                                        DownloadHelper.upGradeDownload(task.url, desPath)
//                                        printLogW("${GlobalCode.fileExist(desPath)}")
                                        //通知更新ui
                                        EventHelper.post(Event.RefreshEvent)
                                    }
                                }
                                task.state = TaskState.Completed
                                downloadQueue.remove(task)
                                processNext()
                            }
                        }
                    }
                }
            } catch (e: Exception) {
                e.printStackTrace()
                if (task.state != TaskState.Paused) {
                    task.state = TaskState.Failed(e.message)
                    task.callback(false, task.url, e.message)
                    //需要提示还是直接删除,但是有错误时不删会导致无限循环启动
                    downloadQueue.remove(task)
                    processNext()
                }
            }
        }
    }

    private fun updateFailed(task: DownloadTask?, msg: String?, e: Throwable? = null) {
        task?.let {
            e?.let {
                task.state = TaskState.Failed(e.message)
            }
            task.callback(false, task.url, msg)
            //需要提示还是直接删除,但是有错误时不删会导致无限循环启动
            downloadQueue.remove(task)
            processNext()
        }
        if (isConnected() || true) { //无网络
          //  saveBoolean(KmmConfig.DATA_DOWNLOAD_STOP, true)
         //   EventHelper.post(Event.MyDownloadRefreshEvent(type = FileInfoBean.TYPE_NET_ERROR))
         //类似EventBus的功能，跟我的业务强绑定了，这里参考可以不要
        }
    }
}

interface ProgressListener {
    fun onProgress(progress: Int, speed: Int, url: String)
}

启动队列下载任务,整个队列下载框架处理的任务对象是DownloadTask类型，我们平时是在页面列表多选项构造出新的下载队列，用covert2TaskList()转换成框架处理的数据集。

kotlin 复制代码 
 DownloadApi.startTaskList(covert2TaskList(newList))
/**将数据源转为队列任务数据*/
fun covert2TaskList(list: MutableList<FileInfoBean>?): List<DownloadTask> {
    val taskList = mutableListOf<DownloadTask>()
    list?.forEach { bean ->
        val desPath = GlobalCode.getGlobalDCIMPath(bean.downloadUrl, isCopy = true) + "/${
            DownloadHelper.setFileNameByUrl(bean.downloadUrl!!)
        }"
        taskList.add(
            DownloadTask(
                url = bean.downloadUrl!!,
                savePath = desPath, progress = createProgressListener(), callback = createCallback()
            )
        )
    }
    return taskList
}

/**回调每个下载进度*/
private fun createProgressListener(): ProgressListener {
    val listener = object : ProgressListener {
        override fun onProgress(progress: Int, speed: Int, url: String) {
//            val str = "progress>$progress , speed>$speed"
//            printLogW(str)
        //    updateProgressData(progress, speed, url) //自己的业务数据更新到本地
          //  refreshUi() //更新前台ui刷新
        }
    }
    return listener
}

/**回调下载结束是否成功 suc,url,path*/
private fun createCallback(): (Boolean, String, String?) -> Unit {
    val callBack = { suc: Boolean, url: String, msg: String? ->
        printLogW("callback>$suc ,$msg")
        if (suc) {
          //  refreshUi(downloadUrl = url, localPath = msg)
        }
    }
    return callBack
}

/**将数据源转为队列任务数据*/
fun covert2TaskList(list: MutableList<FileInfoBean>?): List<DownloadTask> {
    val taskList = mutableListOf<DownloadTask>()
    list?.forEach { bean ->
        val desPath = GlobalCode.getGlobalDCIMPath(bean.downloadUrl, isCopy = true) + "/${
            DownloadHelper.setFileNameByUrl(bean.downloadUrl!!)
        }"
        taskList.add(
            DownloadTask(
                url = bean.downloadUrl!!,
                savePath = desPath, progress = createProgressListener(), callback = createCallback()
            )
        )
    }
    return taskList
}

//在Platform.android.kt的 ,Platform.ios.kt可以重写一次一样的
actual fun createHttpClient(timeout: Long?): HttpClient {
    return HttpClient {
        defaultRequest {
            url.takeFrom(URLBuilder().takeFrom("http://wfserver.gree.com/"))
        }
        install(HttpTimeout) {
            timeout?.let {
                requestTimeoutMillis = timeout
            }
        }
        install(ContentNegotiation) {
            json(Json {
                ignoreUnknownKeys = true
                prettyPrint = true
            })
        }
        install(Logging) {
//                level = LogLevel.BODY
//            level=LogLevel.HEADERS
            level= LogLevel.INFO
//            level = LogLevel.NONE //接口日志屏蔽
            logger = object : io.ktor.client.plugins.logging.Logger {
                override fun log(message: String) {
                    println(message)
                }
            }
        }
    }
}

@Serializable
class FileInfoBean : Comparable<FileInfoBean> {

    companion object {
        const val TYPE_DONE = 0     //已下载
        const val TYPE_DOWNLOADING = 1 //下载中
        const val TYPE_HEADER = 2   //下载日期布局
        const val TYPE_NET_ERROR = 3  //网络错误
        const val TYPE_FILE_ERROR = 4 //无法正常下载的文件，如文件防火墙隔离
        const val TYPE_NET_STOP = 5  //暂停下载
        const val TYPE_FILTER=6 //6= 剔除gdoc文件并开始,7=复制成功,8=权限错误
        const val TYPE_COPY=7
        const val TYPE_PERMISSION=8
    }

    var fileName: String
    var fileSize: Double = 0.0
    var downloadStatus: Int = 0 //是否已下载 0-已完成/未开始 1-进行中
    var createTime: Long = Clock.System.now().toEpochMilliseconds()
    var fileFlag: Int = 0   //是分组名还是文件项 0-已完成 1-下载中 2-组名(日期)
    var present: Int = 0    //进度
    var localPath: String? = null
    var downloadUrl: String? = null
     var id: Int = -1
    var speed: Int = 0
 override fun compareTo(other: FileInfoBean): Int {  //以时间作为排序依据
        return this.createTime.compareTo(other.createTime)
    }


    fun clone(): FileInfoBean { //要实现实体复制
        return FileInfoBean(
            this.fileName,
            this.fileFlag,
           ....//自己补充属性吧，我业务上的实体属性很多上面已经删除了部分
    }

注意事项

  1. saveStr(GlobalCode.subFormatUrl(task.url), desPath) ，这是代表以下载链接最后一截为key保存下载路径到本地，保存的库我是com.russhwolf:multiplatform-settings，自行实现savaStr的封装就好。
  2. 断点下载的关键是请求的头部header的Range字节范围，val existLength = FileSystem.SYSTEM.metadataOrNull(tmpFile)?.size我是依靠这个获取已下载的文件大小，这样就不需要记录每次的下载位置。
  3. iOS的下载文件路径每次获取都被沙盒重构再输出，就是会变的记录也没什么用，他获取文件是靠label的标识，上篇文章有提到，比较难处理的文件管理，android和iOS差异挺大的，而且android内部迭代后权限和存储又不一样。
  4. 模拟了几种下载突然中断的场景，网络断开，忽然杀掉app，重新启动app也可正常断点下载。
  5. 我开始试过用下载进度来代表下载结束，但是进度的计算有误差容易导致下载到99%没跳进结束逻辑，但是下载其实已经结束，而且我内部下载进度是1600ms的间隔对外通知，后来试channel.isClosedForRead就很好判断。
  6. DownloadHelper类是我自己的业务数据更加队列下载情况处理，可以注释掉，正常下载肯定有进度，速度，下载路径，而且缓存文件的信息等，我也把文件拆成已下载和下载中，当然是我的业务上的逻辑，注释即可。
  7. 还有问题，大家可以思考的，队列下载这里是并没有启动线程池并发下再合并文件块，这里是循环下载结束一个接着下一个，那么看createDownloadJob每次创建一个Job,在他的下载结束回调会进入processNext()，这里是获取下一个任务在创建createDownloadJob，相当于Job之间是嵌套了，但是最佳应该是结束一个下载Job也自动被协程释放。这里我也没想好>_<。
相关推荐
测试界的酸菜鱼10 分钟前
Python 大数据展示屏实例
大数据·开发语言·python
晨曦_子画19 分钟前
编程语言之战：AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
大福是小强20 分钟前
005-Kotlin界面开发之程序猿初试Composable
kotlin·界面开发·桌面应用·compose·jetpack·可组合
Black_Friend27 分钟前
关于在VS中使用Qt不同版本报错的问题
开发语言·qt
孤客网络科技工作室41 分钟前
AJAX 全面教程：从基础到高级
android·ajax·okhttp
希言JY1 小时前
C字符串 | 字符串处理函数 | 使用 | 原理 | 实现
c语言·开发语言
残月只会敲键盘1 小时前
php代码审计--常见函数整理
开发语言·php
xianwu5431 小时前
反向代理模块
linux·开发语言·网络·git
ktkiko111 小时前
Java中的远程方法调用——RPC详解
java·开发语言·rpc
y5236482 小时前
Javascript监控元素样式变化
开发语言·javascript·ecmascript
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play