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>) {
    
    ..}
}

猜你喜欢

转载自blog.csdn.net/qq_32670947/article/details/126951798