Kotlin Flow vs Android LiveData

Tenho algumas perguntas sobre o Kotlin Flow

1. Eu posso observar o LiveData de vários fragmentos. Posso fazer isso com o Flow? Se sim, então como?
2. Podemos ter vários LiveData de um único LiveData usando map& switchMap. Existe alguma maneira de ter vários fluxos a partir de um único fluxo de origem?
3. Usando MutableLiveDataEu posso atualizar dados de qualquer lugar usando a referência variável. Existe alguma maneira de fazer o mesmo com o Flow?

Eu tenho um caso de uso como: observarei um SharedPreferencesuso callbackFlow{...}que me dará uma única fonte de fluxo. A partir desse fluxo, desejo criar vários fluxos para cada par de valores-chave.

Isso pode parecer perguntas tolas. Eu sou novo no mundo Rx e Flow.

Eu posso observar o LiveData de vários fragmentos. Posso fazer isso com o Flow? Se sim, então como?

Sim. Você pode fazer isso com emite collect. Pense emité semelhante aos dados ativos postValuee collecté semelhante a observe. Vamos dar um exemplo.

Repositório

// I just faked the weather forecast
val weatherForecast = listOf("10", "12", "9")

// This function returns flow of forecast data
// Whenever the data is fetched, it is emitted so that
// collector can collect (if there is any)
fun getWeatherForecastEveryTwoSeconds(): Flow<String> = flow { 
    for (i in weatherForecast) {
        delay(2000)
        emit(i)
    }
}

ViewModel

fun getWeatherForecast(): Flow<String> {
    return forecastRepository.getWeatherForecastEveryTwoSeconds()
}

Fragmento

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    // Collect is suspend function. So you have to call it from a 
    // coroutine scope. You can create a new coroutine or just use 
    // lifecycleScope
    // https://developer.android.com/topic/libraries/architecture/coroutines
    lifecycleScope.launch {
            viewModel.getWeatherForecastEveryTwoSeconds().collect {
                    // Use the weather forecast data
                    // This will be called 3 times since we have 3 
                    // weather forecast data
            }
    }
}

Podemos ter vários LiveData de um único LiveData usando map & switchMap. Existe alguma maneira de ter vários fluxos de um único fluxo de origem?

O fluxo é muito útil. Você pode apenas criar fluxo dentro do fluxo. Digamos que você queira anexar um sinal de grau a cada um dos dados da previsão do tempo.

ViewModel

fun getWeatherForecast(): Flow<String> {
    return flow {
        forecastRepository
            .getWeatherForecastEveryTwoSeconds(spendingDetailsRequest)
                .map {
                    it + " °C"
                }
                .collect {
                    // This will send "10 °C", "12 °C" and "9 °C" respectively
                    emit(it) 
                }
    }
}

Em seguida, colete os dados no fragmento igual ao nº 1. Aqui o que acontece é que o modelo de exibição está coletando dados do repositório e o fragmento está coletando dados do modelo de exibição.

Usando MutableLiveData, eu posso atualizar dados de qualquer lugar usando a referência variável. Existe alguma maneira de fazer o mesmo com o Flow?

Você não pode emitir valor fora do fluxo. O bloco de código dentro do fluxo é executado apenas quando existe um coletor. Mas você pode converter o fluxo em dados ativos usando a extensão asLiveData do LiveData.

ViewModel

fun getWeatherForecast(): LiveData<String> {
    return forecastRepository
    .getWeatherForecastEveryTwoSeconds()
    .asLiveData() // Convert flow to live data
}

No seu caso, você pode fazer isso

private fun getSharedPrefFlow() = callbackFlow {
    val sharedPref = context?.getSharedPreferences("SHARED_PREF_NAME", MODE_PRIVATE)
    sharedPref?.all?.forEach {
        offer(it)
    }
}

getSharedPrefFlow().collect {
    val key = it.key
    val value = it.value
}

Editar

Obrigado a @mark pelo seu comentário. Criar um novo fluxo no modelo de visualização para a getWeatherForecastfunção é realmente desnecessário. Pode ser reescrito como

fun getWeatherForecast(): Flow<String> {
        return forecastRepository
                .getWeatherForecastEveryTwoSeconds(spendingDetailsRequest)
                    .map {
                        it + " °C"
                    }
    }

Há uma nova Flow.asLiveData()função de extensão nos novos androidx.lifecyclepacotes ktx. Você pode aprender mais no meu artigo: https://www.netguru.com/codestories/android-coroutines-%EF%B8%8Fin-2020

Em uma arquitetura de três camadas: apresentação do domínio de dados, o Flow deve ocorrer na camada de dados (bancos de dados, rede, cache ...) e depois como Samuel Urbanowicz mencionou, é possível mapear o Flow para o LiveData.

Em geral, o Flow é quase o que o Observable (ou Flowable) é para o RxJava. Não confunda com LiveData.

mais aqui: https://medium.com/@elizarov/cold-flows-hot-channels-d74769805f9