RxPM

Reactive implementation of Presentation Model pattern in Android.

Why use RxPM?

Ever found yourself thinking about passing the RxJava chain from the View to the Presenter in MVP? Don’t satisfied with Databinding Library in MVVM? Then you are one of us, who think this patterns are not Rx-friendly.

RxPM allows to use the RxJava all the way from a widget to the data. And the main advantage of that is the possibility to declaratively define and interconnect reactive states.

Dependency

Add the dependency to your build.gradle:

dependencies {

    compile 'me.dmdev.rxpm:rxpm:1.1'
    
    // optional RxBinding
    compile 'com.jakewharton.rxbinding2:rxbinding-kotlin:$latest_version'
    
    // if you use Conductor
    compile 'com.bluelinelabs:conductor:$latest_version'
}

Usage

Create a Presentation Model class and define reactive properties

class DataPresentationModel(
        private val dataModel: DataModel
) : PresentationModel() {

    val data = State<List<Item>>(emptyList())
    val inProgress = State(false)
    val errorMessage = Command<String>()
    val refreshAction = Action<Unit>()

    override fun onCreate() {
        super.onCreate()

        refreshAction.observable
                .skipWhileInProgress(inProgress.observable)
                .flatMapSingle {
                    dataModel.loadData()
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .bindProgress(inProgress.consumer)
                            .doOnError { 
                                errorMessage.consumer.accept("Loading data error")
                            }
                }
                .retry()
                .subscribe(data.consumer)
                .untilDestroy()

        refreshAction.consumer.accept(Unit) // first loading on create
    }
}

Bind to the PresentationModel properties

class DataFragment : PmSupportFragment<DataPresentationModel>() {

    override fun providePresentationModel() = DataPresentationModel(DataModel())

    override fun onBindPresentationModel(pm: DataPresentationModel) {

        pm.inProgress.observable.bindTo(swipeRefreshLayout.refreshing())

        pm.data.observable.bindTo {
            // adapter.setItems(it)
        }

        pm.errorMessage.observable.bindTo {
            // show alert dialog
        }

        swipeRefreshLayout.refreshes().bindTo(pm.refreshAction.consumer)
    }
}

Main Components

State

State is a reactive property which represents a View state. It holds the latest value and emits it on binding. For example, State can be used to represent a progress of the http-request or some data that can change in time.

In the PresentationModel:

val inProgress = State<Boolean>(false)

Change the value through the consumer:

inProgress.consumer.accept(true)

Observe changes in the View:

pm.inProgress.observable.bindTo(progressBar.visibility())

Action

Action is the reactive property which represents the user actions. It's mostly used for receiving events from the View, such as clicks.

In the View:

button.clicks().bindTo(pm.buttonClicks.consumer)

In the PresentationModel:

val buttonClicks = Action<Unit>()

buttonClicks.observable
    .subscribe {
        // handle click
    }
    .untilDestroy()

Command

Command is the reactive property which represents a command to the View. It can be used to show a toast or alert dialog.

Define it in the PresentationModel:

val errorMessage = Command<String>()

Show some message in the View:

pm.errorMessage.observable.bindTo { message ->
    Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
}

When the View is unbound from the PresentationModel, Command collects all received values and emits them on binding:

PresentationModel

The PresentationModel stores the state of the View and holds the UI logic. PresentationModel instance is automatically retained during configuration changes. This behavior is provided by the delegate which controls the lifecycle.

Lifecycle callbacks:

onCreate() — Called when the PresentationModel is created. Initialize your Rx chains in this method.
onBind() — Called when the View binds to the PresentationModel.
onUnbind() — Called when the View unbinds from the PresentationModel.
onDestroy() — Called when the PresentationModel is being destroyed. Dispose all subscriptions in this method.

What's more you can observe lifecycle changes via lifecycleObservable.

Also the useful extensions of the Disposable are available to make lifecycle handling easier: untilUnbind and untilDestroy.

PmView

The library has several predefined classes which implement AndroidPmView: PmSupportActivity, PmSupportFragment and PmController (for Conductor's users).

You have to implement two methods:

providePresentationModel() — Create the instance of the PresentationModel.
onBindPresentationModel() — Bind to the PresentationModel properties in this method. Use the bindTo extension and RxBinding for this.

Also the library has a predefined classes for work with Google Maps.

Two-way Databinding

For the cases of two-way databinding (eg. input field text changes) the library has predefined Сontrols.

In PresentationModel:

val name = inputControl(
    formatter = {
        it.take(50).capitalize().replace("[^a-zA-Z- ]".toRegex(), "")
    }
)

val isChecked = checkControl()