1.修改FileProvider的名称

app/src/main/AndroidManifest.xml

 
         <provider
             android:name="androidx.core.content.FileProvider"
-            android:authorities="com.xhly.manageapp.fileprovider"
+            android:authorities="com.xhkjedu.manageapp.fileprovider"
             android:exported="false"
             android:grantUriPermissions="true">
             <!-- 元数据 -->

app/src/main/java/com/xhly/manageapp/ui/main/activity/MainActivity.kt

 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.graphics.Color
 import android.graphics.drawable.BitmapDrawable
 import com.xhly.corelib.utils.GsonUtils
 import com.xhly.corelib.utils.ImageUtils
 import com.xhly.corelib.utils.LogShow
-import com.xhly.corelib.utils.MD5Utils
+import com.xhly.corelib.utils.ModelNameUtils
 import com.xhly.corelib.utils.SharedPreferencesUtils
 import com.xhly.corelib.utils.SystemUtil
 import com.xhly.manageapp.AppAdapter
 import com.xhly.manageapp.bean.EventLog
 import com.xhly.manageapp.bean.SocketMsgBean
 import com.xhly.manageapp.bean.app.AppInstallBean
-import com.xhly.manageapp.bean.app.AppModel
 import com.xhly.manageapp.bean.log.LogPushBean
 import com.xhly.manageapp.bean.log.LogdOperateBean
 import com.xhly.manageapp.bean.log.UpdateBean
     private var userBean: UserBean? = null
     private var timer: Timer? = null
     private val currentSpUtils by lazy { CurrentAppSharedPreferencesUtils.getInstance(this) }
+
     //标记是否请求了时间策略
-    private var updateTimeFlag=false
+    private var updateTimeFlag = false
+
     //标记是否请求了应用策略，都为真则提示
-    private var updateStrategyFlag=false
+    private var updateStrategyFlag = false
     override fun getBinding() = ActivityMainBinding.inflate(layoutInflater)
 
+    @SuppressLint("CheckResult")
     override fun initData() {
         val json = spUtils.getFromJson(Const.USERINFO, UserBean().javaClass)
         if (json == null) {
             userBean = json as UserBean
         }
         lifecycleScope.launch {
-            withContext(Dispatchers.IO){
+            withContext(Dispatchers.IO) {
                 val file = File(filesDir, "wallpaper.png")
-                if (file.exists()){
+                if (file.exists()) {
                     try {
                         val bitmap = ImageUtils().getBitmapFromFile(file.toString())
-                        withContext(Dispatchers.Main){
+                        withContext(Dispatchers.Main) {
                             try {
-                                mBinding.root.background=BitmapDrawable(resources,bitmap)
-                            }catch (e:Exception){
+                                mBinding.root.background = BitmapDrawable(resources, bitmap)
+                            } catch (e: Exception) {
                                 LogShow("图片设置失败")
                             }
                         }
-                    }catch (e:Exception){
+                    } catch (e: Exception) {
                         LogShow("图片不存在")
                     }
                 }
         }
         viewModel.forceListAppData.observe(this) { modelList ->
             //获得必装应用，未安装或者版本较低则更新，先删除目录中的文件
-            val appList = AppUtils.GetAppList(this)
-            getExternalFilesDir(null)?.let {
-                FileUtils.deleteCurrentFlie(it)
-            }
-            modelList.forEach { app ->
-               try {
-                   //获得已安装的应用判断版本，未安装的则直接静默安装。
-                   val filter = appList.filter { it.packageName.equals(app.appPackage) }
-                   //列表中不存在,或者版本较低则更新
-                   val apkPath = app.apkPath
-                   val appName = app.appName
-                   if (filter.isNotEmpty()) {
-                       val currentApp = filter[0]
-                       if (app.versionNum > currentApp.versionNum) {
-                           //版本低则更新安装。
-                           viewModel.viewModelScope.launch {
-                               AppDownLoadUtils.addToDownloadQueue(apkPath, appName)
-                           }
-                       }
-                   } else {
-                       //不存在，直接下载安装。
-                       viewModel.viewModelScope.launch {
-                           AppDownLoadUtils.addToDownloadQueue(apkPath, appName)
-                       }
-                   }
-               }catch (e:Exception){
-                   LogShow("问题"+e.toString())
-               }
-            }
+            val rxPermissions = RxPermissions(this)
+            rxPermissions.request(Manifest.permission.REQUEST_INSTALL_PACKAGES)
+                .subscribe { granted ->
+                    if (granted || ModelNameUtils.IS_LianxX505f()) {
+                        // 权限已授予，执行安装操作
+                        val appList = AppUtils.GetAppList(this)
+                        getExternalFilesDir(null)?.let {
+                            FileUtils.deleteCurrentFlie(it)
+                        }
+                        modelList.forEach { app ->
+                            try {
+                                //获得已安装的应用判断版本，未安装的则直接静默安装。
+                                val filter =
+                                    appList.filter { it.packageName.equals(app.appPackage) }
+                                //列表中不存在,或者版本较低则更新
+                                val apkPath = app.apkPath
+                                val appName = app.appName
+                                if (filter.isNotEmpty()) {
+                                    val currentApp = filter[0]
+                                    if (app.versionNum > currentApp.versionNum) {
+                                        //版本低则更新安装。
+                                        viewModel.viewModelScope.launch {
+                                            AppDownLoadUtils.addToDownloadQueue(apkPath, appName)
+                                        }
+                                    }
+                                } else {
+                                    //不存在，直接下载安装。
+                                    viewModel.viewModelScope.launch {
+                                        AppDownLoadUtils.addToDownloadQueue(apkPath, appName)
+                                    }
+                                }
+                            } catch (e: Exception) {
+                                LogShow("问题" + e.toString())
+                            }
+                        }
+                    } else {
+                        // 用户拒绝了安装权限，处理相应逻辑
+                        viewModel.getAppList()
+                    }
+
+                }
         }
 
         viewModel.strategyData.observe(this) {
             spUtils.saveJson(Const.STRATEGYBEANKEY, it)
             StrategyUtils.setStrategy(it)
             useTimeStrategy()
-            updateStrategyFlag=true
-            if (updateTimeFlag){
+            updateStrategyFlag = true
+            if (updateTimeFlag) {
                 showSucessToast()
             }
         }
         viewModel.appStrategyData.observe(this) {
             //存储app时间策略
             spUtils.saveJson(Const.APPSTRATEGYBEANKEY, it)
-            updateTimeFlag=true
-            if (updateStrategyFlag){
+            updateTimeFlag = true
+            if (updateStrategyFlag) {
                 showSucessToast()
             }
         }
                             transition: Transition<in Drawable>?
                         ) {
                             mBinding.root.background = resource
-                            val imageUtil=ImageUtils()
-                            imageUtil.saveBitmapToFile(imageUtil.drawableToBitmap(resource), File(filesDir,"wallpaper.png"))
+                            val imageUtil = ImageUtils()
+                            imageUtil.saveBitmapToFile(
+                                imageUtil.drawableToBitmap(resource),
+                                File(filesDir, "wallpaper.png")
+                            )
                         }
                     })
             }
                 Toast(getString(R.string.codeerror))
             }
         }
-        viewModel.lockResultData.observe(this){
-            if (it){
+        viewModel.lockResultData.observe(this) {
+            if (it) {
                 spUtils.setParam(Const.DISABLEPAD, true)
                 startIntentActivity(MainActivity().javaClass)
                 val appList = AppUtils.GetAppList(this)
                 StrategyUtils.clearMemory(this, appList)
             }
         }
-        viewModel.resetlResultData.observe(this){
-            if (it){
+        viewModel.resetlResultData.observe(this) {
+            if (it) {
                 ManageApplication.launchFactoryReset()
             }
         }
-        viewModel.logResultData.observe(this){
-            if (it.enableFlag){
-                when(it.pushType){
-                    2->{
+        viewModel.logResultData.observe(this) {
+            if (it.enableFlag) {
+                when (it.pushType) {
+                    2 -> {
                         spUtils.setParam(Const.DISABLEPAD, false)
                         useTimeStrategy()
                     }
-                    3->{
+
+                    3 -> {
                         val appList = AppUtils.GetAppList(this)
                         StrategyUtils.clearMemory(this, appList)
                         spUtils.setParam(Const.DISABLEPAD, true)
                         startIntentActivity(MainActivity().javaClass)
                     }
-                    4->{
+
+                    4 -> {
                         //请求接口更新策略
                         updateAllStrategy()
                     }
-                    5->{
+
+                    5 -> {
                         ManageApplication.rebootDevice()
                     }
-                    6->{
+
+                    6 -> {
                         ManageApplication.launchFactoryReset()
                     }
-                    7->{
-                        currentSpUtils.setParam(Const.EXIT_CONTROL,true)
+
+                    7 -> {
+                        currentSpUtils.setParam(Const.EXIT_CONTROL, true)
                         StrategyUtils.releaseControl(this)
                     }
-                    8->{
+
+                    8 -> {
                         loginOut()
                     }
                 }
             }
         }
-        viewModel.logEventData.observe(this){
-            when(it.logEventType){
-                EventLog.ACCOUNTQUITEVENT->{
+        viewModel.logEventData.observe(this) {
+            when (it.logEventType) {
+                EventLog.ACCOUNTQUITEVENT -> {
                     loginOutSucess()
                 }
             }
 
     private fun showSucessToast() {
         Toaster.show(R.string.updatetips)
-        updateStrategyFlag=false
-        updateTimeFlag=false
+        updateStrategyFlag = false
+        updateTimeFlag = false
     }
 
 
         onBackPressedDispatcher.addCallback {
             //屏蔽返回键
             Const.backNum++
-            if (Const.backNum>Const.UPDATESTRATEGYNUM){
-                Const.backNum=0
+            if (Const.backNum > Const.UPDATESTRATEGYNUM) {
+                Const.backNum = 0
                 Toaster.show(R.string.updatetips)
                 updateAllStrategy()
             }
         getLocation()
     }
 
-    private fun updateAllStrategy(){
+    private fun updateAllStrategy() {
         userBean?.let {
             Const.USERID = it.userid
             Const.USERNAME = it.username.toString()
                 val removeList = arrayListOf<AppInfo>()
                 currentList.forEach { pkg ->
                     //除了管控之类的我们的app之外的预装都不在统计范围
-                    if (Const.CURRENTAPPPKG!=pkg&&Const.STOREAPPPKG!=pkg) {
+                    if (Const.CURRENTAPPPKG != pkg && Const.STOREAPPPKG != pkg) {
                         appList.filter { it.packageName == pkg }.forEach {
                             removeList.add(it)
                         }
 
             }
             val userBean = spUtils.getFromJson(Const.USERINFO, UserBean().javaClass) as UserBean
-            val appInstallList= arrayListOf<AppInstallBean>()
+            val appInstallList = arrayListOf<AppInstallBean>()
             appList.forEach {
-                val appInstallBean=AppInstallBean()
-                appInstallBean.userid=userBean.userid
-                appInstallBean.appName=it.name
-                appInstallBean.appVersion=it.versionName
-                appInstallBean.appNum=it.versionNum
-                appInstallBean.appPackage=it.packageName
-                ManageApplication.getDeviceInfo()?.let {sn->
+                val appInstallBean = AppInstallBean()
+                appInstallBean.userid = userBean.userid
+                appInstallBean.appName = it.name
+                appInstallBean.appVersion = it.versionName
+                appInstallBean.appNum = it.versionNum
+                appInstallBean.appPackage = it.packageName
+                ManageApplication.getDeviceInfo()?.let { sn ->
                     appInstallBean.sn = sn
                 }
-                ManageApplication.getDeviceInfo(1)?.let {mac->
+                ManageApplication.getDeviceInfo(1)?.let { mac ->
                     appInstallBean.mac = mac
                 }
-                appInstallBean.schoolid=userBean.schoolid
-                appInstallBean.regionid=userBean.regionid
+                appInstallBean.schoolid = userBean.schoolid
+                appInstallBean.regionid = userBean.regionid
                 appInstallList.add(appInstallBean)
             }
 
             viewModel.updateAppInstallInfo(appInstallList)
-        }catch (e:Exception){
+        } catch (e: Exception) {
 
         }
     }
     }
 
 
-
     private fun updateMcApp() {
         //每天请求一次app更新接口，这个接口是用于提交管控自身的版本信息统计
         try {
                 updateBean.schoolid = userBean.schoolid
                 updateBean.userid = userBean.userid
                 updateBean.regionid = userBean.regionid
-               viewModel.updateMcApp(updateBean)
+                viewModel.updateMcApp(updateBean)
             }
         } catch (e: Exception) {
 
                     data.doEvent = EventLog.APPINSTALLEVENT
                     viewModel.eventLog(data)
                     updateAppInstallInfo()
-                }catch (e:Exception){
+                } catch (e: Exception) {
 
                 }
             }
 
             Const.CODE3002.toString() -> {
                 val deviceInfo = ManageApplication.getDeviceInfo()
-                val sn= deviceInfo ?: ""
+                val sn = deviceInfo ?: ""
                 viewModel.postExitLocked(sn)
             }
 
             Const.CODE3006.toString() -> {
                 val deviceInfo = ManageApplication.getDeviceInfo()
-                val sn= deviceInfo ?: ""
+                val sn = deviceInfo ?: ""
                 viewModel.postExitReseted(sn)
             }
+            Const.INSTALL_FORCEAPP->{
+                ManageApplication.installPackage(uiEvent.message)
+            }
         }
     }
 
     private fun postLogPush(pushType: Int) {
         val pushBean = LogPushBean()
         pushBean.pushType = pushType
-        pushBean.sn=ManageApplication.getDeviceInfo()?:""
+        pushBean.sn = ManageApplication.getDeviceInfo() ?: ""
         viewModel.postLogPushAdd(pushBean)
     }
 
             //获得预装应用和商店应用，商店应用和预装重叠直接显示，其余预装直接隐藏
             var schoolDeviceSetBean: SchoolDeviceSetBean? = null
             schoolDeviceSetBean = StrategyUtils.getSchoolDeviceSetBean(this)
-            val storeList= arrayListOf<String>()
+            val storeList = arrayListOf<String>()
             try {
                 val fromJson = spUtils.getFromJson(Const.APPSTOREKEY, ArrayList<String>().javaClass)
-                if (fromJson!=null){
+                if (fromJson != null) {
                     storeList.addAll(fromJson as ArrayList<String>)
                 }
-            }catch (e:Exception){
+            } catch (e: Exception) {
                 LogShow("商店应用为空")
             }
             dataList.clear()
                     ) as ArrayList<String>
                 currentList.forEach { pkg ->
                     //学校控制之外的预装应用加入移除集合，应用商店列表包含的不需要加入移除集合
-                    if (!Const.schoolSetAppList.contains(pkg)&&!storeList.contains(pkg)) {
+                    if (!Const.schoolSetAppList.contains(pkg) && !storeList.contains(pkg)) {
                         appList.filter { it.packageName == pkg }.forEach {
                             removeList.add(it)
                         }
 
             }
             //如果包含应用商店也移除，因为会在自定义app中添加
-            appList.filter { it.packageName == Const.STOREAPPPKG}.forEach {
+            appList.filter { it.packageName == Const.STOREAPPPKG }.forEach {
                 removeList.add(it)
             }
             //移除学校控制之外预装应用
             .setAlign(CustomDialog.ALIGN.CENTER).show()
     }
 
-    private fun loginOut(hasUser:Boolean=true) {
+    private fun loginOut(hasUser: Boolean = true) {
         //没有用户信息时，判断为初次调用，直接跳转登录页面
-        if (hasUser){
+        if (hasUser) {
             //调用接口传递退出事件，成功则退出登录
             val data = LogdOperateBean()
             ManageApplication.getDeviceInfo()?.let {
             data.comm = "退出登录"
             data.doEvent = EventLog.ACCOUNTQUITEVENT
             viewModel.eventLog(data)
-        }else{
+        } else {
             loginOutSucess()
         }
     }
 
-    private fun loginOutSucess(){
+    private fun loginOutSucess() {
         WorkManager.getInstance(this).cancelAllWork()
         deleteSharedPreferences(SharedPreferencesUtils.SP_FILE_NAME)
         Const.USERID = null

app/src/main/java/com/xhly/manageapp/utils/AppDownLoadUtils.kt

 import com.billbook.lib.downloader.Download
 import com.billbook.lib.downloader.Downloader
 import com.xhly.corelib.Const
+import com.xhly.corelib.eventbus.UIEvent
 import com.xhly.corelib.utils.LogShow
 import com.xhly.manageapp.ManageApplication
 import kotlinx.coroutines.Dispatchers
                         successful = execute.isSuccessful()
                         LogShow("下载结果" + successful)
                         if (successful) {
-                            withContext(Dispatchers.Main) {
-                                ManageApplication.installPackage(File(name, "$appName.apk").toString())
-                            }
+                            UIEvent(Const.INSTALL_FORCEAPP).setMessage(File(name, "$appName.apk").toString()).post()
                         } else {
                             currentRetry++
                         }
             }
         }
     }
+
+    data class DownloadItem(val url: String, val tag: String, val savepath: String, var progress: Int)
+
+    interface DownloadCallback {
+        fun onSuccess(downItem: DownloadItem)
+    }
 }

app/src/main/java/com/xhly/manageapp/utils/DownLoadUtils.kt

+import android.util.Log
+import com.billbook.lib.downloader.Download
+import com.billbook.lib.downloader.Downloader
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.LinkedList
+import java.util.Queue
+
+object DownLoadUtils {
+    val queue: Queue<DownloadItem> = LinkedList()
+    var callbackList = mutableListOf<DownloadCallback>()
+    var isRunning = false
+
+    fun isEmpty(): Boolean {
+        return queue.isEmpty()
+    }
+
+    /**
+     * 页面启动 添加回调
+     */
+    fun addCallback(callback: DownloadCallback) {
+        callbackList.add(callback)
+    }
+
+
+    /**
+     * 页面关闭 删除回调
+     */
+    fun removeCallback(callback: DownloadCallback) {
+        callbackList.remove(callback)
+    }
+
+
+    /**
+     * 下载文件
+     */
+    fun addDownload(url: String, tag: String, savepath: String) {
+        var isHave = false
+        for (element in queue) {
+            if (element.tag === tag) {
+                isHave = true
+            }
+        }
+        if (!isHave) {
+            queue.add(DownloadItem(url, tag, savepath, 0))
+        } else {
+            for (downloadCallback in callbackList) {
+                downloadCallback.onFailure(DownloadItem(url, tag, savepath, 0), "已经在下载队列")
+            }
+        }
+        downloadAction()
+    }
+
+    private fun downloadAction() {
+        if (isRunning) {
+            return
+        }
+        val coroutineScope = CoroutineScope(Dispatchers.IO)
+        coroutineScope.launch {
+            while (queue.size > 0) {
+                isRunning = true
+                val downItem = queue.peek()
+                downItem?.let {
+                    try {
+                        val downloader = Downloader.Builder().build()
+                        val request = Download.Request.Builder()
+                            .url(it.url)
+                            .into(it.savepath)
+                            .build()
+                        val call = downloader.newCall(request)
+                        call.execute(object : Download.Callback {
+                            override fun onStart(call: Download.Call) {
+                                for (downloadCallback in callbackList) {
+                                    downloadCallback.onStart(downItem)
+                                }
+                            }
+
+                            override fun onSuccess(call: Download.Call, response: Download.Response) {
+                                queue.poll()
+                                for (downloadCallback in callbackList) {
+                                    downloadCallback.onSuccess(downItem)
+                                }
+                            }
+
+                            override fun onFailure(call: Download.Call, response: Download.Response) {
+                                queue.poll()
+                                for (downloadCallback in callbackList) {
+                                    downloadCallback.onFailure(downItem, response.message!!)
+                                }
+                            }
+
+                            override fun onLoading(call: Download.Call, current: Long, total: Long) {
+                                val progress = (current * 100 / total).toInt()
+//                                Log.i("详情", "$progress ${downItem.progress} ${callbackList.size}")
+                                if (progress != downItem.progress) {
+                                    for (downloadCallback in callbackList) {
+                                        downItem.progress = progress
+                                        downloadCallback.onLoading(downItem)
+                                    }
+                                }
+                            }
+                        })
+                    } catch (e: Exception) {
+                        queue.poll()
+                        for (downloadCallback in callbackList) {
+                            downloadCallback.onFailure(downItem, e.toString())
+                        }
+                    }
+                }
+
+            }
+            isRunning = false
+        }
+
+    }
+}
+
+data class DownloadItem(val url: String, val tag: String, val savepath: String, var progress: Int)
+
+interface DownloadCallback {
+    fun onStart(downItem: DownloadItem)
+    fun onSuccess(downItem: DownloadItem)
+    fun onFailure(downItem: DownloadItem, errMsg: String)
+    fun onLoading(downItem: DownloadItem)
+}

app/src/main/res/xml/file_paths.xml

     <paths>
         <external-path path="Android/data/com.example.iu/" name="files_root" />
         <external-path path="." name="external_storage_root" />
+        <files-path name="data" path="."/>
     </paths>
 </resources>

corelib/src/main/java/com/xhly/corelib/Const.kt

      */
     const val ACCOUNTLOGINOUT = "ACCOUNTLOGINOUT"
 
-
+    /**
+     * 调用安装app方法
+     */
+    const val INSTALL_FORCEAPP="INSTALL_FORCEAPP"
     /**
      * 存储应用商店应用包名集合
      */