Android 利用socket 来实现 自动升级apk

迷路国王2024-10-29 18:35

1.创建socket

  1. 创建解析的bean

    /**

    /**

    • 心跳发送请求的bean
      */
      data class WebSocketRequestBaseBean(

      /**

      • code 值
        */
        val code: Int,

      /**

      • 消息内容
        */
        val message: String,

      val type: Int,

      val data: String
      )

    data class Data(
    /**
    * 下载地址
    */
    val downloadApkUrl: String,

     /**
  * 版本号
  */
 val version: String

    )

2.创建manager

import com.elvishew.xlog.XLog
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.WebSocket



class WebSocketManager private constructor() {

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

        fun getBloodBankPadManager(): WebSocketManager {
            return instance ?: synchronized(this) {
                instance ?: WebSocketManager().also { instance = it }
            }
        }
    }

    /**
     * url 地址
     */
    private var baseUrl: String = ""

    /**
     * 连接
     */
    private var webSocket: WebSocket? = null

    /**
     * client
     */
    private var okHttpClient: OkHttpClient? = null

    /**
     * 回调
     */
    private var hccxWebSocketListener: HccxWebSocketListener? = null

    /**
     * 设备唯一标识
     */
    private var deviceId: String = ""

    /**
     * 初始化baseUrl
     * @param baseUrl url地址
     */
    fun init(baseUrl: String): WebSocketManager {
        this.baseUrl = baseUrl
        this.okHttpClient = OkHttpClient()
        this.hccxWebSocketListener = HccxWebSocketListener()
        return this
    }

    fun setDeviceId(deviceId: Int): WebSocketManager {
        return setDeviceId(deviceId.toString())
    }

    /**
     * 设置设备唯一标识
     */
    fun setDeviceId(deviceId: String): WebSocketManager {
        this.deviceId = deviceId
        return this
    }

    /**
     * 回调
     */
    fun callback(callback: HccxWebSocketCallback): WebSocketManager {
        hccxWebSocketListener?.setHccxWebSocketCallback(callback)
        return this
    }

    /**
     * 连接
     */
    fun connect() {
        disConnect()
        val request = Request.Builder().url(createUrl(baseUrl, deviceId)).build()
        webSocket = okHttpClient?.newWebSocket(request, hccxWebSocketListener)
    }

    /**
     * 清空 websocket
     */
    fun disConnect(){
        webSocket?.cancel()
        webSocket = null
    }


    private fun createUrl(baseUrl: String, deviceId: String): String {
        XLog.e("当前baseUrl----$baseUrl-------deviceId----$deviceId")
        return "$baseUrl$deviceId"
    }
}

  1. 创建listener回调

    import com.elvishew.xlog.XLog
    import com.google.gson.Gson
    import kotlinx.coroutines.CoroutineScope
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.Job
    import kotlinx.coroutines.delay
    import kotlinx.coroutines.isActive
    import kotlinx.coroutines.launch
    import okhttp3.Response
    import okhttp3.WebSocket
    import okhttp3.WebSocketListener

    class HccxWebSocketListener: WebSocketListener() {
    companion object {
    /**
    * 心跳时间
    */
    private const val PING_PONG_INTERVAL_TIME = 10_000L // 10 秒

         /**
      * 重连时间
      */
     private const val RE_CONNECT_INTERVAL_TIME = 60_000L // 60 秒

     /**
      * 重连间隔时间
      */
     private const val RE_CONNECT_DELAY_TIME = 10_000L // 10 秒
 }

 @Volatile
 private var mWebSocket: WebSocket? = null

 private var hccxWebSocketCallback: HccxWebSocketCallback? = null

 /**
  * 心跳机制
  */
 private var pingJob: Job? = null

 /**
  * 重连
  */
 private var reconnectJob: Job? = null

 /**
  * 初始化socketcallback
  */
 fun setHccxWebSocketCallback(callback: HccxWebSocketCallback) {
     this.hccxWebSocketCallback = callback
 }

 override fun onOpen(webSocket: WebSocket, response: Response) {
     XLog.e("onOpen")
     this.mWebSocket = webSocket
     stopReconnect()
     startPingPong()
     hccxWebSocketCallback?.onOpen()
 }

 /**
  * 消息回调
  */
 override fun onMessage(webSocket: WebSocket, text: String) {
     super.onMessage(webSocket, text)
     hccxWebSocketCallback?.onMessage(text)
 }

 override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
     super.onClosing(webSocket, code, reason)
     webSocket.close(1000, reason)
 }

 override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
     XLog.e("onClosed")
     stopPingPong()
     startReconnect()
     hccxWebSocketCallback?.onClosed(code, "app closed")
 }

 override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
     XLog.e("onFailure")
     stopPingPong()
     startReconnect()
     hccxWebSocketCallback?.onFailure(t)
 }

 /**
  * 开始心跳机制
  */
 private fun startPingPong() {
     if (pingJob?.isActive == true) return
     pingJob = CoroutineScope(Dispatchers.IO).launch {
         while (isActive) {
             sendPingPongMessage()
             delay(PING_PONG_INTERVAL_TIME)
         }
     }
     XLog.e("start -- PingPong")
 }

 /**
  * 关闭心跳
  */
 private fun stopPingPong() {
     pingJob?.cancel()
     XLog.e("stop -- PingPong")
 }

 private fun sendPingPongMessage() {
     XLog.e("pingpong------$mWebSocket")
     val pingPongMessage = WebSocketRequestBaseBean(200, "", 100, "")
     val pingPongMessageJson = Gson().toJson(pingPongMessage)
     mWebSocket?.send(pingPongMessageJson)
 }

 /**
  * 开始重连
  */
 private fun startReconnect() {
     if (reconnectJob?.isActive == true) return
     reconnectJob = CoroutineScope(Dispatchers.IO).launch {
         delay(RE_CONNECT_DELAY_TIME)
         while (isActive) {
             XLog.e("reconnect")
             WebSocketManager.getBloodBankPadManager().connect()
             delay(RE_CONNECT_INTERVAL_TIME)
         }
     }
     XLog.e("start -- ReConnectServer")
 }

 /**
  * 关闭重连
  */
 private fun stopReconnect() {
     reconnectJob?.cancel()
     XLog.e("stop -- ReConnectServer")
 }

    }

  2. 数据解析类

    import com.elvishew.xlog.XLog
    import com.google.gson.Gson
    import com.google.gson.JsonSyntaxException
    import com.google.gson.reflect.TypeToken

    class WebSocketParserChain {
    private val parsers = mutableListOf<WebSocketDataParser>()

     fun addParser(parser: WebSocketDataParser): WebSocketParserChain {
     parsers.add(parser)
     return this
 }

 fun parse(text: String): WebSocketResponseBaseBean<*>? {
     for (parser in parsers) {
         val result = parser.parse(text)
         if (result != null) {
             return result
         }
     }
     return null
 }

    }

    /**

    • 解析的接口
      /
      interface WebSocketDataParser {
      fun parse(text: String): WebSocketResponseBaseBean<      >?
      }

    /**

    • 对象解析
      /
      class DataParser : WebSocketDataParser {
      override fun parse(text: String): WebSocketResponseBaseBean<      >? {
      return try {
      val objectType = object : TypeToken<WebSocketResponseBaseBean<Data>>() {}.type
      val webSocketBaseBean: WebSocketResponseBaseBean<*> = Gson().fromJson(text, objectType)

           // 如果解析后的 data 是对象（Data），直接返回结果
     if (webSocketBaseBean.data != null && webSocketBaseBean.data is Data) {
         webSocketBaseBean
     } else {
         XLog.e("DataParser----json解析对应的bean---${webSocketBaseBean.data}")
         null // 如果 data 不是对象，返回 null 传递给下一个解析器
     }
 } catch (e: JsonSyntaxException) {
     XLog.e("DataParser----json解析异常---${e.message}")
     null // 如果解析失败，返回 null
 }

      }
      }

    /**

    • string 解析
      /
      class StringParser: WebSocketDataParser {
      override fun parse(text: String): WebSocketResponseBaseBean<      >? {
      return try {
      val stringType = object : TypeToken<WebSocketResponseBaseBean<String>>() {}.type
      Gson().fromJson(text, stringType)
      } catch (e: JsonSyntaxException) {
      XLog.e("StringParser-----json异常---${e.message}")
      null
      }
      }
      }

    /**

    • object 解析 默认解析 添加一个兜底方案 避免返回的data 既不是字符串 又不是对象
      /
      class ObjectParser: WebSocketDataParser {
      override fun parse(text: String): WebSocketResponseBaseBean<      >? {
      return try {
      val stringType = object : TypeToken<WebSocketResponseBaseBean<Any>>() {}.type
      Gson().fromJson(text, stringType)
      } catch (e: JsonSyntaxException) {
      XLog.e("ObjectParser-----json异常---${e.message}")
      null
      }
      }
      }

  3. listener 实现类

    import com.elvishew.xlog.XLog

    class HccxWebSocketCallbackIml : HccxWebSocketCallback {

     override fun onMessage(text: String) {
     XLog.e("onMessage----text---$text")
     try {
         val parserChain = WebSocketParserChain()
             .addParser(DataParser())   // 尝试解析为对象类型
             .addParser(StringParser())   // 如果失败则尝试解析为字符串类型
             .addParser(ObjectParser())   // 如果失败则尝试解析为Any类型 兜底方案

         val webSocketBaseBean = parserChain.parse(text)


         XLog.e("当前websocket数据为--$webSocketBaseBean------mListener---$mListener")

         if (webSocketBaseBean==null) {
             return
         }

         // 判断 `code` 是否为 200
         if (webSocketBaseBean.code != 200) {
             return
         }

         // 回调是否初始化
         if (mListener == null) {
            return
         }

         when (webSocketBaseBean.data) {
             is Data -> {
                 val updateInfo = webSocketBaseBean.data as Data
                 mListener!!.downloadData(updateInfo)
             }

             is String -> {
                 when (webSocketBaseBean.type) {

                 }
                 val downloadUrl = webSocketBaseBean.data as String
                 XLog.e("------downloadUrl----$downloadUrl")
                 mListener!!.defaultRefresh()
             }

             else -> {
                 XLog.e("解析的data---${webSocketBaseBean.data}")
             }
         }
     } catch (e: Exception) {
         XLog.e("解析异常: ${e.message}")
     }

 }

 override fun onClosed(code: Int, reason: String) {
     XLog.e("当前websocket onClosed--code----$code---------reason----$reason")
 }

 override fun onOpen() {
 }

 override fun onFailure(t: Throwable) {
     XLog.e("当前websocket onFailure--Throwable----" + t.message)
 }


 private var mListener: WebSocketCallbackListener? = null

 /**
  * 设置回调
  */
 fun setWebSocketCallbackListener(listener: WebSocketCallbackListener) {
     this.mListener = listener
 }


 interface WebSocketCallbackListener {
     /**
      * 升级回调
      * @param data 下载返回的bean
      */
     fun downloadData(data:Data) {}

     /**
      * 默认刷新
      */
     fun defaultRefresh(){}
 }

    }

    /**

    • socket 信息回调接口
      */
      interface HccxWebSocketCallback {

      /**

      • 获取推送的消息
      • @param text
        */
        fun onMessage(text: String)

      /**

      • 关闭连接
      • @param code
      • @param reason
        */
        fun onClosed(code: Int, reason: String)

      /**

      • 打开连接
        */
        fun onOpen()

      /**

      • 连接失败
      • @param t
        */
        fun onFailure(t: Throwable)

    }

  4. 使用

    val hccxWebSocketCallbackIml = HccxWebSocketCallbackIml()

             hccxWebSocketCallbackIml.setWebSocketCallbackListener(object :
             HccxWebSocketCallbackIml.WebSocketCallbackListener {
             override fun downloadData(data: Data) {
                 super.downloadData(data)
                 runOnUiThread {
                     toast("刷新数据了-----${data.downloadApkUrl}")
                     val intent = Intent(this@MainActivity, InstallActivity::class.java)
                     intent.putExtra(Constant.DOWNLOAD_URL, data.downloadApkUrl)
                     intent.putExtra(Constant.DOWNLOAD_FILE_NAME, data.version)
                     startActivity(intent)
                 }
             }
         })

         WebSocketManager.getBloodBankPadManager()
             .init("url")
             .callback(hccxWebSocketCallbackIml).connect()

2. 自动安装 activity

import android.content.Intent
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.elvishew.xlog.XLog
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import me.hgj.jetpackmvvm.ext.download.OnDownLoadListener
import java.io.File


class InstallActivity : AppCompatActivity() {
    private var mBinding: ActivityInstallBinding? = null

    /**
     * 下载地址
     */
    @Volatile
    private var downLoadUrl: String = ""

    /**
     * 下载名称
     */
    @Volatile
    private var downLoadFileName: String = ""

    /**
     * 重新申请权限次数  用于超过重新申请次数之后 给出文案提示，
     */
    @Volatile
    private var againNumber = 0


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mBinding = ActivityInstallBinding.inflate(layoutInflater)
        setContentView(mBinding!!.root)

        val intent = intent
        downLoadUrl = intent.getStringExtra(Constant.DOWNLOAD_URL)
            ?: "https"


        downLoadFileName = intent.getStringExtra(DOWNLOAD_FILE_NAME)?.run {
            if (isNotEmpty() && !endsWith(".apk")) "$this.apk" else this
        } ?: DOWNLOAD_DEFAULT_FILE_NAME


        XLog.e("当前下载名称为$downLoadFileName-------下载地址---$downLoadUrl")

        if (downLoadUrl.isEmpty()) {
            toast("下载地址不能为空")
            return
        }

        if (downLoadFileName.isEmpty()) {
            toast("下载文件名不合法，请重新输入")
            return
        }
    }

    override fun onResume() {
        super.onResume()

        // 判断权限是否都申请完
        if (RequestPermissionUtil.checkPermissionState(this)) {
            downloadApk(downLoadFileName, downLoadUrl)
        } else {
            // 申请权限可以 重试两次  ，两次失败之后给出提示
            againNumber++
            if (againNumber > 2) {
                toast(RequestPermissionUtil.permissionTip(this))
                finish()
                return
            }

            startActivity(Intent(this, PermissionActivity::class.java))
        }

    }


    /**
     * 下载apk
     * @param downLoadFileName 下载的文件名称
     * @param downLoadUrl 下载url 地址
     */
    private fun downloadApk(downLoadFileName: String, downLoadUrl: String) {
        val checkUpdateParentFile = checkUpdateParentFile(this)

        val file = File(checkUpdateParentFile.path + "/update/")
        if (!file.exists()) {
            file.mkdirs()
        }

        toast("正在下载中请稍后")


        lifecycleScope.launch(Dispatchers.IO) {

            DownLoadManager.downLoad("NoHeader",
                downLoadUrl,
                file.path,
                downLoadFileName,
                true,
                object : OnDownLoadListener {
                    override fun onDownLoadPrepare(key: String) {
                    }

                    override fun onDownLoadError(key: String, throwable: Throwable) {
                        toast(throwable.message.toString())
                        XLog.e("下载失败---地址为---$downLoadUrl")
                    }

                    override fun onDownLoadSuccess(key: String, path: String, size: Long) {
                        XLog.e("文件路径为----$path")
                        if (File(path).length() > 0) {
                            toast("下载完成")
                            installAPK(this@InstallActivity, path)
                            finish()
                        } else {
                            XLog.e("安装失败---下载地址为---$downLoadUrl")
                            toast("文件包安装失败,请查看下载地址是否正常")
                            finish()
                        }
                    }

                    override fun onDownLoadPause(key: String) {
                    }

                    override fun onUpdate(
                        key: String,
                        progress: Int,
                        read: Long,
                        count: Long,
                        done: Boolean
                    ) {
                        runOnUiThread {
                            mBinding!!.abuPermission.text = "当前进度为$progress"
                        }

                        XLog.e("当前进度为-----$progress-----$read-----$count-----$done")
                    }

                }
            )
        }
    }

}




object Constant {

    /**
     * 下载地址
     */
    const val DOWNLOAD_URL = "DOWNLOAD_URL"

    /**
     * 下载文件名称
     */
    const val DOWNLOAD_FILE_NAME = "DOWNLOAD_FILE_NAME"

    /**
     * 下载文件默认名称名称
     */
    const val DOWNLOAD_DEFAULT_FILE_NAME = "update_1.0.apk"
}



引入了权限申请 依赖  

 implementation 'com.github.getActivity:XXPermissions:20.0'


import android.Manifest
import android.content.Context
import android.content.Intent
import android.os.Build
import android.provider.Settings
import android.text.TextUtils
import android.text.TextUtils.SimpleStringSplitter
import android.util.Log
import com.hjq.permissions.Permission
import com.hjq.permissions.XXPermissions



object RequestPermissionUtil {


    /**
     * 重试次数文案提示
     */
    fun permissionTip(context: Context): String {

        var permissionTipMessage =
            StringBuilder("权限申请超过重试次数，请进入到系统设置界面，打开需要申请的权限\n")

        appendPermissionTip(allMediaState(context), "(所有文件权限)", permissionTipMessage)

        appendPermissionTip(installState(context), "(允许安装未知来源权限)", permissionTipMessage)

        appendPermissionTip(
            XXPermissions.isGranted(context, Permission.SYSTEM_ALERT_WINDOW),
            "(悬浮窗权限)",
            permissionTipMessage
        )
        appendPermissionTip(
            XXPermissions.isGranted(
                context,
                Permission.READ_EXTERNAL_STORAGE,
                Permission.WRITE_EXTERNAL_STORAGE
            ), "(读写文件权限)", permissionTipMessage
        )

        appendPermissionTip(
            XXPermissions.isGranted(context, Permission.POST_NOTIFICATIONS),
            "(通知栏权限)",
            permissionTipMessage
        )

        appendPermissionTip(
            isSettingOpen(AutoInstallService::class.java, context),
            "(无障碍服务权限)",
            permissionTipMessage
        )

        return permissionTipMessage.toString()
    }

    /**
     * 拼接内容
     */
    private fun appendPermissionTip(
        condition: Boolean,
        message: String,
        permissionTipMessage: StringBuilder
    ) {
        if (!condition) {
            permissionTipMessage.append(message).append("\n")
        }
    }

    /**
     * 判断需要申请的权限是否都申请完毕
     * 1.所有文件权限 Android 10以上需要申请
     * 2.是否允许安装未知来源
     * 3.悬浮窗权限
     * 4.读写权限
     * 5.系统通知栏权限
     * 6.无障碍服务权限
     */
    fun checkPermissionState(context: Context): Boolean {

        return allMediaState(context) && installState(context)
                && XXPermissions.isGranted(context, Permission.SYSTEM_ALERT_WINDOW)
                && XXPermissions.isGranted(
            context,
            Permission.READ_EXTERNAL_STORAGE,
            Permission.WRITE_EXTERNAL_STORAGE
        )
                && XXPermissions.isGranted(context, Permission.POST_NOTIFICATIONS)
                && isSettingOpen(AutoInstallService::class.java, context)
    }


    /**
     * 是否有安装未知来源权限
     */
    private fun installState(context: Context): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            XXPermissions.isGranted(context, Permission.REQUEST_INSTALL_PACKAGES)
        } else {
            true
        }
    }

    /**
     * Android 10以上 是否有所有文件权限
     */
    private fun allMediaState(context: Context): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            XXPermissions.isGranted(context, Permission.MANAGE_EXTERNAL_STORAGE)
        } else {
            true
        }
    }


    /**
     * 检查系统设置：是否开启辅助服务
     * @param service 辅助服务
     */
    fun isSettingOpen(service: Class<*>, cxt: Context): Boolean {
        try {
            val enable = Settings.Secure.getInt(
                cxt.contentResolver,
                Settings.Secure.ACCESSIBILITY_ENABLED,
                0
            )
            if (enable != 1) return false
            val services = Settings.Secure.getString(
                cxt.contentResolver,
                Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES
            )
            if (!TextUtils.isEmpty(services)) {
                val split = SimpleStringSplitter(':')
                split.setString(services)
                while (split.hasNext()) { // 遍历所有已开启的辅助服务名
                    if (split.next()
                            .equals(cxt.packageName + "/" + service.name, ignoreCase = true)
                    ) return true
                }
            }
        } catch (e: Throwable) { //若出现异常，则说明该手机设置被厂商篡改了,需要适配
            Log.e("", "isSettingOpen: " + e.message)
        }
        return false
    }

    /**
     * 跳转到系统设置：开启辅助服务
     */
    fun jumpToSetting(cxt: Context) {
        try {
            cxt.startActivity(Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS))
        } catch (e: Throwable) { //若出现异常，则说明该手机设置被厂商篡改了,需要适配
            try {
                val intent = Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                cxt.startActivity(intent)
            } catch (e2: Throwable) {
                Log.e("", "jumpToSetting: " + e2.message)
            }
        }
    }

    /**
     * 读写权限
     * 适配android14
     */
    fun permissionList(): MutableList<String> {
        var permissionList = mutableListOf<String>()
        permissionList.add(Manifest.permission.CAMERA)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
            permissionList.add(Manifest.permission.MANAGE_EXTERNAL_STORAGE)
            permissionList.add(Manifest.permission.READ_MEDIA_IMAGES)
            permissionList.add(Manifest.permission.READ_MEDIA_VIDEO)
            permissionList.add(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            permissionList.add(Manifest.permission.MANAGE_EXTERNAL_STORAGE)
            permissionList.add(Manifest.permission.READ_MEDIA_IMAGES)
            permissionList.add(Manifest.permission.READ_MEDIA_VIDEO)

        } else {
            permissionList.add(Manifest.permission.READ_EXTERNAL_STORAGE)
            permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE)
        }
        return permissionList
    }

}

文件判断

fun createFileUri(context: Context, file: File): Uri {
    var uri: Uri? = null
    uri = if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
        FileProvider.getUriForFile(
            context, context.packageName + ".fileprovider",
            file
        )
    } else {
        Uri.fromFile(file)
    }
    return uri
}

/**
 * 下载安装包的存放路径   app 私有目录下面
 */
fun checkUpdateParentFile(context: Context): File {

    val filesDir = context.filesDir

    if (!filesDir.exists()) {
        filesDir.mkdirs()
    }

    return filesDir
}


/**
 * 自动安装  android 10一下可以实现自动安装并打开
 */
fun installAPK(context: Context, path: String) {
    val intent = Intent(Intent.ACTION_VIEW)
    intent.addCategory(Intent.CATEGORY_DEFAULT)
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
    intent.setDataAndType(
        createFileUri(context, File(path)),
        "application/vnd.android.package-archive"
    )
    //设置静默安装标识
    intent.putExtra("silence_install", true)
    //设置安装完成是否启动标识
    intent.putExtra("is_launch", true)
    //设置后台中启动activity标识
    intent.putExtra("allowed_Background", true)
    if (context.packageManager.queryIntentActivities(intent, 0).size > 0) {
        context.startActivity(intent)
    }
}

下载类downloadmanager

import android.os.Looper
import com.elvishew.xlog.XLog
import com.hccx.lib_framwork.ext.loge
import com.hccx.lib_framwork.net.KtLoggingInterceptor
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.isActive
import kotlinx.coroutines.withContext
import me.hgj.jetpackmvvm.ext.download.DownLoadPool
import me.hgj.jetpackmvvm.ext.download.OnDownLoadListener
import okhttp3.OkHttpClient
import okhttp3.ResponseBody
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.io.File
import java.io.FileOutputStream
import java.io.InputStream
import java.util.concurrent.TimeUnit


object DownLoadManager {
    private val retrofitBuilder by lazy {
        Retrofit.Builder()
            .baseUrl("url/")
            .client(
                OkHttpClient.Builder()
                    .connectTimeout(10, TimeUnit.SECONDS)
                    .readTimeout(5, TimeUnit.SECONDS)
                    .writeTimeout(5, TimeUnit.SECONDS)
                    .build()
            ).addConverterFactory(GsonConverterFactory.create())
            .build()


    }

    /**
     *开始下载
     * @param tag String 标识
     * @param url String  下载的url
     * @param savePath String 保存的路径
     * @param saveName String 保存的名字
     * @param reDownload Boolean 如果文件已存在是否需要重新下载 默认不需要重新下载
     * @param loadListener OnDownLoadListener
     */
    suspend fun downLoad(
        tag: String,
        url: String,
        savePath: String,
        saveName: String,
        reDownload: Boolean = false,
        loadListener: OnDownLoadListener
    ) {
        withContext(Dispatchers.IO) {
            doDownLoad(tag, url, savePath, saveName, reDownload, loadListener, this)
        }
    }

    /**
     * 取消下载
     * @param key String 取消的标识
     */
    fun cancel(key: String) {
        val path = DownLoadPool.getPathFromKey(key)
        if (path != null) {
            val file = File(path)
            if (file.exists()) {
                file.delete()
            }
        }
        DownLoadPool.remove(key)
    }

    /**
     * 暂停下载
     * @param key String 暂停的标识
     */
    fun pause(key: String) {
        val listener = DownLoadPool.getListenerFromKey(key)
        listener?.onDownLoadPause(key)
        DownLoadPool.pause(key)
    }

    /**
     * 取消所有下载
     */
    fun doDownLoadCancelAll() {
        DownLoadPool.getListenerMap().forEach {
            cancel(it.key)
        }
    }

    /**
     * 暂停所有下载
     */
    fun doDownLoadPauseAll() {
        DownLoadPool.getListenerMap().forEach {
            pause(it.key)
        }
    }

    /**
     *下载
     * @param tag String 标识
     * @param url String  下载的url
     * @param savePath String 保存的路径
     * @param saveName String 保存的名字
     * @param reDownload Boolean 如果文件已存在是否需要重新下载 默认不需要重新下载
     * @param loadListener OnDownLoadListener
     * @param coroutineScope CoroutineScope 上下文
     */
    private suspend fun doDownLoad(
        tag: String,
        url: String,
        savePath: String,
        saveName: String,
        reDownload: Boolean,
        loadListener: OnDownLoadListener,
        coroutineScope: CoroutineScope
    ) {
        //判断是否已经在队列中
        val scope = DownLoadPool.getScopeFromKey(tag)
        if (scope != null && scope.isActive) {
            "已经在队列中".loge()
            return
        } else if (scope != null && !scope.isActive) {
            "key $tag 已经在队列中 但是已经不再活跃 remove".loge()
            DownLoadPool.removeExitSp(tag)
        }

        if (saveName.isEmpty()) {
            withContext(Dispatchers.Main) {
                loadListener.onDownLoadError(tag, Throwable("save name is Empty"))
            }
            return
        }

        if (Looper.getMainLooper().thread == Thread.currentThread()) {
            withContext(Dispatchers.Main) {
                loadListener.onDownLoadError(tag, Throwable("current thread is in main thread"))
            }
            return
        }

        val file = File("$savePath/$saveName")
        val currentLength = if (!file.exists()) {
            0L
        } else {
            ShareDownLoadUtil.getLong(tag, 0)
        }
        if (file.exists() && currentLength == 0L && !reDownload) {
            //文件已存在了
            loadListener.onDownLoadSuccess(tag, file.path, file.length())
            return
        }
        "startDownLoad current $currentLength".loge()

        try {
            //添加到pool
            DownLoadPool.add(tag, coroutineScope)
            DownLoadPool.add(tag, "$savePath/$saveName")
            DownLoadPool.add(tag, loadListener)

            withContext(Dispatchers.Main) {
                loadListener.onDownLoadPrepare(key = tag)
            }

            // 断点续传下载
            val response = retrofitBuilder.create(DownLoadService::class.java)
                .downloadFile("bytes=$currentLength-", url)

            val acceptRanges = response.headers()["Accept-Ranges"]
            val supportsResume = acceptRanges != null && acceptRanges.equals(
                "bytes",
                ignoreCase = true)

            // 判断是否支持断点续传
            if (!supportsResume) {

                val responseBody = response.body()

                if (responseBody == null) {
                    "responseBody is null".loge()
                    withContext(Dispatchers.Main) {
                        loadListener.onDownLoadError(
                            key = tag,
                            throwable = Throwable("responseBody is null please check download url")
                        )
                    }
                    DownLoadPool.remove(tag)
                    return
                }
                downloadNoRange(tag,responseBody,file,loadListener)
                return
            }

            val responseBody = response.body()
            if (responseBody == null) {
                "responseBody is null".loge()
                withContext(Dispatchers.Main) {
                    loadListener.onDownLoadError(
                        key = tag,
                        throwable = Throwable("responseBody is null please check download url")
                    )
                }
                DownLoadPool.remove(tag)
                return
            }

            FileTool.downToFile(
                tag,
                savePath,
                saveName,
                currentLength,
                responseBody,
                loadListener
            )

        } catch (throwable: Throwable) {
            withContext(Dispatchers.Main) {
                loadListener.onDownLoadError(key = tag, throwable = throwable)
            }
            DownLoadPool.remove(tag)
        }
    }


    /**
     * 不带有断点续传下载
     * @param tag  下载标识
     * @param url 下载链接
     * @param apkFile 下载保存后的文件
     * @param loadListener 监控回调
     */
    private suspend fun downloadNoRange(
        tag: String,
        responseBody: ResponseBody,
        apkFile: File,
        loadListener: OnDownLoadListener
    ) {
        try {

            var inputStream: InputStream? = null
            var outputStream: FileOutputStream? = null

            try {
                val fileReader = ByteArray(4096)
                val fileSize = responseBody.contentLength()
                var fileSizeDownloaded: Long = 0

                XLog.e("-----------下载filesize---$fileSize")

                inputStream = responseBody.byteStream()
                outputStream = FileOutputStream(apkFile)

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

                    outputStream.write(fileReader, 0, read)
                    fileSizeDownloaded += read

                    // 计算并更新进度
                    val progress = (fileSizeDownloaded*100 / fileSize).toInt()
                    loadListener.onUpdate(tag,progress,fileSizeDownloaded,fileSize,fileSizeDownloaded==fileSize)
                }

                outputStream.flush()

                withContext(Dispatchers.Main) {
                    loadListener.onDownLoadSuccess(tag, apkFile.path,fileSizeDownloaded)
                }
                DownLoadPool.remove(tag)
                apkFile
            } finally {
                inputStream?.close()
                outputStream?.close()
            }
        } catch (e: Exception) {
            loadListener.onDownLoadError(tag,Throwable(e.message))
            null
        }
    }
}


object DownLoadPool {


    private val scopeMap: ConcurrentHashMap<String, CoroutineScope> = ConcurrentHashMap()

    //下载位置
    private val pathMap: ConcurrentHashMap<String, String> = ConcurrentHashMap()

    //监听
    private val listenerHashMap: ConcurrentHashMap<String, OnDownLoadListener> = ConcurrentHashMap()

    fun add(key: String, job: CoroutineScope) {
        scopeMap[key] = job
    }

    //监听
    fun add(key: String, loadListener: OnDownLoadListener) {
        listenerHashMap[key] = loadListener
    }

    //下载位置
    fun add(key: String, path: String) {
        pathMap[key] = path
    }


    fun remove(key: String) {
        pause(key)
        scopeMap.remove(key)
        listenerHashMap.remove(key)
        pathMap.remove(key)
        ShareDownLoadUtil.remove(key)
    }


    fun pause(key: String) {
        val scope = scopeMap[key]
        if (scope != null && scope.isActive) {
            scope.cancel()
        }
    }

    fun removeExitSp(key: String) {
        scopeMap.remove(key)
    }


    fun getScopeFromKey(key: String): CoroutineScope? {
        return scopeMap[key]
    }

    fun getListenerFromKey(key: String): OnDownLoadListener? {
        return listenerHashMap[key]
    }

    fun getPathFromKey(key: String): String? {
        return pathMap[key]
    }

    fun getListenerMap(): ConcurrentHashMap<String, OnDownLoadListener> {
        return listenerHashMap
    }

}



interface DownLoadProgressListener {

    /**
     * 下载进度
     * @param key url
     * @param progress  进度
     * @param read  读取
     * @param count 总共长度
     * @param done  是否完成
     */
    fun onUpdate( key: String,progress: Int, read: Long,count: Long,done: Boolean)
}


interface OnDownLoadListener : DownLoadProgressListener {

    //等待下载
    fun onDownLoadPrepare(key: String)

    //下载失败
    fun onDownLoadError(key: String, throwable: Throwable)

    //下载成功
    fun onDownLoadSuccess(key: String, path: String,size:Long)

    //下载暂停
    fun onDownLoadPause(key: String)
}



sealed class DownloadResultState {

    companion object {

        fun onPending(): DownloadResultState = Pending

        fun onProgress(soFarBytes: Long, totalBytes: Long, progress: Int): DownloadResultState =  Progress(soFarBytes, totalBytes,progress)

        fun onSuccess(filePath: String,totalBytes:Long): DownloadResultState = Success(filePath,totalBytes)

        fun onPause(): DownloadResultState = Pause

        fun onError(errorMsg: String): DownloadResultState = Error(errorMsg)
    }

    object Pending : DownloadResultState()
    data class Progress(val soFarBytes: Long, val totalBytes: Long,val progress: Int) : DownloadResultState()
    data class Success(val filePath: String,val totalBytes:Long) : DownloadResultState()
    object Pause : DownloadResultState()
    data class Error(val errorMsg: String) : DownloadResultState()
}


interface DownLoadService {

    /**
     * 带有断点续传
     */
    @Streaming
    @GET
    suspend fun downloadFile(
        @Header("RANGE") start: String,
        @Url url: String
    ): Response<ResponseBody>
}


object FileTool {

    //定义GB的计算常量
    private const val GB = 1024 * 1024 * 1024

    //定义MB的计算常量
    private const val MB = 1024 * 1024

    //定义KB的计算常量
    private const val KB = 1024

    /**
     * 下载文件到本地
     * @param key String
     * @param savePath String
     * @param saveName String
     * @param currentLength Long
     * @param responseBody ResponseBody
     * @param loadListener OnDownLoadListener
     */
    suspend fun downToFile(
        key: String,
        savePath: String,
        saveName: String,
        currentLength: Long,
        responseBody: ResponseBody,
        loadListener: OnDownLoadListener
    ) {
        val filePath = getFilePath(savePath, saveName)
        try {
            if (filePath == null) {
                withContext(Dispatchers.Main) {
                    loadListener.onDownLoadError(key, Throwable("mkdirs file [$savePath]  error"))
                }
                DownLoadPool.remove(key)
                return
            }
            //保存到文件
            saveToFile(currentLength, responseBody, filePath, key, loadListener)
        } catch (throwable: Throwable) {
            withContext(Dispatchers.Main) {
                loadListener.onDownLoadError(key, throwable)
            }
            DownLoadPool.remove(key)
        }
    }

    /**
     *
     * @param currentLength Long
     * @param responseBody ResponseBody
     * @param filePath String
     * @param key String
     * @param loadListener OnDownLoadListener
     */
    suspend fun saveToFile(
        currentLength: Long,
        responseBody: ResponseBody,
        filePath: String,
        key: String,
        loadListener: OnDownLoadListener
    ) {
        val fileLength =
            getFileLength(currentLength, responseBody)
        val inputStream = responseBody.byteStream()
        val accessFile = RandomAccessFile(File(filePath), "rwd")
        val channel = accessFile.channel
        val mappedBuffer = channel.map(
            FileChannel.MapMode.READ_WRITE,
            currentLength,
            fileLength - currentLength
        )
        val buffer = ByteArray(1024 * 4)
        var len = 0
        var lastProgress = 0
        var currentSaveLength = currentLength //当前的长度

        while (inputStream.read(buffer).also { len = it } != -1) {
            mappedBuffer.put(buffer, 0, len)
            currentSaveLength += len

            val progress = (currentSaveLength.toFloat() / fileLength * 100).toInt() // 计算百分比
            if (lastProgress != progress) {
                lastProgress = progress
                //记录已经下载的长度
                ShareDownLoadUtil.putLong(key, currentSaveLength)
                withContext(Dispatchers.Main) {
                    loadListener.onUpdate(
                        key,
                        progress,
                        currentSaveLength,
                        fileLength,
                        currentSaveLength == fileLength
                    )
                }

                if (currentSaveLength == fileLength) {
                    withContext(Dispatchers.Main) {
                        loadListener.onDownLoadSuccess(key, filePath,fileLength)
                    }
                    DownLoadPool.remove(key)
                }
            }
        }

        inputStream.close()
        accessFile.close()
        channel.close()
    }

    /**
     * 数据总长度
     * @param currentLength Long
     * @param responseBody ResponseBody
     * @return Long
     */
    fun getFileLength(
        currentLength: Long,
        responseBody: ResponseBody
    ) =
        if (currentLength == 0L) responseBody.contentLength() else currentLength + responseBody.contentLength()


    /**
     * 获取下载地址
     * @param savePath String
     * @param saveName String
     * @return String?
     */
    fun getFilePath(savePath: String, saveName: String): String? {
        if (!createFile(savePath)) {
            return null
        }
        return "$savePath/$saveName"

    }


    /**
     * 创建文件夹
     * @param downLoadPath String
     * @return Boolean
     */
    fun createFile(downLoadPath: String): Boolean {
        val file = File(downLoadPath)
        if (!file.exists()) {
            return file.mkdirs()
        }
        return true
    }


    /**
     * 格式化小数
     * @param bytes Long
     * @return String
     */
    fun bytes2kb(bytes: Long): String {
        val format = DecimalFormat("###.0")
        return when {
            bytes / GB >= 1 -> {
                format.format(bytes / GB) + "GB";
            }
            bytes / MB >= 1 -> {
                format.format(bytes / MB) + "MB";
            }
            bytes / KB >= 1 -> {
                format.format(bytes / KB) + "KB";
            }
            else -> {
                "${bytes}B";
            }
        }
    }

    /**
     * 获取App文件的根路径
     * @return String
     */
    fun getBasePath(): String {
        var p: String? = appContext.getExternalFilesDir(null)?.path
        val f: File? = appContext.getExternalFilesDir(null)
        if (null != f) {
            p = f.absolutePath
        }
        return p ?: ""
    }
}




object ShareDownLoadUtil {

    private var path = Build.BRAND + "_" + Build.MODEL + "_" + "download_sp"
    private val sp: SharedPreferences


    init {
        sp = appContext.getSharedPreferences(path, Context.MODE_PRIVATE)
    }


    fun setPath(path: String) {
        ShareDownLoadUtil.path = path
    }

    fun putBoolean(key: String, value: Boolean) {
        sp.edit().putBoolean(key, value).apply()
    }

    fun getBoolean(key: String, defValue: Boolean): Boolean {
        return sp.getBoolean(key, defValue)
    }

    fun putString(key: String, value: String) {
        sp.edit().putString(key, value).apply()
    }

    fun getString(key: String, defValue: String): String? {
        return sp.getString(key, defValue)
    }

    fun putInt(key: String, value: Int) {
        sp.edit().putInt(key, value).apply()
    }

    fun getInt(key: String, defValue: Int): Int {
        return sp.getInt(key, defValue)
    }

    fun putLong(key: String?, value: Long) {
        sp.edit().putLong(key, value).apply()
    }

    fun getLong(key: String, defValue: Long): Long {
        return sp.getLong(key, defValue)
    }

    fun remove(key: String) {
        sp.edit().remove(key).apply()
    }

    fun clear() {
        sp.edit().clear().apply()
    }


}
相关推荐
SouthBay4932 小时前
PHP内存马：不死马
android·开发语言·php
安於宿命2 小时前
【Linux内核揭秘】深入理解命令行参数和环境变量
android·linux·服务器
Gerry_Liang3 小时前
Android Studio 无法查看Kotlin源码的解决办法
android·kotlin·android studio
IT生活课堂4 小时前
唤醒车机时娱乐屏出现黑屏，卡顿的案例分享
android·智能手机·汽车
翔云API5 小时前
PC端增值税发票识别API-翔云智能财务发票识别OCR接口
android·c语言·开发语言·php
follycat9 小时前
Litctf-web
android·linux·前端·网络安全
慢慢成长的码农9 小时前
安卓取消触摸屏幕的指针效果
android
渗透测试老鸟-九青14 小时前
PHP免杀详细讲解PHP免杀详细讲解
android·开发语言·前端·数据库·sql·安全·web安全
小双14 小时前
Android WebView加载不到cookie
android·webview
Cui晨15 小时前
Android 下载进度条HorizontalProgressView 基础版
android
热门推荐
01前端vue3实现本地及在线文件预览（含pdf/txt/mp3/mp4/docx/xlsx/pptx）02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)04Windows10安装PCL1.14.0及点云配准05制冷毛细管的计算方法介绍06RAG 实践- Ollama+RagFlow 部署本地知识库07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Coze扣子平台完整体验和实践（附国内和国际版对比）09苍穹外卖面试总结10ECharts 地图实战分析：实现一个完整的地图下钻功能