Let every Observer only receive *new* LiveData upon subscribing/observing

Question

Whenever you call .observe() on LiveData, the Observer receives the last value of that LiveData. This may be useful in some cases, but not in mine.

1. Whenever I call .observe(), I want the Observer to receive only future LiveData changes, but not the value it holds when .observe() is called.

2. I may have more than one Observer for a LiveData instance. I want them all to receive LiveData updates when they happen.

3. I want each LiveData update to be consumed only once by each Observer. I think is just a re-phrasing of the first requirement, but my head is spinning already and I'm not sure about it.

---

While googling this problem, I came upon two common approaches:

1. Wrap the data in an LiveData<SingleEvent<Data>> and check in this SingleEvent class if it was already consumed.

2. Extend MediatorLiveData and use a look-up-map if the Observer already got the Event

Examples for these approaches can be found here: https://gist.github.com/JoseAlcerreca/5b661f1800e1e654f07cc54fe87441af#gistcomment-2783677 https://gist.github.com/hadilq/f095120348a6a14251a02aca329f1845#file-liveevent-kt https://gist.github.com/JoseAlcerreca/5b661f1800e1e654f07cc54fe87441af#file-event-kt

Unfortunately none of these examples solves all my requirements. Most of the time, the problem is that any new Observer still receives the last LiveData value upon subscribing. That means that a Snackbar which was already shown is displayed again and again whenever the user navigates between screens.

---

To give you some insights what I am talking about / what I am coding about:

I am following the LiveData MVVM design of the Android Architecture Componentns:

• 2 ListFragment are showing a list of entries.
• They are using 2 instances of the same ViewModel class to observe UI-related LiveData.
• The user can delete an entry in such a ListFragment. The deletion is done by the ViewModel calling Repository.delete()
• The ViewModel observes the Repository for RepositoryEvents.

So when the deletion is done, the Repository informs the ViewModel about it and the ViewModel inform the ListFragment about it.

Now, when the user switches to the second ListFragment the following happens:

• The second Fragment gets created and calls .observe() on its ViewModel

• The ViewModel gets created and calls .observe() on the Repository

• The Repository sends its current RepositoryEvent to the ViewModel

• The ViewModel send the according UI Event to the Fragment
• The Fragment shows a confirmation Snackbar for a deletion that happened somewhere else.

Heres some simplified code:

Fragment:

viewModel.dataEvents.observe(viewLifecycleOwner, Observer { showSnackbar() })
viewModel.deleteEntry()

ViewModel:

val dataEvents: LiveData<EntryListEvent> = Transformations.switchMap(repository.events, ::handleRepoEvent)
fun deleteEntry() = repository.deleteEntry()
private fun handleRepoEvent(event: RepositoryEvent): LiveData<EntryListEvent> {
    // convert the repository event to an UI event
}

Repository:

private val _events = MutableLiveData<RepositoryEvent>()
val events: LiveData<RepositoryEvent>
    get() = _events

fun deleteEntry() {
    // delete it from database
    _events.postValue(RepositoryEvent.OnDeleteSuccess)
}

Answer 1

UPDATE 2021:

Using the coroutines library and Flow it is now very easy to achieve this by implementing Channels:

MainActivity

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.lifecycleScope
import com.google.android.material.snackbar.Snackbar
import com.plcoding.kotlinchannels.databinding.ActivityMainBinding
import kotlinx.coroutines.flow.collect

class MainActivity : AppCompatActivity() {

    private lateinit var viewModel: MainViewModel

    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)

        binding.btnShowSnackbar.setOnClickListener {
            viewModel.triggerEvent()
        }

        lifecycleScope.launchWhenStarted {
            viewModel.eventFlow.collect { event ->
                when(event) {
                    is MainViewModel.MyEvent.ErrorEvent -> {
                        Snackbar.make(binding.root, event.message, Snackbar.LENGTH_LONG).show()
                    }
                }
            }
        }

    }
}

MainViewModel

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.consumeEach
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch

class MainViewModel : ViewModel() {

    sealed class MyEvent {
        data class ErrorEvent(val message: String): MyEvent()
    }

    private val eventChannel = Channel<MyEvent>()
    val eventFlow = eventChannel.receiveAsFlow()

    fun triggerEvent() = viewModelScope.launch {
        eventChannel.send(MyEvent.ErrorEvent("This is an error"))
    }
}

Answer 2

For me problem was solved with this:

Event wrapper class to keep event related data(Copy from google samples)

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;
    }
}

Next, i create event observer class, that handles data checks(null, etc):

public class EventObserver<T> implements Observer<Event<T>> {

  @Override
  public void onChanged(Event<T> tEvent) {
    if (tEvent != null && !tEvent.hasBeenHandled())
      onEvent(tEvent.getContentIfNotHandled());
  }

  protected void onEvent(@NonNull T content) {}
}

And, event handler class, to simplify access from viewmodel:

public class EventHandler<T> {

  private MutableLiveData<Event<T>> liveEvent = new MutableLiveData<>();

  public void observe(@NonNull LifecycleOwner owner, @NonNull EventObserver<T> observer){
      liveEvent.observe(owner, observer);
  }

    public void create(T content) {
    liveEvent.setValue(new Event<>(content));
  }
}

Example:

In ViewModel.class:

private EventHandler<Boolean> swipeEventHandler = new EventHandler<>();

  public EventHandler<Boolean> getSwipeEventHandler() {
    return swipeEventHandler;
  }

In Activity/Fragment:

Start observing:

 viewModel
    .getSwipeEventHandler()
    .observe(
        getViewLifecycleOwner(),
        new EventObserver<Boolean>() {
          @Override
          protected void onEvent(@NonNull Boolean content) {
            if(content)confirmDelete(modifier);
          }
        });

Create event:

viewModel.getSwipeEventHandler().create(true);

Answer 3

Created a basic sealed class flag in the need of:

sealed class Event(private var handled: Boolean = false) {

        val coldData: Event?
            get() {
                return if (handled) null else {
                    handled = true
                    this
                }
            }

        class ShowLoader() : Event()
        class HideLoader() : Event()
        class ShowErrorAlert(@StringRes val message: Int) : Event()
    }

Then it can be observed at different fragments

viewModel.eventFlow.observe(this) { event ->

            val data = event.coldData

            when (data) {
                is Event.ShowLoader -> {
                    progressBar.visible = true
                }
                is Event.HideLoader -> {
                    progressBar.visible = false
                }
                is Event.ShowErrorAlert -> {
                    showAlert(data.message)
                }
                else -> {
                    // do nothing
                }
            }
        }

Or use a subclass of MutableLiveDatawith the same purpose to process them individually.

Answer 4

You can add this functionality in an extension function. Just replace the call to observe with it. It will emit only events emitted after observing the LiveData object.

fun <T> LiveData<T>.observeFutureEvents(owner: LifecycleOwner, observer: Observer<T>) {
    observe(owner, object : Observer<T> {
        var isFirst = true

        override fun onChanged(value: T) {
            if (isFirst) {
                isFirst = false
            } else {
                observer.onChanged(value)
            }
        }
    })
}