There are two ways that make change value of `MutableLiveData`. But what is difference between **`setValue()`** &amp; **`postValue()`** in `MutableLiveData`.

I could not find documentation for same.

Here is class `MutableLiveData` of Android.

    package android.arch.lifecycle;
    
    /**
     * {@link LiveData} which publicly exposes {@link #setValue(T)} and {@link #postValue(T)} method.
     *
     * @param &lt;T&gt; The type of data hold by this instance
     */
    @SuppressWarnings(&quot;WeakerAccess&quot;)
    public class MutableLiveData&lt;T&gt; extends LiveData&lt;T&gt; {
        @Override
        public void postValue(T value) {
            super.postValue(value);
        }
    
        @Override
        public void setValue(T value) {
            super.setValue(value);
        }
    }




Difference of setValue() &amp; postValue() in MutableLiveData

I&#39;m trying to trigger an update on LiveData from a coroutine:

    object AddressList: MutableLiveData&lt;List&lt;Address&gt;&gt;()
    fun getAddressesLiveData(): LiveData&lt;List&lt;Address&gt;&gt; {
        AddressList.value = listOf()
        GlobalScope.launch {
            AddressList.value = getAddressList()
        }
        return AddressList
    }

but I get the following error:

&gt; IllegalStateException: Cannot invoke setValue on a background thread

Is there a way to make it work with coroutines?


MutableLiveData: Cannot invoke setValue on a background thread from Coroutine

I have a separate class in which I handle data fetching (specifically Firebase) and I usually return LiveData objects from it and update them asynchronously. Now I want to have the returned data stored in a ViewModel, but the problem is that in order to get said value, I need to observe the LiveData object returned from my data fetching class. The observe method required a LifecycleOwner object as the first parameter, but I obviously don&#39;t have that inside of my ViewModel and I know I am not supposed to keep a reference to the Activity/Fragment inside of the ViewModel. What should I do?

Observing LiveData from ViewModel

I need to get an Observer event when the item is added to the List of LiveData. But as far as I understand the event receives only when I replace the old list with a new one.
For example when I do the next:

    list.value = mutableListOf(IssuePost(UserEntity(name, email, photoUrl), issueEntity))
Observer gets event. But when I just add item to value, Observer is silent.
Could you please give me advice on how I can implement what I need?

Notify Observer when item is added to List of LiveData

How do I remove the observer after I receive the first result? Below are two code ways I&#39;ve tried, but they both keep receiving updates even though I have removed the observer.

    Observer observer = new Observer&lt;DownloadItem&gt;() {
            @Override
            public void onChanged(@Nullable DownloadItem downloadItem) {
                if(downloadItem!= null) {
                    DownloadManager.this.downloadManagerListener.onDownloadManagerFailed(null, &quot;this item already exists&quot;);
                    return;
                }
                startDownload();
                model.getDownloadByContentId(contentId).removeObservers((AppCompatActivity)context);
            }
        };
        model.getDownloadByContentId(contentId).observeForever(observer);

**************************************
     model.getDownloadByContentId(contentId).observe((AppCompatActivity)context, downloadItem-&gt; {
                 if(downloadItem!= null) {
                    this.downloadManagerListener.onDownloadManagerFailed(null, &quot;this item already exists&quot;);
                    return;
                }
                startDownload();
                model.getDownloadByContentId(contentId).removeObserver(downloadItem-&gt; {});
            } );

LiveData remove Observer after first callback

It looks like `MutableLiveData` differs from `LiveData` only by making the `setValue()` and `postValue()` methods public, whereas in `LiveData` they are protected.

What are some reasons to make a separate class for this change and not simply define those methods as public in the `LiveData` itself?

Generally speaking, is such a form of inheritance (increasing the visibility of certain methods being the only change) a well-known practice and what are some scenarios where it may be useful (assuming we have access to all the code)?

Why there&#39;s a separate MutableLiveData subclass of LiveData?

What is the difference between those 2 methods of the LiveData class? The official doc and tutorial are pretty vague on that. In the **map()** method the first parameter called **source** but in the **switchMap()** it called **trigger**. What&#39;s the rationale behind that?



What is the difference between map() and switchMap() methods?

In recent Android Architecture Components library released by Google, we have two static functions in the `Transformations` class. While the `map` function is straight forward and easily understandable, I am finding it hard to properly understand the `switchMap` function.

The official documentation of switchMap can be found [here][1].

Can somebody explain how and where to use the switchMap function with a practical example?


  [1]: https://developer.android.com/reference/android/arch/lifecycle/Transformations.html#switchMap(android.arch.lifecycle.LiveData%3CX%3E,%20android.arch.core.util.Function%3CX,%20android.arch.lifecycle.LiveData%3CY%3E%3E)

How and where to use Transformations.switchMap?

I have searched a lot but not found the crystal clear answer for the questions:

1. What is the difference between MediatorLiveData and MutableLiveData?

2. What are the suitable condition to use either of them.

What is difference between MediatorLiveData and MutableLiveData in MVVM

*My understanding on `LiveData` is that, it will trigger observer on the current state change of data, and not a series of history state change of data.*

Currently, I have a `MainFragment`, which perform `Room` write operation, to change **non-trashed data**, to **trashed data**.

I also another `TrashFragment`, which observes to **trashed data**.

Consider the following scenario.

 1. There are currently 0 **trashed data**.
 2. `MainFragment` is the current active fragment. `TrashFragment` is not created yet.
 3. `MainFragment` added 1 **trashed data**.
 4. Now, there are 1 **trashed data**
 5. We use navigation drawer, to replace `MainFragment` with `TrashFragment`.
 6. `TrashFragment`&#39;s observer will first receive `onChanged`, with 0 **trashed data**
 7. Again, `TrashFragment`&#39;s observer will secondly receive `onChanged`, with 1 **trashed data** 

What is out of my expectation is that, item (6) shouldn&#39;t happen. `TrashFragment` should only receive latest **trashed data**, which is 1.

Here&#39;s my codes


----------

TrashFragment.java
------------------

    public class TrashFragment extends Fragment {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            noteViewModel = ViewModelProviders.of(getActivity()).get(NoteViewModel.class);
        }
    
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            ...
    
            noteViewModel.getTrashedNotesLiveData().removeObservers(this);
            noteViewModel.getTrashedNotesLiveData().observe(this, notesObserver);
    
    
MainFragment.java
------------------    
    public class MainFragment extends Fragment {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            noteViewModel = ViewModelProviders.of(getActivity()).get(NoteViewModel.class);
        }
    
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            ...
    
            noteViewModel.getNotesLiveData().removeObservers(this);
            noteViewModel.getNotesLiveData().observe(this, notesObserver);
    
NoteViewModel .java
------------------

    public class NoteViewModel extends ViewModel {
        private final LiveData&lt;List&lt;Note&gt;&gt; notesLiveData;
        private final LiveData&lt;List&lt;Note&gt;&gt; trashedNotesLiveData;
    
        public LiveData&lt;List&lt;Note&gt;&gt; getNotesLiveData() {
            return notesLiveData;
        }
    
        public LiveData&lt;List&lt;Note&gt;&gt; getTrashedNotesLiveData() {
            return trashedNotesLiveData;
        }
    
        public NoteViewModel() {
            notesLiveData = NoteplusRoomDatabase.instance().noteDao().getNotes();
            trashedNotesLiveData = NoteplusRoomDatabase.instance().noteDao().getTrashedNotes();
        }
    }


----------

Code which deals with Room
--------------------------

    public enum NoteRepository {
        INSTANCE;
    
        public LiveData&lt;List&lt;Note&gt;&gt; getTrashedNotes() {
            NoteDao noteDao = NoteplusRoomDatabase.instance().noteDao();
            return noteDao.getTrashedNotes();
        }
        
        public LiveData&lt;List&lt;Note&gt;&gt; getNotes() {
            NoteDao noteDao = NoteplusRoomDatabase.instance().noteDao();
            return noteDao.getNotes();
        }
    }
        
    @Dao
    public abstract class NoteDao {
        @Transaction
        @Query(&quot;SELECT * FROM note where trashed = 0&quot;)
        public abstract LiveData&lt;List&lt;Note&gt;&gt; getNotes();
    
        @Transaction
        @Query(&quot;SELECT * FROM note where trashed = 1&quot;)
        public abstract LiveData&lt;List&lt;Note&gt;&gt; getTrashedNotes();
    
        @Insert(onConflict = OnConflictStrategy.REPLACE)
        public abstract long insert(Note note);
    }
        
    @Database(
            entities = {Note.class},
            version = 1
    )
    public abstract class NoteplusRoomDatabase extends RoomDatabase {
        private volatile static NoteplusRoomDatabase INSTANCE;
    
        private static final String NAME = &quot;noteplus&quot;;
    
        public abstract NoteDao noteDao();
    
        public static NoteplusRoomDatabase instance() {
            if (INSTANCE == null) {
                synchronized (NoteplusRoomDatabase.class) {
                    if (INSTANCE == null) {
                        INSTANCE = Room.databaseBuilder(
                                NoteplusApplication.instance(),
                                NoteplusRoomDatabase.class,
                                NAME
                        ).build();
                    }
                }
            }
    
            return INSTANCE;
        }
    }

Any idea how I can prevent from receiving `onChanged` twice, for a same data?


----------

Demo
----

I created a demo project to demonstrate this problem.

As you can see, after I perform write operation (Click on **ADD TRASHED NOTE** button) in `MainFragment`, when I switch to `TrashFragment`, I expect `onChanged` in `TrashFragment` will only be called once. However, it is being called twice.

[![enter image description here][1]][1]

Demo project can be downloaded from https://github.com/yccheok/live-data-problem



  [1]: https://i.stack.imgur.com/uLsLE.gif

Why LiveData observer is being triggered twice for a newly attached observer

In same cases Android studio displays warning message when I call `observe` method of `LiveData` object

    viewModel.emailValidationResult.observe(viewLifecycleOwner, {onEmailChanged(it)})

&gt; Candidate resolution will be changed soon, please use fully qualified
&gt; name to invoke the following closer candidate explicitly: 
&gt; 
&gt; **public open**
&gt; **fun** observe(owner: LifecycleOwner, observer: Observer&lt;in Int?&gt;): Unit
&gt; defined in androidx.lifecycle.LiveData

As I understand it&#39;s happened after updating kotlin 1.4
**What does it actually mean ?**

Live Data: Candidate resolution will be changed soon

How I can initialize **MutableLiveData** with initial value?
I&#39;m looking for something like:

`val text = MutableLiveData&lt;String&gt;(&quot;initial value&quot;)`

MutableLiveData with initial value

I have some questions about **Kotlin Flow**

1. I can observe `LiveData` from multiple Fragments. Can I do this with `Flow`? If yes then how?
2. We can have multiple `LiveData` from a single `LiveData` using `map`&amp; `switchMap`. Is there any way to have multiple `Flow` from a single source `Flow`?
3. Using `MutableLiveData` I can update data from anywhere using the variable reference. Is there any way to do the same with `Flow`?

I have a use-case like: I will observe a `SharedPreferences` using `callbackFlow{...}` which will give me a single source Flow. From that Flow, I want to create multiple Flow for each key-value pair.

These might sound silly questions. I am new to Rx and Flow world. 

Kotlin Flow vs Android LiveData

I&#39;m using Android MVVM architecture with LiveData. I have an object like this

    public class User {
        private String firstName;
        private String lastName;

        public String getFirstName() {
            return firstName;
        }

        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }

        public String getLastName() {
            return lastName;
        }

        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    }

And my view model looks like this 

    public class InfoViewModel extends AndroidViewModel {
        MutableLiveData&lt;User&gt; user = new MutableLiveData&lt;&gt;();

        public InfoViewModel(@NonNull Application application) {
            super(application);
            User user = new User();
            user.setFirstName(&quot;Alireza&quot;);
            user.setLastName(&quot;Ahmadi&quot;);

            this.user.setValue(user);
        }

        public LiveData&lt;User&gt; getUser(){
            return user;
        }

        public void change(){
            user.getValue().setFirstName(user.getValue().getFirstName() + &quot; A &quot;);
        }
    }

How can I make sure when some field in user object changes observers get notified? BTW it is important to me to keep this data in the separate object and not use primary values like Strings in my ViewModel.


LiveData update on object field change

According to [LiveData documentation][1]:

&gt; The LiveData class provides the following advantages:
&gt;
&gt;...
&gt;
&gt;**Always up to date data:** If a Lifecycle starts again (like an activity going back to started state from the back stack) it receives the latest location data (if it didn’t already).

But sometimes I don&#39;t need this feature. 

For example, I have following LiveData in ViewModel and Observer in Activity:

    //LiveData
    val showDialogLiveData = MutableLiveData&lt;String&gt;()

    //Activity
    viewModel.showMessageLiveData.observe(this, android.arch.lifecycle.Observer { message -&gt;
            AlertDialog.Builder(this)
                    .setMessage(message)
                    .setPositiveButton(&quot;OK&quot;) { _, _ -&gt; }
                    .show()
        })

Now after every rotation old dialog will appear.

Is there a way to clear stored value after it&#39;s handled or is it wrong usage of LiveData at all?

  [1]: https://developer.android.com/topic/libraries/architecture/livedata.html

How to clear LiveData stored value?

**Short question**:

What is the correct way to handle database + network on the Paging library from Architecture components, using an API that uses page + size to load a new page and the `BoundaryCallback` class?

**Research and explanation**

Currently the class [`BoundaryCallback`][1] used in the paging library for architecture components, receives as parameter the instance of an element in the list without actual context of where this element is at. It happens in `onItemAtFrontLoaded` and `onItemAtEndLoaded`.

My Api is supposed to receive the page and the size of the page to load the next chunk of data. Boundary callback, added as part of the paged list builder, is supposed to tell you when to load the next page of data based on prefetch distance and page size.

Since the Api needs the page number and the size of the page to provide, I don&#39;t see a way to send that to the Api just by receiving one of the elements from the list as offered in `onItemAtFrontLoaded` and `onItemAtEndLoaded`. Checking the google examples in [this link][2], they use the name of the last element to get the next one, but that doesn&#39;t fit an Api with page + size.

They also have another example with only network that uses [`PagedKeyedDatasource`][3], but there is no sample or clue on how to mix that with the database and the BoundaryCallback.

**Edit**:
Only solutions I have found so far is to store the last loaded page on the shared preferences, but that sounds like a dirty trick.

Refer to 
https://github.com/googlesamples/android-architecture-components/issues/252#issuecomment-392119468 for official input on it.

  [1]: https://developer.android.com/reference/android/arch/paging/PagedList.BoundaryCallback
  [2]: https://github.com/googlesamples/android-architecture-components/tree/master/PagingWithNetworkSample
  [3]: https://developer.android.com/reference/android/arch/paging/PageKeyedDataSource

Paging library - Boundary callback for network + db with API taking page and size

I have a fragment:

    class MyFragment : BaseFragment() {
    
       // my StudentsViewModel instance
       lateinit var viewModel: StudentsViewModel
       
       override fun onCreateView(...){
            ...
       }
    
       override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
           super.onViewCreated(view, savedInstanceState)
    
           viewModel = ViewModelProviders.of(this).get(StudentsViewModel::class.java)
           updateStudentList()
       }
    
       fun updateStudentList() {
            // Compiler error on &#39;this&#39;: Use viewLifecycleOwner as the LifecycleOwner
            viewModel.students.observe(this, Observer {
                //TODO: populate recycler view
            })
        }
    }

In my fragment, I have a instance of StudentsViewModel which is initiated in `onViewCreated(...)`.  

In, `StudentsViewModel`, `students` is a `LiveData`:

    class StudentsViewModel : ViewModel() {
        val students = liveData(Dispatchers.IO) {
              ...
        }
    }

Back to `MyFragment`, in function `updateStudentList()` I get compiler error complaining the `this` parameter I passed in to `.observe(this, Observer{...})` that `Use viewLifecycleOwner as the LifecycleOwner`

Why I get this error? How to get rid of it?

Use viewLifecycleOwner as the LifecycleOwner

I am using [`Transformations.switchMap`](https://developer.android.com/reference/android/arch/lifecycle/Transformations.html) in my ViewModel so my `LiveData` collection, observed in my fragment, reacts on changes of `code` parameter.

This works perfectly :

    public class MyViewModel extends AndroidViewModel {
    
        private final LiveData&lt;DayPrices&gt; dayPrices;
        private final MutableLiveData&lt;String&gt; code = new MutableLiveData&lt;&gt;();
        // private final MutableLiveData&lt;Integer&gt; nbDays = new MutableLiveData&lt;&gt;();
        private final DBManager dbManager;
    
        public MyViewModel(Application application) {
            super(application);
            dbManager = new DBManager(application.getApplicationContext());
            dayPrices = Transformations.switchMap(
                code,
                value -&gt; dbManager.getDayPriceData(value/*, nbDays*/)
            );
        }
    
        public LiveData&lt;DayPrices&gt; getDayPrices() {
            return dayPrices;
        }
    
        public void setCode(String code) {
            this.code.setValue(code);
        }

        /*public void setNbDays(int nbDays) {
            this.nbDays.setValue(nbDays);
        }*/
    
    }

    public class MyFragment extends Fragment {

        private MyViewModel myViewModel;

        myViewModel = ViewModelProviders.of(this).get(MyViewModel.class);
        myViewModel.setCode(&quot;SO&quot;);
        //myViewModel.setNbDays(30);
        myViewModel.getDayPrices().observe(MyFragment.this, dataList -&gt; {
            // update UI with data from dataList
        });
    }

**Problem**

I now need another parameter (`nbDays` commented in the code above), so that my `LiveData` object reacts on both parameters change (`code` and `nbDays`).

How can I chain transformations ?

Some reading pointed me to [MediatorLiveData](https://developer.android.com/reference/android/arch/lifecycle/MediatorLiveData.html), but it does not solve my problem (still need to call single DB function with 2 parameters, I don&#39;t need to merge 2 liveDatas).

So I tried this instead of `switchMap` but `code` and `nbDays` are always null.

    dayPrices.addSource(
        dbManager.getDayPriceData(code.getValue(), nbDays.getValue),
        apiResponse -&gt; dayPrices.setValue(apiResponse)
    );

One solution would be to pass an object as single parameter by I&#39;m pretty sure there is a simple solution to this.

All Android Livedata Solutions on Gang of Coders

Total of 18 Android Livedata Solutions

Difference of setValue() & postValue() in MutableLiveData