How to observe the livedata with multiple observe for correct way in Android?

Question

I have an Activity, and it will turn to the fragment-A and then turn to the fragment-B like the following.

Activity -> Fragment-A -> Fragment-B

situation 1

These two fragment observe the same LiveData for showing snackBar like the following .

viewModel.responseData.observe(this, Observer {
            it.getContentIfNotHandled()?.let {
            showSnackBar(it)
}

The livedata in viewModel:

var responseData = MutableLiveData<Event<String>>()
responseData.value = Event("$message")

Error: When I use the above code. It only show the snackBar at fragment-A. The fragment-B can not get the value.

situation 2

When I change the code to the following

viewModel.responseData.observe(this, Observer {
            showSnackBar(it.peekContent())
})

The both fragment can get the value.

Error:

After close the fragment and turn again. It show the snackBar because the value of responseData still exist. But I did not send the message.

Event class reference from Google is like the following:

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package bbin.mobile.ballbet.support

import androidx.lifecycle.Observer
import timber.log.Timber

/**
 * Used as a wrapper for data that is exposed via a LiveData that represents an event.
 */
open class Event<out T>(private val content: T) {

    var hasBeenHandled = false
        private set // Allow external read but not write

    /**
     * Returns the content and prevents its use again.
     */
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    /**
     * Returns the content, even if it's already been handled.
     */
    fun peekContent(): T = content
}

/**
 * An [Observer] for [Event]s, simplifying the pattern of checking if the [Event]'s content has
 * already been handled.
 *
 * [onEventUnhandledContent] is *only* called if the [Event]'s contents has not been handled.
 */
class EventObserver<T>(private val onEventUnhandledContent: (T) -> Unit) : Observer<Event<T>> {
    override fun onChanged(event: Event<T>?) {
        event?.getContentIfNotHandled()?.let {
            onEventUnhandledContent(it)
        }
    }
}

I want the fragment show the correct snackBar message for them.

How to observe the livedata for multiple fragment for correct way in Android?

Thanks in advance.

Go through this blog you will get to know. https://blog.mindorks.com/shared-viewmodel-in-android-shared-between-fragments — Rajnish suryavanshi, Sep 24 '19 at 07:16
Event used to notify only for single time value, so when you come back again on same fragment it won't get notified again on same value unless new event is added to livedata. — Jeel Vankhede, Sep 24 '19 at 07:23

score 3 · Answer 1 · answered Sep 24 '19 at 07:45

3

You are observing the LiveData correctly, it is how the Event class is designed.

When you do

viewModel.responseData.observe(this, Observer {
            it.getContentIfNotHandled()?.let {
            showSnackBar(it)
}

getContentIfNotHandled will return content only once until there is a new value set again. If FragmentA consumes this first FragmentB will not be able to consume the same value. This is the reason peekContent works since it will always return the current value even though the event has been consumed.

If there is a solid reason where you need to show this Snackbar msg in both fragments I suggest you observe on different LiveData instances for each fragment.

You could do this by returning a new LiveData<Event<String>> everytime viewModel.getResponseData() is invoked.

answered Sep 24 '19 at 07:45

Arka Prava Basu

2,366
3
18
34

That's weird .. I've never had to use `peekContent` when using shared liveDatas in java, although it always worked properly. – Arthur Attout Sep 24 '19 at 08:30
You should not rely on `peekContent` as it defeats the purpose of creating the `Event` class – Arka Prava Basu Sep 24 '19 at 08:48
Yes, and I'm not. I'm not using the Event strategy either. But I'm pretty sure I've already had a ViewModel that has a LiveData observed by several Fragments, and they were all updating properly, so I don't understand why it's not working for OP – Arthur Attout Sep 24 '19 at 08:50
Oooh I see, OP already uses this `Event` class, so that's why it wasn't working. – Arthur Attout Sep 24 '19 at 08:51

How to observe the livedata with multiple observe for correct way in Android?

1 Answers1

Linked

Related