1.将部分livedata转为flow方便在activity不可见时调用。

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

 import android.widget.EditText
 import android.widget.TextView
 import androidx.activity.addCallback
+import androidx.lifecycle.lifecycleScope
 import androidx.work.PeriodicWorkRequest
 import androidx.work.WorkManager
 import com.kongzue.dialogx.DialogX
 import com.xhly.manageapp.utils.CurrentAppSharedPreferencesUtils
 import com.xhly.manageapp.utils.StrategyUtils
 import com.xhly.manageapp.workmanager.TimingWorker
+import kotlinx.coroutines.launch
 import java.util.concurrent.TimeUnit
 
 class LoginActivity : BaseActivity<LoginViewModel, ActivityLoginBinding>() {
                 showSettingDialog()
             }
         }
-        viewModel.logResultData.observe(this){
-            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)
+        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)
+                        }
                     }
                 }
             }

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

 import android.widget.TextView
 import android.widget.Toast
 import androidx.activity.addCallback
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleRegistry
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.viewModelScope
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.work.PeriodicWorkRequest
 import androidx.work.WorkManager
 import com.xhly.manageapp.utils.StrategyUtils
 import com.xhly.manageapp.workmanager.TimingWorker
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
           startActivity(permissionIntent)*/
         // csdkManagerUtils.csdkManager.enableAccessibility("com.xhly.manageapp","com.xhly.manageapp.service.TestService",true)
 
-        viewModel.listAppData.observe(this) { modelList ->
-            //存储商店应用包名到本地,并且存储商店应用列表数据到本地集合
-            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)
-            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.forceListAppData.observe(this) { modelList ->
-            //获得必装应用，未安装或者版本较低则更新，先删除目录中的文件
-            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)
-                        }
-                        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.strategyData.observe(this) {
-            spUtils.saveJson(Const.STRATEGYBEANKEY, it)
-            StrategyUtils.setStrategy(it)
-            useTimeStrategy()
-            updateStrategyFlag = true
-            if (updateTimeFlag) {
-                showSucessToast()
-            }
-        }
-        viewModel.appStrategyData.observe(this) {
-            //存储app时间策略
-            spUtils.saveJson(Const.APPSTRATEGYBEANKEY, it)
-            updateTimeFlag = true
-            if (updateStrategyFlag) {
-                showSucessToast()
-            }
-        }
-        viewModel.padInfoData.observe(this) {
-            //存储信息上传时间
-            if (it) {
-                spUtils.setParam(Const.PADINFOTIMEKEY, System.currentTimeMillis())
-            }
-        }
-        viewModel.loginOutData.observe(this) {
+        viewModel.pwdResultData.observe(this) {
             if (it) {
-                loginOut()
+                unBindBlock()
             } else {
                 Toast(getString(R.string.codeerror))
             }
         }
-        viewModel.updateInfoData.observe(this) {
-            //成功则保存不在提交
-            if (it) {
-                spUtils.setParam(Const.PADUPDATETIMEKEY, System.currentTimeMillis())
-            }
-        }
-        viewModel.schoolSetData.observe(this) {
-            spUtils.saveJson(Const.SCHOOLSETDEVICE, it)
-            initSchoolSet(it)
-            mBinding.rv.visibility=View.VISIBLE
-            updateAppRv()
-        }
+
         viewModel.wallpaperData.observe(this) {
             if (!it.hpath.isNullOrBlank()) {
                 Glide.with(this).load(Const.URL1 + it.hpath).placeholder(R.drawable.main_bg)
                     })
             }
         }
-        viewModel.netWhiteListData.observe(this) {
-            StrategyUtils.setNetWhiteList(it)
-        }
-        viewModel.pwdResultData.observe(this) {
-            if (it) {
-                unBindBlock()
-            } else {
-                Toast(getString(R.string.codeerror))
-            }
-        }
+
+
         viewModel.lockResultData.observe(this) {
             if (it) {
                 spUtils.setParam(Const.DISABLEPAD, true)
                 ManageApplication.launchFactoryReset()
             }
         }
-        viewModel.logResultData.observe(this) {
-            if (it.enableFlag) {
-                when (it.pushType) {
-                    2 -> {
-                        spUtils.setParam(Const.DISABLEPAD, false)
-                        useTimeStrategy()
-                    }
 
-                    3 -> {
-                        val appList = AppUtils.GetAppList(this)
-                        StrategyUtils.clearMemory(this, appList)
-                        spUtils.setParam(Const.DISABLEPAD, true)
-                        startIntentActivity(MainActivity().javaClass)
+        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)
                     }
-
-                    4 -> {
-                        //请求接口更新策略
-                        updateAllStrategy()
+                }
+                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)
                     }
+                }
+            }
+        }
 
-                    5 -> {
-                        ManageApplication.rebootDevice()
-                    }
+        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()
+                        }
 
-                    6 -> {
-                        loginOutSucess()
-                        ManageApplication.launchFactoryReset()
                     }
+            }
 
-                    7 -> {
-                        currentSpUtils.setParam(Const.EXIT_CONTROL, true)
-                        StrategyUtils.releaseControl(this)
-                    }
+        }
+
+        viewModel.viewModelScope.launch {
+            viewModel.strategyData.collect {
+                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()
+                }
+            }
+        }
+
+        viewModel.viewModelScope.launch {
+            viewModel.padInfoData.collect {
+                //存储信息上传时间
+                if (it) {
+                    spUtils.setParam(Const.PADINFOTIMEKEY, System.currentTimeMillis())
+                }
+            }
+        }
+
+        viewModel.viewModelScope.launch {
+            viewModel.loginOutData.collect {
+                if (it) {
+                    loginOut()
+                } else {
+                    Toast(getString(R.string.codeerror))
+                }
+            }
+        }
+
+        viewModel.viewModelScope.launch {
+            viewModel.updateInfoData.collect {
+                //成功则保存不在提交
+                if (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()
+            }
+        }
 
-                    8 -> {
-                        loginOut()
+        viewModel.viewModelScope.launch {
+
+            viewModel.netWhiteListData.collect {
+                StrategyUtils.setNetWhiteList(it)
+            }
+
+        }
+
+
+        viewModel.viewModelScope.launch {
+
+            viewModel.logResultData.collect {
+                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)
+                        }
+
+                        4 -> {
+                            //请求接口更新策略
+                            updateAllStrategy()
+                        }
+
+                        5 -> {
+                            ManageApplication.rebootDevice()
+                        }
+
+                        6 -> {
+                            loginOutSucess()
+                            ManageApplication.launchFactoryReset()
+                        }
+
+                        7 -> {
+                            currentSpUtils.setParam(Const.EXIT_CONTROL, true)
+                            StrategyUtils.releaseControl(this@MainActivity)
+                        }
+
+                        8 -> {
+                            loginOut()
+                        }
                     }
                 }
             }
         }
-        viewModel.logEventData.observe(this) {
-            when (it.logEventType) {
-                EventLog.ACCOUNTQUITEVENT -> {
-                    loginOutSucess()
+
+        viewModel.viewModelScope.launch {
+            viewModel.logEventData.collect {
+                when (it.logEventType) {
+                    EventLog.ACCOUNTQUITEVENT -> {
+                        loginOutSucess()
+                    }
                 }
             }
         }
-        viewModel.autoAppData.observe(this){
-            //连接不为空，并且应用已安装则跳转应用
-            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,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,autoAppBean.appPackage)&&!it.netSucessFlag){
-                            startAutoApp(autoAppBean)
-                        }else{
+
+        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{
+                                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()
         lastTimeLong=System.currentTimeMillis()
             pushBean.sn =it
         }
         viewModel.postLogPushAdd(pushBean)
-        startIntentActivity(MainActivity().javaClass)
+        if (pushBean.pushType!=4){
+            //更新策略不调回activity因为可能在其他应用中。
+            startIntentActivity(MainActivity().javaClass)
+        }
     }
 
     private fun updateAppRv() {

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

 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.asFlow
 import com.xhly.corelib.Const
 import com.xhly.corelib.eventbus.UIEvent
 import com.xhly.corelib.network.RetrofitService
 import com.xhly.manageapp.network.log.LogService
 import com.xhly.manageapp.network.strategy.StrategyService
 import com.xhly.manageapp.viewmodel.BaseViewModel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
 
 class MainViewModel : BaseViewModel() {
     private val appService by lazy { RetrofitService.create<AppService>() }
     private val strategyService by lazy { RetrofitService.create<StrategyService>() }
     private var logService = RetrofitService.create<LogService>()
-    private val listData = MutableLiveData<ArrayList<AppModel>>()
+
+/*    private val listData = MutableLiveData<ArrayList<AppModel>>()
     val listAppData: LiveData<ArrayList<AppModel>> = listData
     private val forceData = MutableLiveData<ArrayList<AppModel>>()
     val forceListAppData: LiveData<ArrayList<AppModel>> = forceData
-
     private val strategy = MutableLiveData<StrategyBean>()
     val strategyData: LiveData<StrategyBean> = strategy
     private val appStrategy = MutableLiveData<ArrayList<AppTimeManageBean>>()
     val loginOutData: LiveData<Boolean> = loginOut
     private val schoolSet = MutableLiveData<SchoolDeviceSetBean>()
     val schoolSetData: LiveData<SchoolDeviceSetBean> = schoolSet
+
+    private val netWhiteList = MutableLiveData<ArrayList<String>>()
+    val netWhiteListData: LiveData<ArrayList<String>> = netWhiteList*/
+
     private val wallpaper = MutableLiveData<WallpaperBean>()
     val wallpaperData: LiveData<WallpaperBean> = wallpaper
-    private val netWhiteList = MutableLiveData<ArrayList<String>>()
-    val netWhiteListData: LiveData<ArrayList<String>> = netWhiteList
+
+
+    private val listData =MutableStateFlow(ArrayList<AppModel>())
+    val listAppData: Flow<ArrayList<AppModel>> = listData.asStateFlow()
+
+    private val forceData =MutableStateFlow(ArrayList<AppModel>())
+    val forceListAppData: Flow<ArrayList<AppModel>> = forceData.asStateFlow()
+
+    private val strategy = MutableStateFlow(StrategyBean())
+    val strategyData: Flow<StrategyBean> = strategy.asStateFlow()
+
+    private val appStrategy = MutableStateFlow(ArrayList<AppTimeManageBean>())
+    val appStrategyData: Flow<ArrayList<AppTimeManageBean>> = appStrategy.asStateFlow()
+
+    private val padInfo = MutableStateFlow(false)
+    val padInfoData: Flow<Boolean> = padInfo.asStateFlow()
+
+    private val updateInfo =MutableStateFlow(false)
+    val updateInfoData: Flow<Boolean> = updateInfo.asStateFlow()
+
+    private val loginOut =MutableStateFlow(false)
+    val loginOutData:  Flow<Boolean> = loginOut.asStateFlow()
+
+    private val schoolSet = MutableStateFlow(SchoolDeviceSetBean())
+    val schoolSetData: Flow<SchoolDeviceSetBean> = schoolSet.asStateFlow()
+
+
+    private val netWhiteList = MutableStateFlow(ArrayList<String>())
+    val netWhiteListData: Flow<ArrayList<String>> = netWhiteList.asStateFlow()
+
+
 
     fun getAppList() {
         launchUI {

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

 import com.xhly.manageapp.bean.scheme.AutoAppBean
 import com.xhly.manageapp.network.log.LogService
 import com.xhly.manageapp.ui.login.netservice.LoginService
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
 
 open class BaseViewModel : CommonBaseViewModel() {
     protected val loginService: LoginService by lazy { RetrofitService.create<LoginService>() }
     val lockResultData: LiveData<Boolean> = lockResult
     private val resetResult = MutableLiveData<Boolean>()
     val resetlResultData: LiveData<Boolean> = resetResult
-    private val logResult=MutableLiveData<LogPushResultBean>()
-    val logResultData:LiveData<LogPushResultBean> =logResult
-    private val logEventResult=MutableLiveData<LogEventBean>()
-    val logEventData:LiveData<LogEventBean> =logEventResult
-    private val autoAppResult=MutableLiveData<AutoAppBean>()
-    val autoAppData:LiveData<AutoAppBean> =autoAppResult
+
+    /*    private val logResult=MutableLiveData<LogPushResultBean>()
+        val logResultData:LiveData<LogPushResultBean> =logResult
+
+    private val logEventResult = MutableLiveData<LogEventBean>()
+    val logEventData: LiveData<LogEventBean> = logEventResult
+        */
+    private val logResult = MutableStateFlow(LogPushResultBean())
+    val logResultData: Flow<LogPushResultBean> = logResult.asStateFlow()
+
+    private val logEventResult =MutableStateFlow(LogEventBean())
+    val logEventData: Flow<LogEventBean> = logEventResult.asStateFlow()
+
+
+    private val autoAppResult = MutableStateFlow(AutoAppBean())
+    val autoAppData: Flow<AutoAppBean> = autoAppResult.asStateFlow()
+
     /**
      * 解除当前锁屏
      */
     fun postPwdDetail(code: String, sn: String) {
         launchUI {
             //先对比本地密码，一致则直接解锁，不然传给服务器
-            if (code == MD5Utils.getDynamicPassword(sn)){
-                pwdResult.value =true
+            if (code == MD5Utils.getDynamicPassword(sn)) {
+                pwdResult.value = true
                 postEditUnlock(sn)
-            }else{
+            } else {
                 val map = HashMap<String, Any>()
                 map["password"] = code
-                val result=loginService.postExitControl(map)
+                val result = loginService.postExitControl(map)
                 pwdResult.value = result.code == 0
             }
         }
     /**
      * 手动进入管理页面
      */
-    fun postExitControl(code:String,sn: String){
+    fun postExitControl(code: String, sn: String) {
         launchUI {
             //先对比本地密码，一致则可以进入本地管理页面
             controlResult.value = code == MD5Utils.getDynamicPassword(sn)
     fun eventLog(operateBean: LogdOperateBean) {
         launchUI {
             var result = logService.postLogdoperateAdd(operateBean)
-            if (result.code==0){
-                val logEventBean=LogEventBean()
-                logEventBean.enableFlag=true
-                logEventBean.logEventType=operateBean.doEvent
-                logEventResult.value=logEventBean
+            if (result.code == 0) {
+                val logEventBean = LogEventBean()
+                logEventBean.enableFlag = true
+                logEventBean.logEventType = operateBean.doEvent
+                logEventResult.value = logEventBean
             }
         }
     }
     fun postLogPushAdd(logPushBean: LogPushBean) {
         launchUI {
             val postLogPushAdd = logService.postLogPushAdd(logPushBean)
-            if (postLogPushAdd.code==0){
+            if (postLogPushAdd.code == 0) {
                 //为true则后续执行
-                val logPushResultBean=LogPushResultBean()
-                logPushResultBean.pushType=logPushBean.pushType
-                logPushResultBean.enableFlag=true
-                logResult.value=logPushResultBean
+                val logPushResultBean = LogPushResultBean()
+                logPushResultBean.pushType = logPushBean.pushType
+                logPushResultBean.enableFlag = true
+                logResult.value = logPushResultBean
             }
         }
     }
+
     /**
      * 同步服务器的时间
      */
-    fun postSyncTime(){
+    fun postSyncTime() {
         launchUI {
             val startTime = System.currentTimeMillis()
             val postSyncTime = loginService.postSyncTime()
-            if (postSyncTime.code==0){
+            if (postSyncTime.code == 0) {
                 val endTime = System.currentTimeMillis()
                 val obj = postSyncTime.obj
-                timeResult.value=obj+(endTime-startTime)/2
-            }else{
-                if (!postSyncTime.msg.isNullOrEmpty()){
-                   netMessage.value=postSyncTime.msg
+                timeResult.value = obj + (endTime - startTime) / 2
+            } else {
+                if (!postSyncTime.msg.isNullOrEmpty()) {
+                    netMessage.value = postSyncTime.msg
                 }
             }
         }
      * sn 设备号
      *  pushType  3锁定
      */
-    fun postExitLocked(sn:String,pushType:Int=3){
+    fun postExitLocked(sn: String, pushType: Int = 3) {
         launchUI {
-            val map=HashMap<String,Any>()
-            map["sn"]=sn
-            map["pushType"]=pushType
+            val map = HashMap<String, Any>()
+            map["sn"] = sn
+            map["pushType"] = pushType
             val result = loginService.postExitLocked(map)
-            if (result.code==0){
-                lockResult.value=true
-            }else{
-                if (!result.msg.isNullOrEmpty()){
-                    netMessage.value=result.msg
+            if (result.code == 0) {
+                lockResult.value = true
+            } else {
+                if (!result.msg.isNullOrEmpty()) {
+                    netMessage.value = result.msg
                 }
             }
         }
      * sn 设备号
      * pushType  6恢复出厂设置
      */
-    fun postExitReseted(sn:String,pushType:Int=6){
+    fun postExitReseted(sn: String, pushType: Int = 6) {
         launchUI {
-            val map=HashMap<String,Any>()
-            map["sn"]=sn
-            map["pushType"]=pushType
+            val map = HashMap<String, Any>()
+            map["sn"] = sn
+            map["pushType"] = pushType
             val result = loginService.postExitReseted(map)
-            if (result.code==0){
-                resetResult.value=true
-            }else{
-                if (!result.msg.isNullOrEmpty()){
-                    netMessage.value=result.msg
+            if (result.code == 0) {
+                resetResult.value = true
+            } else {
+                if (!result.msg.isNullOrEmpty()) {
+                    netMessage.value = result.msg
                 }
             }
         }
     /**
      * 设备--解除锁定(锁定后，本地输入密码校验通过后调用) 参数sn
      */
-    fun postEditUnlock(sn:String){
+    fun postEditUnlock(sn: String) {
         launchUI {
-            val map=HashMap<String,Any>()
-            map["sn"]=sn
+            val map = HashMap<String, Any>()
+            map["sn"] = sn
             var postExitLocked = loginService.postEditUnlock(map)
         }
     }
      * 开机设置-启动应用-平板用户（根据这个接口启动指定应用）
      */
 
-    fun postAutoAppDetail(regionid:Long){
+    fun postAutoAppDetail(regionid: Long) {
         launchUI {
-           try {
-               val map=HashMap<String,Any>()
-               map["regionid"]=regionid
-               val result= loginService.postAutoAppDetail(map)
-               if (result.code==0){
-                   result.obj.netSucessFlag=true
-                   autoAppResult.value=result.obj
-               }else{
-                   val autoAppBean = AutoAppBean()
-                   autoAppBean.netSucessFlag=true
-                   autoAppResult.value=AutoAppBean()
-               }
-           }catch (e:Exception){
-               autoAppResult.value= AutoAppBean()
-               LogShow(e.toString())
-           }
+            try {
+                val map = HashMap<String, Any>()
+                map["regionid"] = regionid
+                val result = loginService.postAutoAppDetail(map)
+                if (result.code == 0) {
+                    result.obj.netSucessFlag = true
+                    autoAppResult.value = result.obj
+                } else {
+                    val autoAppBean = AutoAppBean()
+                    autoAppBean.netSucessFlag = true
+                    autoAppResult.value = AutoAppBean()
+                }
+            } catch (e: Exception) {
+                autoAppResult.value = AutoAppBean()
+                LogShow(e.toString())
+            }
         }
     }
 }