1.flow默认值设置为null

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

     private var regioncode = ""
     //如果次数大于10则可以打开设置页面
     private var showSettingNum=0
-
+    private var waitDialog:WaitDialog?=null
     override fun getBinding() = ActivityLoginBinding.inflate(layoutInflater)
 
     override fun initData() {
        viewModel.loginData.observe(this){
-           WaitDialog.dismiss()
+           waitDialog?.doDismiss()
            if (it.xhlyLoginSucess){
                loginSucess(it)
            }else{
         }
         lifecycleScope.launch {
             viewModel.logResultData.collect{
-                if (it.enableFlag){
-                    when(it.pushType){
-                        2->{
-                            spUtils.setParam(Const.DISABLEPAD, false)
-                            useTimeStrategy()
-                        }
-                        3->{
-                            spUtils.setParam(Const.DISABLEPAD, true)
-                            useTimeStrategy()
-                        }
-                        5->{
-                            ManageApplication.rebootDevice()
-                        }
-                        6->{
-                            ManageApplication.launchFactoryReset()
-                        }
-                        7->{
-                            currentSpUtils.setParam(Const.EXIT_CONTROL,true)
-                            StrategyUtils.releaseControl(this@LoginActivity)
+                it?.let {
+                    if (it.enableFlag){
+                        when(it.pushType){
+                            2->{
+                                spUtils.setParam(Const.DISABLEPAD, false)
+                                useTimeStrategy()
+                            }
+                            3->{
+                                spUtils.setParam(Const.DISABLEPAD, true)
+                                useTimeStrategy()
+                            }
+                            5->{
+                                ManageApplication.rebootDevice()
+                            }
+                            6->{
+                                ManageApplication.launchFactoryReset()
+                            }
+                            7->{
+                                currentSpUtils.setParam(Const.EXIT_CONTROL,true)
+                                StrategyUtils.releaseControl(this@LoginActivity)
+                            }
                         }
                     }
                 }
         ManageApplication.getDeviceInfo()?.let {
             loginBean.sn=it
         }
-        WaitDialog.setMessage("正在登陆").show()
+         waitDialog = WaitDialog.setMessage("正在登陆").show()
         viewModel.login(loginBean)
     }
 

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

         viewModel.viewModelScope.launch {
             //在这里执行获得策略的操作，用来处理在后台时的数据处理。
             viewModel.listAppData.collect{ modelList ->
-                //存储商店应用包名到本地,并且存储商店应用列表数据到本地集合
-                val appNameList = arrayListOf<String>()
-                val whiteList = arrayListOf<String>()
-                modelList.forEach {
-                    appNameList.add(it.appPackage)
-                    if (it.whited == 1) {
-                        whiteList.add(it.appPackage)
+                modelList?.let {
+                    //存储商店应用包名到本地,并且存储商店应用列表数据到本地集合
+                    val appNameList = arrayListOf<String>()
+                    val whiteList = arrayListOf<String>()
+                    modelList.forEach {
+                        appNameList.add(it.appPackage)
+                        if (it.whited == 1) {
+                            whiteList.add(it.appPackage)
+                        }
                     }
-                }
-                ManageApplication.addAppWhiteRule(whiteList)
-                spUtils.saveJson(Const.APPSTOREDATAKEY,modelList)
-                //获得应用集合，必装应用和推荐应用，再加上预装应用(预装应用直接隐藏)，其余应用需要静默卸载,必装应用需要进行静默下载和安装。安装应用从forceapp接口获取
-                val appList = AppUtils.GetAppList(this@MainActivity)
-                val firstAppList = arrayListOf<String>()
-                try {
-                    //获得预装应用的包名
-                    val currentList =
-                        currentSpUtils.getFromJson(
-                            Const.FIRSTAPPLIST,
-                            ArrayList<String>().javaClass
-                        ) as ArrayList<String>
-                    firstAppList.addAll(currentList)
-                } catch (e: Exception) {
-                    LogShow("冻结失败" + e.toString())
-                }
-                appList.forEach { app ->
-                    unInstallAppList.clear()
-                    val filter = modelList.filter { it.appPackage.equals(app.packageName) }
-                    val appInfos = firstAppList.filter { app.packageName.equals(it) }
-                    //接口列表以及初始化列表中不存在则将应用冻结或者卸载,目前是卸载
-                    LogShow("${app.name},被冻结" + (filter.isEmpty() && appInfos.isEmpty()))
-                    if (filter.isEmpty() && appInfos.isEmpty()) {
-                        //ManageApplication.setPackageEnabled(app.packageName, (filter.isNotEmpty()))
-                        unInstallAppList.add(app)
-                        ManageApplication.uninstallPackage(app.packageName)
+                    ManageApplication.addAppWhiteRule(whiteList)
+                    spUtils.saveJson(Const.APPSTOREDATAKEY,modelList)
+                    //获得应用集合，必装应用和推荐应用，再加上预装应用(预装应用直接隐藏)，其余应用需要静默卸载,必装应用需要进行静默下载和安装。安装应用从forceapp接口获取
+                    val appList = AppUtils.GetAppList(this@MainActivity)
+                    val firstAppList = arrayListOf<String>()
+                    try {
+                        //获得预装应用的包名
+                        val currentList =
+                            currentSpUtils.getFromJson(
+                                Const.FIRSTAPPLIST,
+                                ArrayList<String>().javaClass
+                            ) as ArrayList<String>
+                        firstAppList.addAll(currentList)
+                    } catch (e: Exception) {
+                        LogShow("冻结失败" + e.toString())
                     }
+                    appList.forEach { app ->
+                        unInstallAppList.clear()
+                        val filter = modelList.filter { it.appPackage.equals(app.packageName) }
+                        val appInfos = firstAppList.filter { app.packageName.equals(it) }
+                        //接口列表以及初始化列表中不存在则将应用冻结或者卸载,目前是卸载
+                        LogShow("${app.name},被冻结" + (filter.isEmpty() && appInfos.isEmpty()))
+                        if (filter.isEmpty() && appInfos.isEmpty()) {
+                            //ManageApplication.setPackageEnabled(app.packageName, (filter.isNotEmpty()))
+                            unInstallAppList.add(app)
+                            ManageApplication.uninstallPackage(app.packageName)
+                        }
+                    }
+
                 }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.forceListAppData.collect { modelList ->
-                //获得必装应用，未安装或者版本较低则更新，先删除目录中的文件
-                val rxPermissions = RxPermissions(this@MainActivity)
-                rxPermissions.request(Manifest.permission.REQUEST_INSTALL_PACKAGES)
-                    .subscribe { granted ->
-                        if (granted || ModelNameUtils.IS_LianxX505f()) {
-                            // 权限已授予，执行安装操作
-                            val appList = AppUtils.GetAppList(this@MainActivity)
-                            getExternalFilesDir(null)?.let {
-                                FileUtils.deleteCurrentFlie(it)
-                            }
-                            val file = getExternalFilesDir(null)
-                            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) {
-                                            //版本低则更新安装。
-                                            //AppDownLoadUtils.addToDownloadQueue(apkPath, appName,app.appPackage)
-                                            DownLoadUtils.addDownload(apkPath,app.appPackage,File(file.toString(), "$appName.apk").toString(),app.appPackage)
-                                        }
-                                    } else {
-                                        //不存在，直接下载安装。
-                                        //AppDownLoadUtils.addToDownloadQueue(apkPath, appName,app.appPackage)
-                                        DownLoadUtils.addDownload(apkPath,app.appPackage,File(file.toString(), "$appName.apk").toString(),app.appPackage)
-                                    }
-                                } catch (e: Exception) {
-                                    LogShow("问题" + e.toString())
-                                }
-                            }
-                        } else {
-                            // 用户拒绝了安装权限，处理相应逻辑
-                            viewModel.getAppList()
-                        }
-
-                    }
+               modelList?.let {
+                   //获得必装应用，未安装或者版本较低则更新，先删除目录中的文件
+                   val rxPermissions = RxPermissions(this@MainActivity)
+                   rxPermissions.request(Manifest.permission.REQUEST_INSTALL_PACKAGES)
+                       .subscribe { granted ->
+                           if (granted || ModelNameUtils.IS_LianxX505f()) {
+                               // 权限已授予，执行安装操作
+                               val appList = AppUtils.GetAppList(this@MainActivity)
+                               getExternalFilesDir(null)?.let {
+                                   FileUtils.deleteCurrentFlie(it)
+                               }
+                               val file = getExternalFilesDir(null)
+                               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) {
+                                               //版本低则更新安装。
+                                               //AppDownLoadUtils.addToDownloadQueue(apkPath, appName,app.appPackage)
+                                               DownLoadUtils.addDownload(apkPath,app.appPackage,File(file.toString(), "$appName.apk").toString(),app.appPackage)
+                                           }
+                                       } else {
+                                           //不存在，直接下载安装。
+                                           //AppDownLoadUtils.addToDownloadQueue(apkPath, appName,app.appPackage)
+                                           DownLoadUtils.addDownload(apkPath,app.appPackage,File(file.toString(), "$appName.apk").toString(),app.appPackage)
+                                       }
+                                   } catch (e: Exception) {
+                                       LogShow("问题" + e.toString())
+                                   }
+                               }
+                           } else {
+                               // 用户拒绝了安装权限，处理相应逻辑
+                               viewModel.getAppList()
+                           }
+
+                       }
+
+               }
             }
 
         }
 
         viewModel.viewModelScope.launch {
             viewModel.strategyData.collect {
-                spUtils.saveJson(Const.STRATEGYBEANKEY, it)
-                StrategyUtils.setStrategy(it)
-                useTimeStrategy()
-                updateStrategyFlag = true
-                if (updateTimeFlag) {
-                    showSucessToast()
-                }
+              it?.let {
+                  spUtils.saveJson(Const.STRATEGYBEANKEY, it)
+                  StrategyUtils.setStrategy(it)
+                  useTimeStrategy()
+                  updateStrategyFlag = true
+                  if (updateTimeFlag) {
+                      showSucessToast()
+                  }
+
+              }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.appStrategyData.collect {
                 //存储app时间策略
-                spUtils.saveJson(Const.APPSTRATEGYBEANKEY, it)
-                updateTimeFlag = true
-                if (updateStrategyFlag) {
-                    showSucessToast()
-                }
+               it?.let {
+                   spUtils.saveJson(Const.APPSTRATEGYBEANKEY, it)
+                   updateTimeFlag = true
+                   if (updateStrategyFlag) {
+                       showSucessToast()
+                   }
+               }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.padInfoData.collect {
                 //存储信息上传时间
-                if (it) {
-                    spUtils.setParam(Const.PADINFOTIMEKEY, System.currentTimeMillis())
+                it?.let {
+                    if (it) {
+                        spUtils.setParam(Const.PADINFOTIMEKEY, System.currentTimeMillis())
+                    }
                 }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.loginOutData.collect {
-                if (it) {
-                    loginOut()
-                } else {
-                    Toast(getString(R.string.codeerror))
+                it?.let {
+                    if (it) {
+                        loginOut()
+                    } else {
+                        Toast(getString(R.string.codeerror))
+                    }
                 }
             }
         }
         viewModel.viewModelScope.launch {
             viewModel.updateInfoData.collect {
                 //成功则保存不在提交
-                if (it) {
+                if (it!=null&&it) {
                     spUtils.setParam(Const.PADUPDATETIMEKEY, System.currentTimeMillis())
                 }
             }
         }
 
         viewModel.viewModelScope.launch {
-
             viewModel.schoolSetData.collect {
-                spUtils.saveJson(Const.SCHOOLSETDEVICE, it)
-                initSchoolSet(it)
-                mBinding.rv.visibility=View.VISIBLE
-                updateAppRv()
+                it?.let {
+                    spUtils.saveJson(Const.SCHOOLSETDEVICE, it)
+                    initSchoolSet(it)
+                    mBinding.rv.visibility=View.VISIBLE
+                    updateAppRv()
+                }
             }
         }
 
         viewModel.viewModelScope.launch {
 
             viewModel.netWhiteListData.collect {
-                StrategyUtils.setNetWhiteList(it)
+               it?.let {
+                   StrategyUtils.setNetWhiteList(it)
+               }
             }
 
         }
         viewModel.viewModelScope.launch {
 
             viewModel.logResultData.collect {
-                if (it.enableFlag) {
-                    when (it.pushType) {
-                        2 -> {
-                            spUtils.setParam(Const.DISABLEPAD, false)
-                            useTimeStrategy()
-                        }
+                it?.let {
+                    if (it.enableFlag) {
+                        when (it.pushType) {
+                            2 -> {
+                                spUtils.setParam(Const.DISABLEPAD, false)
+                                useTimeStrategy()
+                            }
 
-                        3 -> {
-                            val appList = AppUtils.GetAppList(this@MainActivity)
-                            StrategyUtils.clearMemory(this@MainActivity, appList)
-                            spUtils.setParam(Const.DISABLEPAD, true)
-                            startIntentActivity(MainActivity().javaClass)
-                        }
+                            3 -> {
+                                val appList = AppUtils.GetAppList(this@MainActivity)
+                                StrategyUtils.clearMemory(this@MainActivity, appList)
+                                spUtils.setParam(Const.DISABLEPAD, true)
+                                startIntentActivity(MainActivity().javaClass)
+                            }
 
-                        4 -> {
-                            //请求接口更新策略
-                            updateAllStrategy()
-                        }
+                            4 -> {
+                                //请求接口更新策略
+                                updateAllStrategy()
+                            }
 
-                        5 -> {
-                            ManageApplication.rebootDevice()
-                        }
+                            5 -> {
+                                ManageApplication.rebootDevice()
+                            }
 
-                        6 -> {
-                            loginOutSucess()
-                            ManageApplication.launchFactoryReset()
-                        }
+                            6 -> {
+                                loginOutSucess()
+                                ManageApplication.launchFactoryReset()
+                            }
 
-                        7 -> {
-                            currentSpUtils.setParam(Const.EXIT_CONTROL, true)
-                            StrategyUtils.releaseControl(this@MainActivity)
-                        }
+                            7 -> {
+                                currentSpUtils.setParam(Const.EXIT_CONTROL, true)
+                                StrategyUtils.releaseControl(this@MainActivity)
+                            }
 
-                        8 -> {
-                            loginOut()
+                            8 -> {
+                                loginOut()
+                            }
                         }
                     }
+
                 }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.logEventData.collect {
-                when (it.logEventType) {
-                    EventLog.ACCOUNTQUITEVENT -> {
-                        loginOutSucess()
-                    }
-                }
+               it?.let {
+                   when (it.logEventType) {
+                       EventLog.ACCOUNTQUITEVENT -> {
+                           loginOutSucess()
+                       }
+                   }
+               }
             }
         }
 
         viewModel.viewModelScope.launch {
             viewModel.autoAppData.collect{
-                //连接不为空，并且应用已安装则跳转应用
-                /*  it.authUrl="com.xhkjedu.xh_control_browser.MainActivity"
-                  it.appPackage="com.xhkjedu.xh_control_browser"*/
-                LogShow("锁定了吧"+mainLockFlag)
-                if (!mainLockFlag){
-                    if (it.authUrl!=null&&AppUtils.isAppInstalled(this@MainActivity,it.appPackage)){
-                        spUtils.saveJson(Const.AUTOAPPKEY,it)
-                        startAutoApp(it)
-                    }else{
-                        try {
-                            val autoAppBean = spUtils.getFromJson(Const.AUTOAPPKEY, AutoAppBean().javaClass) as AutoAppBean
-                            if (autoAppBean.authUrl!=null&&AppUtils.isAppInstalled(this@MainActivity,autoAppBean.appPackage)&&!it.netSucessFlag){
-                                startAutoApp(autoAppBean)
-                            }else{
+                it?.let {
+                    //连接不为空，并且应用已安装则跳转应用
+                    /*  it.authUrl="com.xhkjedu.xh_control_browser.MainActivity"
+                      it.appPackage="com.xhkjedu.xh_control_browser"*/
+                    LogShow("锁定了吧"+mainLockFlag)
+                    if (!mainLockFlag){
+                        if (it.authUrl!=null&&AppUtils.isAppInstalled(this@MainActivity,it.appPackage)){
+                            spUtils.saveJson(Const.AUTOAPPKEY,it)
+                            startAutoApp(it)
+                        }else{
+                            try {
+                                val autoAppBean = spUtils.getFromJson(Const.AUTOAPPKEY, AutoAppBean().javaClass) as AutoAppBean
+                                if (autoAppBean.authUrl!=null&&AppUtils.isAppInstalled(this@MainActivity,autoAppBean.appPackage)&&!it.netSucessFlag){
+                                    startAutoApp(autoAppBean)
+                                }else{
+                                    canClickFlag=true
+                                }
+                            }catch (e:Exception){
                                 canClickFlag=true
                             }
-                        }catch (e:Exception){
-                            canClickFlag=true
                         }
+                    }else{
+                        autoAppFlag=false
+                        startIntentActivity(MainActivity().javaClass)
                     }
-                }else{
-                    autoAppFlag=false
-                    startIntentActivity(MainActivity().javaClass)
+
                 }
-            }
+             }
         }
         getLocation()
         startWorkManager()

app/src/main/java/com/xhly/manageapp/ui/main/viewmodel/MainViewModel.kt

     val wallpaperData: LiveData<WallpaperBean> = wallpaper
 
 
-    private val listData =MutableStateFlow(ArrayList<AppModel>())
-    val listAppData: Flow<ArrayList<AppModel>> = listData.asStateFlow()
+    private val listData =MutableStateFlow<ArrayList<AppModel>?>(null)
+    val listAppData: Flow<ArrayList<AppModel>?> = listData.asStateFlow()
 
-    private val forceData =MutableStateFlow(ArrayList<AppModel>())
-    val forceListAppData: Flow<ArrayList<AppModel>> = forceData.asStateFlow()
+    private val forceData =MutableStateFlow<ArrayList<AppModel>?>(null)
+    val forceListAppData: Flow<ArrayList<AppModel>?> = forceData.asStateFlow()
 
-    private val strategy = MutableStateFlow(StrategyBean())
-    val strategyData: Flow<StrategyBean> = strategy.asStateFlow()
+    private val strategy = MutableStateFlow<StrategyBean?>(null)
+    val strategyData: Flow<StrategyBean?> = strategy.asStateFlow()
 
-    private val appStrategy = MutableStateFlow(ArrayList<AppTimeManageBean>())
-    val appStrategyData: Flow<ArrayList<AppTimeManageBean>> = appStrategy.asStateFlow()
+    private val appStrategy = MutableStateFlow<ArrayList<AppTimeManageBean>?>(null)
+    val appStrategyData: Flow<ArrayList<AppTimeManageBean>?> = appStrategy.asStateFlow()
 
-    private val padInfo = MutableStateFlow(false)
-    val padInfoData: Flow<Boolean> = padInfo.asStateFlow()
+    private val padInfo = MutableStateFlow<Boolean?>(null)
+    val padInfoData: Flow<Boolean?> = padInfo.asStateFlow()
 
-    private val updateInfo =MutableStateFlow(false)
-    val updateInfoData: Flow<Boolean> = updateInfo.asStateFlow()
+    private val updateInfo =MutableStateFlow<Boolean?>(null)
+    val updateInfoData: Flow<Boolean?> = updateInfo.asStateFlow()
 
-    private val loginOut =MutableStateFlow(false)
-    val loginOutData:  Flow<Boolean> = loginOut.asStateFlow()
+    private val loginOut =MutableStateFlow<Boolean?>(null)
+    val loginOutData:  Flow<Boolean?> = loginOut.asStateFlow()
 
-    private val schoolSet = MutableStateFlow(SchoolDeviceSetBean())
-    val schoolSetData: Flow<SchoolDeviceSetBean> = schoolSet.asStateFlow()
+    private val schoolSet = MutableStateFlow<SchoolDeviceSetBean?>(null)
+    val schoolSetData: Flow<SchoolDeviceSetBean?> = schoolSet.asStateFlow()
 
 
-    private val netWhiteList = MutableStateFlow(ArrayList<String>())
-    val netWhiteListData: Flow<ArrayList<String>> = netWhiteList.asStateFlow()
+    private val netWhiteList = MutableStateFlow<ArrayList<String>?>(null)
+    val netWhiteListData: Flow<ArrayList<String>?> = netWhiteList.asStateFlow()
 
 
 

app/src/main/java/com/xhly/manageapp/viewmodel/BaseViewModel.kt

     private val logEventResult = MutableLiveData<LogEventBean>()
     val logEventData: LiveData<LogEventBean> = logEventResult
         */
-    private val logResult = MutableStateFlow(LogPushResultBean())
-    val logResultData: Flow<LogPushResultBean> = logResult.asStateFlow()
+    private val logResult = MutableStateFlow<LogPushResultBean?>(null)
+    val logResultData: Flow<LogPushResultBean?> = logResult.asStateFlow()
 
-    private val logEventResult =MutableStateFlow(LogEventBean())
-    val logEventData: Flow<LogEventBean> = logEventResult.asStateFlow()
+    private val logEventResult =MutableStateFlow<LogEventBean?>(null)
+    val logEventData: Flow<LogEventBean?> = logEventResult.asStateFlow()
 
 
-    private val autoAppResult = MutableStateFlow(AutoAppBean())
-    val autoAppData: Flow<AutoAppBean> = autoAppResult.asStateFlow()
+    private val autoAppResult = MutableStateFlow<AutoAppBean?>(null)
+    val autoAppData: Flow<AutoAppBean?> = autoAppResult.asStateFlow()
 
     /**
      * 解除当前锁屏
      */
     fun eventLog(operateBean: LogdOperateBean) {
         launchUI {
-            var result = logService.postLogdoperateAdd(operateBean)
+            val result = logService.postLogdoperateAdd(operateBean)
             if (result.code == 0) {
                 val logEventBean = LogEventBean()
                 logEventBean.enableFlag = true