hadilq / liveevent Goto Github PK

Hi,
I always used Event wrapper for handling actions. But I found this solution as a better approach.

However It would be great if you add encapsulation support. I mean for LiveData itself we have two classes: LiveData and MutableLiveData and for example we use them in a ViewModel like below:

private val _isEnabled = MutableLiveData<Boolean>(false)
val isEnabled: LiveData<Boolean>
    get() = _isEnabled

With this approach we cannot post values inside view to the LiveData we observing. So in this library we can have two classes like LiveEvent and MutableLiveEvent that extends from LiveEvent. This two functions (postValue() and setValue()) must be protected inside LiveEvent class and public inside MutableLiveEvent.

Hi there.
I'm sorry if this is vague but unfortunately I don't have much time to spend on this at this stage.
Anyway, I swapped my SingleLiveEvent class taken from the one on the google repo for yours since I needed the same functionality but with multiple observers.
All I did is a direct copy paste into the SingleLiveEvent class with your code in, and the very first event I use in the class ( it's on the main activity to decie whther to go to the login screen or Home ) never fired at all, so the app just hangs there.
I've left the exact same code as from SingleLiveEvent, only swapped out the code in the class, and it doesn't work.
I don't know if there's something obvious I'm missing...

Try run this code, but notify min api 23

    private val observers = ArraySet<ObserverWrapper<in T>>()

In actuality I use this code extract SO

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
}

    @MainThread
    override fun observeForever(observer: Observer<in T>) {
        val wrapper = ObserverWrapper(observer)
        observers.add(wrapper)
        super.observeForever(wrapper)
    }

is not implemented.

So LiveEvent is not possible to use source of MediatorLiveData.
(MediatorLiveData uses observeForever)

Its great now that we can add multiple observers to the LiveEvent object, But in most cases we want to act as we added a single observer. For example imagine that we accidentally added observer in onViewCreated of the fragment and we did not removed the observer. So after going to another fragment and getting back actions will be called twice (Or there can be another similar cases). I think it is good to have such a SingleLiveEvent class that only delivers data for the first observer in such cases.

Thanks

Defining the class as open would allow inheritance, which is something that is not possible currently. For debugging reasons I am overriding the setValue method and adding logging there, something which is not possible with this implementation. I know I can easily log this elsewhere but more substantial changes would suffer from this.

If LiveEvent.observe or LiveEvent.observeForever is called multiple times, it will add the same observer multiple times. This is because ObserverWrapper is added around the observer and this negates the usefulness of having the ArraySet of observers since a unique entry is added each time.

data.observeForever(dataObserver)
data.observeForever(dataObserver)
data.observeForever(dataObserver)

data.postValue(value)

This results in dataObserver being notified 3 times. When using typical LiveData, adding the same observer (perhaps accidently) multiple times would not be an issue.

When starting to observe a LiveEvent that has a value already pending, the observer is not fired and the first event is lost.

Type mismatch.
Required:
Observer<T!>
Found:
LiveEvent.ObserverWrapper

Is it related to my Kotlin version (1.3.50) ?
Anyway removing contravariancy from types and parameters helped to compile.

This may be an optional feature, but I recommend adding it, as there are several cases where it can be useful.

If oldValue == newValue then ignore this. I need it for ClickEvent for to avoid of double tap problem with navigation.

I was under the impression that using LiveEvent, we would be able to use these events to trigger dialogs in a Fragment. E.g.

class MyFragment : Fragment(){
    override fun onCreateView(inflater: LayoutInflater,
                              container: ViewGroup?,
                              savedInstanceState: Bundle?): View? {

        val binding = // inflate view using Databinding
        binding.viewModel = // some viewModel
        viewModel.events().observe(viewLifecycleOwner, Observer { event ->
                showDialog(event)
        })
        return binding.root
    }
}

This is the ViewModel:

class MyViewModel : ViewModel(){
    private val events = MutableLiveData<DialogEvent>()
    fun events(): LiveData<DialogEvent> = events.toSingleEvent()

    fun onClick() = events.postValue(DialogEvent)
}

object DialogEvent

So, whenever I click a button, a dialog is shown.
However, when I rotate the screen, the dialog is shown again.
This makes sense, because on orientation change, the observer is removed, added again, and will receive the latest value...

Am I wrong that LiveEvent can be used in these scenario's?
Or am I missing something obvious?

Just a small nit here: https://github.com/hadilq/LiveEvent/blob/f47ac07a3fa6a7cf2af4e956416cc65032b29d56/lib/src/main/res/values/strings.xml can be deleted as it has just one string called app_name which is unused.

If the LiveEvent's setValue is called before observe and there is no observer to consume the event the next registered observer is not receiving the event as well because pending is by default false.

This is maybe a deliberate decision but I find it a huge weakness of the design.

Shouldn't this line be
if (observer is ObserverWrapper && observers.remove(observer)) {
Got lint error here

Do we need to resend value that was set before we observe liveevent?

For example we set value to our live data and only after this we subscribe with observer.
With current implementation we will not receive current value to our observer

val event = LiveEvent<Boolean>()
event.value = true
event.observe(this, Observer {
           // no trigger
})

If there is no support for Voids we can check value in observe function and send it to newly subscribed observers if it's not null.

Currently, LiveEvent class inherits from MediatorLiveData. However, when using addSource(), the correct result is not obtained.

For example, if you rewrite the following test code, the test will fail.

@Test
fun `observe after emit event`() {
    // Given
    val mutableLiveData = MutableLiveData<String>()
    liveEvent.addSource(mutableLiveData) {
        liveEvent.value = it
    }
    owner.create()
    val event = "event"
    mutableLiveData.value = event
    liveEvent.observe(owner, observer)

    // When
    owner.start()

    // Then
    if (config == LiveEventConfig.Normal) {
        verify(observer, never()).onChanged(event) // This test does not pass
    } else {
        verify(observer, times(1)).onChanged(event)
    }
}

Should the LiveEvent class be an inheritance of MutableLiveData?

First of all, thank you for the community contribution with your LiveEvent, @hadilq !

I noticed that 3 tests are failing:

• observe after remove multi owner
• observe after remove owner
• observe after remove

One of the most common usages of LiveData from a ViewModel is through the postValue method which doesn't seem to be implemented.

It seems to be triggered when lifecycle goes to STARTED state. How do I prevent this behaviour and make it triggered only if event happened when observer is active?