Kotlin SharedFlow 实践使用

需求

监测到数据后，做自定义view画图显示。数据200ms发一次，自定义view数据50ms画一次，需将原始数据做平滑处理

1、viewModel侧

// Backing property to avoid state updates from other classes
    private val _uiState = MutableSharedFlow<Int>(replay = 0)

    // The UI collects from this StateFlow to get its state updates
    val uiState: SharedFlow<Int> = _uiState

    fun sendEvent(event: Int) {
        viewModelScope.launch {
            _uiState.emit(event)
        }
    }

监听端

class FullScreenRhythmActivity : AppCompatActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
...
	registerListener(listener)
}

	private var listener: Listener = object : Listener() {
//        @RequiresApi(Build.VERSION_CODES.O)
        override fun onDataEventChanged(eventValue: Value) {
        	if (GenerateData.isFistEmit) {
                    Log.d("liulinTest", "startCacheData")
                    startCacheData(GenerateData.handleOriginalData(value))
                    GenerateData.isFistEmit = false
                } else {
                    setCacheData(GenerateData.handleOriginalData(value))
                }
        	viewModel.sendEvent(1)
       }
	}
}

数据处理端

我的数据是将近200ms接收一次，需要将数据做缓存平滑处理后，50ms发一组出去处理过的数据，并作显示（会比较耗时，所以用measureTimeMillis 计算出方法耗时时间）

open class BaseFragment : Fragment() {
	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 使用lifecycleScope启动协程
        // 由于 repeatOnLifecycle 是一个挂起函数，
        // 因此从 lifecycleScope 中创建新的协程
        viewLifecycleOwner.lifecycleScope.launch {
            // 直到 lifecycle 进入 DESTROYED 状态前都将当前协程挂起。
            // repeatOnLifecycle 每当生命周期处于 STARTED 或以后的状态时会在新的协程中
            // 启动执行代码块，并在生命周期进入 STOPPED 时取消协程。
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                // 每次生命周期处于 STARTED 状态（或更高状态）时，repeatOnLifecycle 在新的协程中启动块，并在它停止时取消它。
                viewModel.uiState.collect {
                	//方法耗时时间
                    var timeCost =
                        measureTimeMillis {...
                     	callback.onChanged(GenerateData.cache1Array!!)
                        //接收到数据后要做的处理1...
                        }
                   	if (timeCost < 50)
                        delay(50 - timeCost)
                   	timeCost =
                        measureTimeMillis {...接收到数据后要做的处理2...}
                  	if (timeCost < 50)
                        delay(50 - timeCost)
                   	timeCost =
                        measureTimeMillis {...接收到数据后要做的处理3...} 
                }
	}
}

数据处理

object GenerateData {
	fun handleOriginalData(byte: ByteArray): MutableList<Int> {....}
  	var isFistEmit = true
    var cache1Array: FloatArray? = null//缓存数组1
    var cache2Array: FloatArray? = null//缓存数组2
    var cacheTempArray1: FloatArray? = null
    var cacheTempArray2: FloatArray? = null
    var cacheTempArray3: FloatArray? = null
    
    fun setCacheData(list: MutableList<Int>) {...}
    fun startCacheData(list: MutableList<Int>) {..}
}