Flow，StateFlow，SharedFlow使用简单对比

本篇代码地址：
https://github.com/VIVILL/SimpleDemo/tree/main/Flow

在使用flow之前，建议先阅读这2篇文章，了解下MVI和flow。
Flow很难？：kotlin《序列 vs 集合》
MVI架构模式？到底是谁在卷？《官方架构指南升级》

https://juejin.cn/post/7058903426893086734

Flow是支持异步操作的Sequence

https://juejin.cn/post/7066832858664402980/

新建Repository，产生随机数据，使用flow封装数据。

class Repository {

    fun getRandomNumber(): Flow<Int>{
        // 创建 Flow
        return flow {
            // 模拟耗时任务
            // 会在后台线程执行delay ，执行完后，自动切换线程
            delay(1_000)
            // 随机输出 number
            val number = (0..100).random()
            Log.d("Repository","number = $number")
            // 发射 number
            emit(number)
            Log.d("Repository","emit number = $number")
        }
    }

}

新建FlowTestViewModel类，使用Flow，StateFlow，SharedFlow 3种方式获取随机数。

class FlowTestViewModel: ViewModel() {
    // 使用 Repository
    private val repository: Repository = Repository()

    // 使用 flow
    private val _numberFlow = repository.getRandomNumber()
    val numberFlow: Flow<Int> = _numberFlow

    // 使用 StateFlow
    // StateFlow 具有一个属性 value，可以被设置
    // 设置默认值 0
    private val _numberStateFlow = MutableStateFlow<Int>(0)
    val numberStateFlow: StateFlow<Int> = _numberStateFlow

    fun updateNumberStateFlow() {
        // 更新  value 数据
        viewModelScope.launch {
            _numberStateFlow.value = repository.getRandomNumber()
                .stateIn(viewModelScope)
                .value
        }
    }

    // 使用 SharedFlow
    private val _numberSharedFlow = MutableSharedFlow<Int>()
    val numberSharedFlow: SharedFlow<Int> = _numberSharedFlow

    fun updateNumberSharedFlow() {
        viewModelScope.launch {
            repository.getRandomNumber().collect {
                _numberSharedFlow.emit(it)
            }
        }
    }

}

然后在MainActivity 中使用。

private const val TAG = "MainActivity"
class MainActivity : AppCompatActivity() {

    private val binding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }
    private val viewModel by lazy {
        ViewModelProvider(this).get(FlowTestViewModel::class.java)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)


        /* https://juejin.cn/post/7127454075666300965
        * 冷流 :只有订阅者订阅时，才开始执行发射数据流的代码。
        * 并且冷流和订阅者只能是一对一的关系，当有多个不同的订阅者时，消息是重新完整发送的。
        * 也就是说对冷流而言，有多个订阅者的时候，他们各自的事件是独立的。
        * 热流:无论有没有订阅者订阅，事件始终都会发生。
        * 当 热流有多个订阅者时，热流与订阅者们的关系是一对多的关系，可以与多个订阅者共享信息。
        * */
        binding.flowButton.setOnClickListener{
            // flow 是冷流 只有当订阅者发起订阅时，事件的发送者才会开始发送事件。
            // 每次调用创建flow 都需调用 collect
            lifecycleScope.launch {
                repeatOnLifecycle(Lifecycle.State.STARTED) {
                    viewModel.numberFlow.collect { value ->
                        Log.d(TAG,"numberFlow = $value")
                    }
                }
            }
        }

        // StateFlow 和 SharedFlow 是热流
        binding.stateflowButton.setOnClickListener{
            // 更新 StateFlow 中的 value
             viewModel.updateNumberStateFlow()
        }
        binding.sharedFlowButton.setOnClickListener{
            viewModel.updateNumberSharedFlow()
        }

        subscribe()
    }

    private fun subscribe(){
        // 因为 使用了lifecycleScope,我们的collector具有了生命周期的感应能力
        // 每次 _numberStateFlow 的 value 更新的时候，collector就会执行相应的代码，
        lifecycleScope.launch {
            // https://developer.android.com/kotlin/flow/stateflow-and-sharedflow?hl=zh-cn
            // 如果需要更新界面，切勿使用 launch 或 launchIn 扩展函数从界面直接收集数据流。
            // 即使 View 不可见，这些函数也会处理事件。此行为可能会导致应用崩溃。
            // 为避免这种情况，请使用 repeatOnLifecycle API
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.numberStateFlow.collect { value ->
                    Log.d(TAG,"numberStateFlow = $value")
                }
            }
        }

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.numberSharedFlow.collect { value ->
                    Log.d(TAG,"numberSharedFlow = $value")
                }
            }
        }

    }


}

当按下button，产生事件，数据就会更新。
下面来简单看看StateFlow 和 SharedFlow 对比。

/**
 * StateFlow 和 SharedFlow 简单使用
 * */
class LoginViewModel: ViewModel() {
    // https://blog.csdn.net/fly_with_24/article/details/120300290
    // 使用 StateFlow （即UiState）的时候 ，有与 LiveData 一样的「粘性事件」问题
    // 在弹出 Snackbar 之后旋转屏幕后， 会再次弹出 Snackbar
    // 使用 SharedFlow 不会有「粘性事件」的问题
    private val _loginUiState = MutableStateFlow<LoginUiState>(LoginUiState.Empty)
    val loginUiState: StateFlow<LoginUiState> = _loginUiState

    fun login(username: String, password: String) {
        viewModelScope.launch {
            _loginUiState.value = LoginUiState.Loading
            delay(2000L)
            if(username == "abc" && password == "123") {
                _loginUiState.value = LoginUiState.Success
            } else {
                _loginUiState.value = LoginUiState.Error("Wrong credentials")
            }
        }
    }

    // 使用 SharedFlow
    private val _loginUiAction = MutableSharedFlow<LoginUiAction>()
    val loginUiAction: SharedFlow<LoginUiAction> = _loginUiAction

    fun loginBySharedFlow(username: String, password: String) {
        viewModelScope.launch {
            _loginUiAction.emit(LoginUiAction.Loading)
            delay(2000L)
            if(username == "abc" && password == "123") {
                _loginUiAction.emit(LoginUiAction.Success)
            } else {
                _loginUiAction.emit(LoginUiAction.Error("Wrong credentials"))
            }
        }
    }
}


sealed class LoginUiState {
    object Success : LoginUiState()
    data class Error(val message: String) : LoginUiState()
    object Loading : LoginUiState()
    object Empty : LoginUiState()
}

sealed class LoginUiAction {
    object Success : LoginUiAction()
    data class Error(val message: String) : LoginUiAction()
    object Loading : LoginUiAction()
}

登陆后显示结果。

class LoginActivity : AppCompatActivity() {
    private val binding by lazy {
        ActivityLoginBinding.inflate(layoutInflater)
    }
    private val viewModel by lazy {
        ViewModelProvider(this).get(LoginViewModel::class.java)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
        binding.btnLogin.setOnClickListener{
/*            viewModel.login( binding.etUserName.text.toString(),
                binding.etPassword.text.toString())*/
            viewModel.loginBySharedFlow( binding.etUserName.text.toString(),
                binding.etPassword.text.toString())
        }

        lifecycleScope.launch {
            // https://developer.android.com/kotlin/flow/stateflow-and-sharedflow?hl=zh-cn
            // 如果需要更新界面，切勿使用 launch 或 launchIn 扩展函数从界面直接收集数据流。
            // 即使 View 不可见，这些函数也会处理事件。此行为可能会导致应用崩溃。
            // 为避免这种情况，请使用 repeatOnLifecycle API
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.loginUiState.collect {
                    when (it) {
                        is LoginUiState.Success -> {
                            Snackbar.make(
                                binding.root,
                                "Successfully logged in",
                                Snackbar.LENGTH_LONG
                            ).show()
                            binding.progressBar.isVisible = false
                        }
                        is LoginUiState.Error -> {
                            Snackbar.make(
                                binding.root,
                                it.message,
                                Snackbar.LENGTH_LONG
                            ).show()
                            binding.progressBar.isVisible = false
                        }
                        is LoginUiState.Loading -> {
                            binding.progressBar.isVisible = true
                        }
                        else -> Unit
                    }
                }

            }
        }

        // Jetpack MVVM 常见错误二：在 launchWhenX 中启动协程  
        // https://www.jianshu.com/p/567b19cd5ebf
        lifecycleScope.launch {
            // https://developer.android.com/kotlin/flow/stateflow-and-sharedflow?hl=zh-cn
            // 如果需要更新界面，切勿使用 launch 或 launchIn 扩展函数从界面直接收集数据流。
            // 即使 View 不可见，这些函数也会处理事件。此行为可能会导致应用崩溃。
            // 为避免这种情况，请使用 repeatOnLifecycle API
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.loginUiAction.collect {
                    when (it) {
                        is LoginUiAction.Success -> {
                            Snackbar.make(
                                binding.root,
                                "Successfully logged in",
                                Snackbar.LENGTH_LONG
                            ).show()
                            binding.progressBar.isVisible = false
                        }
                        is LoginUiAction.Error -> {
                            Snackbar.make(
                                binding.root,
                                it.message,
                                Snackbar.LENGTH_LONG
                            ).show()
                            binding.progressBar.isVisible = false
                        }
                        is LoginUiAction.Loading -> {
                            binding.progressBar.isVisible = true
                        }
                        else -> Unit
                    }
                }
            }
        }

    }


}

StateFlow，SharedFlow实际使用的时候，数据需封装成UiState和UiAction。
具体可参考codelabs中的代码：
https://github.com/googlecodelabs/android-paging

// SearchRepositoriesViewModel.kt
sealed class UiAction {
    data class Search(val query: String) : UiAction()
    data class Scroll(val currentQuery: String) : UiAction()
}

data class UiState(
    val query: String = DEFAULT_QUERY,
    val lastQueryScrolled: String = DEFAULT_QUERY,
    val hasNotScrolledForCurrentSearch: Boolean = false
)

从这个demo可以看出StateFlow和SharedFlow 实际应用场景。需要更新 UiState （UI状态）时用 StateFlow ，需要更新UiAction （UI动作）时用 SharedFlow 。
从代码上简单理解的话

当 待更新的数据 可以封装成data class的时候，用UiState
当 待更新的数据 可以封装成sealed class的时候，用UiAction 。

为什么要用flow代替livedata？我觉得这篇讲的挺好的。

https://zhuanlan.zhihu.com/p/434659014
LiveData作为数据的唯一载体似乎渐渐无法担此重任，其中一个痛点就是由于模糊了“状态”和“事件”的界限。

参考链接：
StateFlow 和 SharedFlow
从 LiveData 迁移到 Kotlin 数据流
 Kotlin上的反应式流-SharedFlow和StateFlow
Android中StateFlow的简单使用
 Kotlin:深入理解StateFlow与SharedFlow，StateFlow和LiveData使用差异区分，SharedFlow实现源码解析。
不做跟风党，LiveData，StateFlow，SharedFlow 的使用场景对比
 Kotlin-Flow常见场景下的使用
 用Kotlin Flow解决Android开发中的痛点问题
 【Android】之 Flow 的使用和浅析