DisposableExtension.kt

import com.trello.rxlifecycle2.LifecycleProvider
import io.reactivex.Observable
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.disposables.Disposable

fun Disposable.disposeWith(compositeDisposable: CompositeDisposable) {
    compositeDisposable.add(this)
}

fun <E> Disposable.disposeUntil(e: E, lifecycleProvider: LifecycleProvider<E>) {
    Observable
            .never<Any>()
            .compose(lifecycleProvider.bindUntilEvent(e))
            .subscribe({  }, {  }, { dispose() })
}

fun <E> Disposable.disposeWithLifecycle(lifecycleProvider: LifecycleProvider<E>) {
    Observable
            .never<Any>()
            .compose(lifecycleProvider.bindToLifecycle())
            .subscribe({  }, {  }, { dispose() })
}

Sample.kt

import com.trello.rxlifecycle2.LifecycleProvider
import com.trello.rxlifecycle2.LifecycleTransformer
import com.trello.rxlifecycle2.RxLifecycle
import io.reactivex.Observable
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.subjects.BehaviorSubject
import java.util.concurrent.TimeUnit

class Sample: LifecycleProvider<Sample.Event> {

    val observable = BehaviorSubject.create<Event>()

    override fun <T : Any?> bindUntilEvent(event: Event): LifecycleTransformer<T> =
        RxLifecycle.bindUntilEvent<T, Event>(observable, event)


    override fun <T : Any?> bindToLifecycle(): LifecycleTransformer<T> =
        RxLifecycle.bind(observable)


    override fun lifecycle(): Observable<Event> = observable.hide()

    enum class Event {
        CREATE,
        DESTROY
    }

    fun makeNetworkCall() {
        Observable.timer(100, TimeUnit.SECONDS)
                .subscribe().disposeWithLifecycle(this)
    }

    fun makeNetworkCall2() {
        Observable.timer(100, TimeUnit.SECONDS)
                .subscribe().disposeUntil(Event.DESTROY, this)
    }

    fun makeNetworkCall3(compositeDisposable: CompositeDisposable) {
        Observable.timer(100, TimeUnit.SECONDS)
                .subscribe().disposeWith(compositeDisposable)
    }

    fun emitCreate() {
        observable.onNext(Event.CREATE)
    }

    fun emitDestroy() {
        observable.onNext(Event.DESTROY)
    }
}


fun main(args: Array<String>) {
    var sample = Sample()
    sample.emitCreate()
    sample.makeNetworkCall()
    sample.emitDestroy()

    sample = Sample()
    sample.makeNetworkCall2()
    sample.emitCreate()
    sample.emitDestroy()

    sample = Sample()
    val compositeDisposable = CompositeDisposable()
    sample.makeNetworkCall3(compositeDisposable)
    compositeDisposable.dispose()
}