ボツネタ。 Lifecycle with ViewModel は使える

LifecycleDisposables.kt

package reactive.view.lifecycle

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.OnLifecycleEvent
import androidx.lifecycle.ViewModelStoreOwner
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.disposables.Disposable
import reactive.viewmodel.ReactiveViewModel

enum class LifecycleEvent {
    OnPause,
    OnStop,
    OnDestroy
}

private fun <T> T.getOrCreateLifecycleDisposable(): LifecycleDisposables where T : LifecycleOwner, T : ViewModelStoreOwner =
    ReactiveViewModel.getOrCreate(LifecycleDisposables::class.java, this, ::LifecycleDisposables).also {
        it.lifecycle = lifecycle
    }

fun <T> Disposable.disposeOnLifecycle(owner: T, lifecycleEvent: LifecycleEvent? = null) where T : LifecycleOwner, T : ViewModelStoreOwner {
    owner.getOrCreateLifecycleDisposable().addToOnLifecycle(this, lifecycleEvent)
}

fun <T> Disposable.disposeOnPause(owner: T) where T : LifecycleOwner, T : ViewModelStoreOwner {
    disposeOnLifecycle(owner, LifecycleEvent.OnPause)
}

fun <T> Disposable.disposeOnStop(owner: T) where T : LifecycleOwner, T : ViewModelStoreOwner {
    disposeOnLifecycle(owner, LifecycleEvent.OnStop)
}

fun <T> Disposable.disposeOnDestroy(owner: T) where T : LifecycleOwner, T : ViewModelStoreOwner {
    disposeOnLifecycle(owner, LifecycleEvent.OnDestroy)
}

private class LifecycleDisposables : ReactiveViewModel(), LifecycleObserver {
    internal var lifecycle: Lifecycle? = null
        set(value) {
            if (field != value) {
                field?.removeObserver(this)
                field = value
                field?.addObserver(this)
            }
        }

    private val onPauseDisposables = CompositeDisposable()
    private val onStopDisposables = CompositeDisposable()
    private val onDestroyDisposables = CompositeDisposable()


    fun addToOnLifecycle(disposable: Disposable, lifecycleEvent: LifecycleEvent?) {
        when (lifecycleEvent) {
            LifecycleEvent.OnPause -> onPauseDisposables.add(disposable)
            LifecycleEvent.OnStop -> onStopDisposables.add(disposable)
            LifecycleEvent.OnDestroy -> onDestroyDisposables.add(disposable)
            null -> when (lifecycle?.currentState) {
                Lifecycle.State.INITIALIZED -> onDestroyDisposables.add(disposable)
                Lifecycle.State.CREATED -> onStopDisposables.add(disposable)
                Lifecycle.State.STARTED -> onPauseDisposables.add(disposable)
                Lifecycle.State.RESUMED -> onPauseDisposables.add(disposable)
                Lifecycle.State.DESTROYED -> disposable.dispose()
            }
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        onPauseDisposables.clear()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        onStopDisposables.clear()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        lifecycle = null
        onDestroyDisposables.clear()
    }

    override fun onCleared() {
        super.onCleared()
        onPauseDisposables.dispose()
        onStopDisposables.dispose()
        onDestroyDisposables.dispose()
    }
}