Disposer

General

Category
Free
Tag
FRP
License
MIT License
Min SDK
19 (Android 4.4 KitKat)
Registered
Oct 2, 2018
Favorites
0
Link
https://github.com/sellmair/disposer
See also
assert-rx
RxActions
Android-RxJava
RxJavaJoins
RxAgera

Additional

Language
Kotlin
Version
v3.0.0 (Nov 18, 2020)
Created
Sep 29, 2018
Updated
Nov 17, 2020 (Retired)
Owner
Sebastian Sellmair (sellmair)
Contributors
Fabian Terhorst (FabianTerhorst)
Sebastian Sellmair (sellmair)
SeungHun Choe (uOOOO)
3
Activity
Badge
Generate
Download
Source code
APK file

Announcement

Disposer

Easily dispose RxJava streams with Android's Lifecycle

Checkout my Medium article.

Usage

Gradle
dependencies {
    // Non AndroidX projects
    implementation 'io.sellmair:disposer:1.1.0'
    
    // AndroidX projects rxjava2
    implementation 'io.sellmair:disposer:2.0.0'
    
    // AndroidX projects rxjava3    
    implementation 'io.sellmair:disposer:3.0.0'
}

Disposer

A Disposer is the object managing multiple Disposable instances and disposes them at the correct time.

You can easily add a given disposable to a Disposer:

val disposer: Disposer = /* ... */
val disposable = Service.queryAwesomeData().subscribe()
disposer.add(disposable)  // The disposable will now managed by the disposer

Or a much sweeter apis, that might look familiar to rxKotlin users:

val disposer: Disposer = /* ... */
disposer += Service.queryAwesomeData().subscribe() // Managed by the disposer
val disposer: Disposer = /* ... */
Service.queryAwesomeData().subscribe().disposeBy(disposer) // Managed by the disposer

Get the correct Disposer

RxLifecycle makes it easy to get a disposer for each lifecycle hook like onCreate, onStart, onResume, onPause, onStop and onDestroy

One can simple call the extension function:

val onStopDisposer: Disposer = lifecycle.disposers.onStop

Much more shorter and convenient extensions are also offered, like for LifecycleOwner:

class MyCoolComponent: LifecycleOwner {
    
    // ...
    
    private val onStopDisposer: Disposer = this.onStop

}

Which leads to very concise and readable API's inside your Activity or Fragment classes:


Example:
class MyCoolFragment {
    
    // awesome other code 
    
    fun onStart(){
        super.onStart()
        
        awesomDataProvider.query()
            .flatMap(::pepareForAwesomeness)
            .filter(::isAwesome)
            .subscribe(::displayAwesomeData)
            .disposeBy(onStop) // <---  Will automatically be disposed when onStop() is called.
    }
}
Advanced: Upstream dispose

It is also possible to put the .disposeBy call before the .subscribe. But be aware, that this will only dispose the upstream not the downstream, which is often okay, but should only be used with caution!

awesomDataProvider.query()
    .flatMap(::pepareForAwesomeness)
    .filter(::isAwesome)
    .disposeBy(onStop) // <--- Will dispose everything above it when .onStop() is called
    .subscribe(::displayAwesomeData)
Create you own Disposer

You can easily create your own Disposer by calling

val disposer = Disposer.create()

Each call of

disposer.dispose()

Will dispose all currently managed disposables and reset the Disposer

⚠️ Be aware: This behaviour differs from CompositeDisposable and actually is more like CompositeDisposable.clear.