Understanding LiveData and Event Bus Implementations in Android

In Android development, message passing is essential for communication between components and threads. Traditional approaches such as Handler , BroadcastReceiver , and interface callbacks have been supplemented by popular event‑bus libraries like EventBus , RxBus , and Otto .

EventBus provides a publish/subscribe model that decouples senders and receivers, simplifying communication across Activities, Fragments, and background threads while handling lifecycle concerns better than the older mechanisms.

RxBus leverages RxJava’s Subject to implement an event bus, allowing developers to replace third‑party buses with a reactive approach and reduce library dependencies, though it still requires careful lifecycle management to avoid memory leaks.

Otto , introduced by Square, uses reflection to deliver events without holding direct references, but it suffers from performance overhead, limited parameter support, and reduced extensibility, leading Square to recommend RxJava‑based solutions instead.

The Android Architecture Components introduce LiveData , a lifecycle‑aware observable holder that automatically removes observers when the associated LifecycleOwner is destroyed, eliminating manual unregistration and preventing memory leaks.

LiveData offers two registration modes: observe , which respects the owner’s lifecycle (active only in STARTED or RESUMED states), and observeForever , which receives events regardless of lifecycle and therefore must be manually cleared to avoid leaks.

Key implementation details include:

• MutableLiveData extends LiveData and overrides postValue(T value) and setValue(T value) to handle background‑thread updates.

• setValue must run on the UI thread; it updates mVersion and notifies active observers via dispatchingValue(null) .

• postValue queues a value for the main thread, ultimately invoking setValue after thread‑switching.

• observe creates a LifecycleBoundObserver that registers with the owner’s lifecycle and automatically removes the observer when the owner reaches the DESTROYED state.

• observeForever uses an AlwaysActiveObserver that is always active, requiring explicit removal via removeObserver .

To prevent newly registered observers from receiving stale events, LiveEventBus overrides observe to set the observer’s mLastVersion to the current mVersion :

if (observer.mLastVersion >= mVersion) { return; }

The article concludes that LiveData’s built‑in lifecycle awareness, small footprint, and lack of external dependencies make it a superior foundation for a custom event bus, and it recommends the open‑source LiveEventBus project for practical use.