近段时间的学习碎片整理（16）

一、ViewModel的使用

可以引入fragment和activity的扩展

implementation "androidx.fragment:fragment-ktx:1.4.1"
implementation "androidx.activity:activity-ktx:1.4.0"

初始化就可以 private val viewModel: ViewModel by ViewModels初始化

没有引入扩展的情况下初始化：

private val viewModel by lazy {
        obtainViewModel(ViewModel::class.java)
    }

使用：

  viewModel.data.observe(this) {
            //里面就是获取到的数据
        }
                                                            
  viewModel.state.observe(this) {
            //监测状态，展示加载中、错误等不同状态时的控件
            binding.**.isVisible = it == DataState.LOADING
            binding.**.isVisible = it == DataState.ERROR
            binding.**.isVisible = it == DataState.SUCCESS
        }

BaseRepo类：

abstract class BaseRepo<D>(protected val dataKey: String, protected val timeKey: String) {
    protected val mmkv by lazy {
        //初始化mmkv
    }

    protected val gson by lazy {
        //初始化Gson
    }

    /**
     * 判断是否超时,超时返回当前时间戳，不超时返回0L
     */
    protected fun isOverDue(overTime: Long): Long {
        val lastTime = mmkv.getLong(timeKey, 0L)
        val currentTimeMillis = System.currentTimeMillis()
        return if (currentTimeMillis - lastTime <= overTime) {
            0L
        } else {
            currentTimeMillis
        }
    }

    /**
     * 保存请求网络的时间
     */
    protected fun saveTime(time: Long) {
        mmkv.encode(timeKey, time)
    }

    /**
     * 保存数据
     */
    protected fun saveData(data: D) {
        val toJson = gson.toJson(data)
        mmkv.encode(dataKey, toJson)
    }
}

NetBaseViewModel类：

abstract class NetBaseViewModel<D, S> : BaseViewModel<D>() {
    protected val service by lazy {
        getNetService(setService())
    }

    protected abstract fun setService(): Class<S>
}

仓库类可以继承BaseRepo类：

class ****Repo(private val service: NetService): BaseRepo<ArrayList<数据类型>>
    (存储数据的KEY,存储请求时间的Key){

    companion object {
        private const val OVER_DUE_TIME = 900000L //15分钟
    }

   
    suspend fun get****List(): ArrayList<数据类型> {
        val overDue = isOverDue(OVER_DUE_TIME)
        if (overDue == 0L) {
            val saveData = getSaveData()
            if (!saveData.isNullOrEmpty()) {
                return saveData
            }
        }
        val netData = getNetData()
        if (!netData.isNullOrEmpty()) {
            saveTime(overDue)
            saveData(netData)
        }

        val saveData = getSaveData()
        if (!saveData.isNullOrEmpty()) {
            return saveData
        }

        return arrayListOf()
    }

   
    private fun getSaveData(): ArrayList<数据类型> {
        try {
            val resultDataString = mmkv.getString(dataKey, "") ?: ""
            if (resultDataString.isEmpty()) return arrayListOf()
            val type = object : TypeToken<ArrayList<数据类型>>() {}.type
            return gson.fromJson(resultDataString, type)
        } catch (e: Throwable) {
            e.printStackTraceByDebug()
            return arrayListOf()
        }
    }

    /**
     * 获取网络数据
     */
    private suspend fun getNetData(): ArrayList<数据类型> {
        return try {
            val data = service.get***List()
            if (!data.isNullOrEmpty()) {
                return data
            }else {
                arrayListOf()
            }

        }catch (e: Throwable) {
            e.printStackTraceByDebug()
            arrayListOf()
        }
    }
}

ViewModel可以继承NetBaseViewModel类：

class *****VM : NetBaseViewModel<ArrayList<数据类型>, NetService>() {

    override fun setService() = NetService::class.java

    private val ****Repo by lazy {
        //初始化数据仓库
    }

    /**
     * 请求数据
     */
    fun getList() {
        viewModelScope.launch(Dispatchers.IO) {
            try {
                inState.postValue(DataState.LOADING)
                val List = anatomyRepo.get***List()
                if (List.isNullOrEmpty()) {
                    inState.postValue(DataState.ERROR)
                }else {
                    inState.postValue(DataState.SUCCESS)
                }
                inData.postValue(List)
            }catch (e: Throwable) {
                e.printStackTraceByDebug()
                inState.postValue(DataState.ERROR)
            }
        }
    }
}