How to clear LiveData stored value?

Question

According to LiveData documentation:

The LiveData class provides the following advantages:

...

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't need this feature.

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

//LiveData
val showDialogLiveData = MutableLiveData<String>()

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

Now after every rotation old dialog will appear.

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

Answer 1

Update

There are actually a few ways to resolve this issue. They are summarized nicely in the article LiveData with SnackBar, Navigation and other events (the SingleLiveEvent case). This is written by a fellow Googler who works with the Architecture Components team.

TL;DR A more robust approach is to use an Event wrapper class, which you can see an example of at the bottom of the article.

This pattern has made it's way into numerous Android samples, for example:

• Plaid
• Architecture Blueprints
• IOSched

Why is an Event wrapper preferred over SingleLiveEvent?

One issue with SingleLiveEvent is that if there are multiple observers to a SingleLiveEvent, only one of them will be notified when that data has changed - this can introduce subtle bugs and is hard to work around.

Using an Event wrapper class, all of your observers will be notified as normal. You can then choose to either explicitly "handle" the content (content is only "handled" once) or peek at the content, which always returns whatever the latest "content" was. In the dialog example, this means you can always see what the last message was with peek, but ensure that for every new message, the dialog only is triggered once, using getContentIfNotHandled.

Old Response

Alex's response in the comments is I think exactly what you're looking for. There's sample code for a class called SingleLiveEvent. The purpose of this class is described as:

A lifecycle-aware observable that sends only new updates after subscription, used for events like navigation and Snackbar messages.

This avoids a common problem with events: on configuration change (like rotation) an update can be emitted if the observer is active. This LiveData only calls the observable if there's an explicit call to setValue() or call().

Answer 2

I`m not sure if it will work in your case, but in my case (increasing/decreasing items amount in Room by click on views) removing Observer and checking if there is active observers let me do the job:

LiveData<MenuItem> menuitem = mViewModel.getMenuItemById(menuid);
menuitem.observe(this, (MenuItem menuItemRoom) ->{
                menuitem.removeObservers(this);
                if(menuitem.hasObservers())return;

                // Do your single job here

                });
});  

UPDATE 20/03/2019:

Now i prefer this: EventWraper class from Google Samples inside MutableLiveData

/**
 * Used as a wrapper for data that is exposed via a LiveData that represents an event.
 */
public class Event<T> {

    private T mContent;

    private boolean hasBeenHandled = false;


    public Event( T content) {
        if (content == null) {
            throw new IllegalArgumentException("null values in Event are not allowed.");
        }
        mContent = content;
    }

    @Nullable
    public T getContentIfNotHandled() {
        if (hasBeenHandled) {
            return null;
        } else {
            hasBeenHandled = true;
            return mContent;
        }
    }

    public boolean hasBeenHandled() {
        return hasBeenHandled;
    }
}

In ViewModel :

 /** expose Save LiveData Event */
 public void newSaveEvent() {
    saveEvent.setValue(new Event<>(true));
 }

 private final MutableLiveData<Event<Boolean>> saveEvent = new MutableLiveData<>();

 LiveData<Event<Boolean>> onSaveEvent() {
    return saveEvent;
 }

In Activity/Fragment

mViewModel
    .onSaveEvent()
    .observe(
        getViewLifecycleOwner(),
        booleanEvent -> {
          if (booleanEvent != null)
            final Boolean shouldSave = booleanEvent.getContentIfNotHandled();
            if (shouldSave != null && shouldSave) saveData();
          }
        });

Answer 3

If you need simple solution, try this one:

class SingleLiveData<T> : MutableLiveData<T?>() {

    override fun observe(owner: LifecycleOwner, observer: Observer<in T?>) {
        super.observe(owner, Observer { t ->
            if (t != null) {
                observer.onChanged(t)
                postValue(null)
            }
        })
    }
}

Use it like a regular MutableLiveData

Answer 4

In my case SingleLiveEvent doesn't help. I use this code:

private MutableLiveData<Boolean> someLiveData;
private final Observer<Boolean> someObserver = new Observer<Boolean>() {
    @Override
    public void onChanged(@Nullable Boolean aBoolean) {
        if (aBoolean != null) {
            // doing work
            ...

            // reset LiveData value  
            someLiveData.postValue(null);
        }
    }
};

Answer 5

I solved it like that. Live data will clear itself when there is no observer

class SelfCleaningLiveData<T> : MutableLiveData<T>(){
    override fun onInactive() {
       super.onInactive()
       value = null
    }

} 

Answer 6

You need to use SingleLiveEvent for this case

class SingleLiveEvent<T> : MutableLiveData<T>() {

    private val pending = AtomicBoolean(false)

    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<T>) {

        if (hasActiveObservers()) {
            Log.w(TAG, "Multiple observers registered but only one will be notified of changes.")
        }

        // Observe the internal MutableLiveData
        super.observe(owner, Observer<T> { t ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        })
    }

    @MainThread
    override fun setValue(t: T?) {
        pending.set(true)
        super.setValue(t)
    }

    /**
     * Used for cases where T is Void, to make calls cleaner.
     */
    @MainThread
    fun call() {
        value = null
    }

    companion object {
        private const val TAG = "SingleLiveEvent"
    }
}

And inside you viewmodel class create object like:

 val snackbarMessage = SingleLiveEvent<Int>()

Answer 7

The best solution I found is live event library which works perfectly if you have multiple observers:

class LiveEventViewModel : ViewModel() {
    private val clickedState = LiveEvent<String>()
    val state: LiveData<String> = clickedState

    fun clicked() {
        clickedState.value = ...
    }
}

Answer 8

Might be an ugly hack but... Note: it requires RxJava

menuRepository
            .getMenuTypeAndMenuEntity(menuId)
            .flatMap { Single.fromCallable { menuTypeAndId.postValue(Pair(it.first, menuId)) } }
            .flatMap { Single.timer(200, TimeUnit.MILLISECONDS) }
            .subscribe(
                { menuTypeAndId.postValue(null) },
                { Log.d(MenuViewModel.TAG, "onError: ${it.printStackTrace()}") }
            )

Answer 9

I know It's not the best way or even a professional way but if you do not hav time to do it the right way you can recreate the MutableLiveDataa after you observed it. it would be like :

    private void purchaseAllResultFun() {
    viewModel.isAllPurchaseSuccess().observe(getViewLifecycleOwner(), isSuccess -> {
        if (!isSuccess) {
            failedPurchaseToast();
        }else {
            successfulPurchaseToast();
        }
        //reset mutableLiveData after you're done
        viewModel.resetIsAllSuccessFull();
    });
}

//function in viewmodel class
public void resetIsAllSuccessFull(){
    purchaseRepository.reSetIsAllSuccessFull();
}

//function in repository class
public void resetIsAllSuccessFull(){
    successLiveData = new MutableLiveData<>();
}

In this way if you need to recall purchaseAllResultFun() function it won't give the stored value.

Answer 10

Solution worked for me :

class SingleLiveData<T> : MutableLiveData<T>() {

override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
    super.observe(owner, Observer { t ->
        if (t != null) {
            observer.onChanged(t)
            value=null
        }
    })
}}'

Answer 11

I had the same issue. Old data kept re-appearing.

Reinitialising the MutableLiveData worked for me on onCreate()

on ViewModel :

public MutableLiveData<CityResponse.CityBean> cityCollabMapLiveData = new MutableLiveData<>();

Reinitialising (onCreate() of the fragment):

viewModel.cityCollabMapLiveData = new MutableLiveData<>();
binding.etCollabCity.setText("");