what are the benefits for using Flow from a Room query in Android as oppose to using Livedata?

I would say that Flow has numerous operators you can apply to the stream in comparison with LiveData which have almost none. That might be considered as an advantage.

Flow

has way more operators. Also,

LiveData

is only consumed from the Main thread, while

Flow

could be consumed from any context (using

flowOn

operator). But

LiveData

has the advantage of saving the latest received value (

liveData.getValue()

).

Ok so Flow gives me more flexibility with operators and more Dispatchers(IO/Default)

Flows can be lifecycle aware also, provided that you use a lifecycle scope when consuming them

Also, there is an

asLiveData()

extension function on

Flow

to wrap it in a

LiveData

. So, your diagram a couple of comments earlier in this thread is fairly easy to implement.

So i'm following this advance Google Code lab: https://codelabs.developers.google.com/codelabs/advanced-kotlin-coroutines/?authuser=0#13

We use LiveData only as properties in ViewModels for Activities/Fragments to observe. All the other stream types are either Flows or Rx Observables. The Flow.asLiveData() has some issues with its pausing dispatcher and we don't yet use it.

And this green outlined text kind of suprised me. Observe Livedata in your viewmodel from your Activity or Fragment is like super standard?

i think the text in your screenshot happens to be awkwardly worded, what it means is don’t have your ViewModel observe a LiveData property, observing a LiveData property in your ViewModel with an Activity or Fragment is super standard, as you say

We use LiveData only as properties in ViewModels for Activities/Fragments to observe. All the other stream types are either Flows or Rx Observables. The Flow.asLiveData() has some issues with its pausing dispatcher and we don't yet use it.

But would you consider Livedata a 'steam' type? Since it returns a whole list like 'listOf(1, 2, 3)' instead of a flow of items in the list '1, 2, and 3'.

Flow

can emit

List<Int>

and

LiveData

can emit

Int

. The type of what is being emitted to observers is independent of whether it is

Flow

or

LiveData

.

ok good to know

Isn't LiveData meant to represent a single value that changes over time (ie, a user's first name) whereas Flow is just a stream of one or more values over time (ie, click events of a button)?

do not use

LiveData<T>

anywhere except in a

ViewModel

to expose a

T

to a UI component (such as an

Activity

or

Fragment

).

Flow<T>

should be preferred everywhere else (and I prefer it at the

ViewModel

level too because it avoids the main thread limitation)