Effective Reactive Architecture

Transcript

Benoît Quenaudon @oldergod Effective Reactive Architecture

None

Side-Effects Isolation

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { } }

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { nameSubject .switchMap { name -> appService.profile() .map { profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) } }

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { nameSubject .switchMap { name -> appService.profile() .map { profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) } }

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { nameSubject .switchMap { name -> appService.profile() .map { profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) appService.profile().subscribe(this::populateProfile) } }

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { nameSubject .switchMap { name -> appService.profile() .map { profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) appService.profile().subscribe(this::populateProfile) } fun populateProfile(profile: Profile) { nameSubject.onNext(profile.name) // rendering other stuff } }

class ProfileView { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() fun onStart() { nameSubject .switchMap { name -> appService.profile() .map { profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) appService.profile().subscribe(this::populateProfile) } fun populateProfile(profile: Profile) { nameSubject.onNext(profile.name) // rendering other stuff } fun onSetNameDialogResult(newName: String) = setName(newName) }

fun onStart() { nameSubject .switchMap { name -> appService.profile() .map

{ profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) appService.profile().subscribe(this::populateProfile) } fun populateProfile(profile: Profile) { nameSubject.onNext(profile.name) // rendering other stuff } fun onSetNameDialogResult(newName: String) = setName(newName) fun setName(newName: String) { nameSubject.onNext(newName) } }

fun onStart() { nameSubject .switchMap { name -> appService.profile() .map

{ profile -> profile.prefix } .map { profile -> if (name.isEmpty()) "" else "$prefix $name" } } .subscribe(nameView::setText) // hint grows the view in width so hide it if unnecessary nameSubject .map { name -> if (name.isEmpty()) "Set your name" else "" } .subscribe(nameView::setHint) appService.profile().subscribe(this::populateProfile) } fun populateProfile(profile: Profile) { nameSubject.onNext(profile.name) // rendering other stuff } fun onSetNameDialogResult(newName: String) = setName(newName) fun setName(newName: String) { nameSubject.onNext(newName) appService.setName(newName) .subscribe { response -> when { response.isValid -> nameSubject.onNext(response.name) response.isInvalid -> navigator.goTo(response.error) } } }

fun onStart() { nameSubject .switchMap { name -> appService.profile() .map

None

How about Side Effects?

fun onStart() { nameSubject .switchMap { name -> appService.profile() .map

class ProfileView { val navigator: Navigator val nameView: TextView val

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

sealed class Event { data class EditName(val newName: String) :

Event() }

sealed class Result { data class ProfileResult(val profile: Profile) :

Result() data class NameValid(val name: String) : Result() object NameInvalid : Result() }

data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName )

{ data class PrefixedName( val prefix: String, val name: String ) { fun compute(name:String): String = if (name.isEmpty()) "" else "$prefix $name" } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> .subscribe { viewModel -> } } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> } ) } .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } } ) } .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } }

class ProfileViewRemix { val navigator: Navigator val nameView: TextView val

appService: AppService val nameSubject = BehaviorSubject.create<String>() val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

val nameView: TextView val appService: AppService val nameSubject = BehaviorSubject.create<String>()

val events = PublishSubject.create<Event>() fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> }) .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

val nameView: TextView val appService: AppService val nameSubject = BehaviorSubject.create<String>()

fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap

{ event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous } }) .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } }

fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap

{ event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff }

fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap

{ event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) .subscribe { viewModel -> nameView.hint = if (viewModel.prefixedName.name.isEmpty()) "Set your name" else "" nameView.text = viewModel.prefixedName.compute() // rendering other stuff } } fun onSetNameDialogResult(newName: String) { events.onNext(EditName(newName)) }

fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap

None

One Stream Let's organize it

fun onStart() { events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap

events // Observable<Event> .subscribe { viewModel -> }

events // Observable<Event>  .subscribe { viewModel ->

}

None

Passing events to the Presenter

Option A Passing events to the Presenter

events .subscribe { viewModel -> } class ProfilePresenter : Consumer<Event>

{ } View Presenter

events .subscribe { viewModel -> } class ProfilePresenter : Consumer<Event>

{ override fun accept(event: Event) { } } View Presenter

events.subscribe(presenter) presenter.something().subscribe { viewModel -> } class ProfilePresenter : Consumer<Event>

{ override fun accept(event: Event) { } } View Presenter

class ProfilePresenter : Consumer<Event> { override fun accept(event: Event) {

event.flatMap {} } } View Presenter events.subscribe(presenter) presenter.something().subscribe { viewModel -> }

Option B Passing events to the Presenter

events. .subscribe { viewModel -> } class ProfilePresenter(val events:Observable<Event>) {

} View Presenter

events. .subscribe { viewModel -> } class ProfilePresenter(val events:Observable<Event>) {

init { events.publish { events -> } } } View Presenter

presenter(events) .subscribe { viewModel -> } class ProfilePresenter(val events:Observable<Event>) {

init { events.publish { events -> } } } View Presenter

Option C Passing events to the Presenter

presenter.viewModels(events) .subscribe { viewModel -> } class ProfilePresenter { fun

viewModels(events: Observable<Event>) { events.publish { events -> } } } View Presenter

None

Passing view models to the View

Option A Passing view models to the View

presenter.viewmodels() .subscribe { viewModel -> } class ProfilePresenter { fun

viewmodels(): Observable<ViewModel> { } } View Presenter

Option B Passing view models to the View

presenter .subscribe { viewModel -> } class ProfilePresenter: Observable<ViewModel>() {

override fun subscribeActual(observer: Observer<in ViewModel>) { } } View Presenter

Option C Passing view models to the View

presenter .subscribe() class ProfilePresenter: ObservableSource<ViewModel> { override fun subscribe(observer: Observer<in

ViewModel>) { } } View Presenter

presenter .subscribe(object : Observer<ViewModel> { override fun onComplete() {} override

fun onSubscribe(d: Disposable) {} override fun onNext(t: ViewModel) {} override fun onError(e: Throwable) {} }) class ProfilePresenter: ObservableSource<ViewModel> { override fun subscribe(observer: Observer<in ViewModel>) { } } View Presenter

Observable.wrap(presenter) .subscribe { viewModel -> } class ProfilePresenter: ObservableSource<ViewModel> {

override fun subscribe(observer: Observer<in ViewModel>) { } } View Presenter

None

Writing is good. Thinking is better.

fun presenter()

fun presenter(events: Observable<Event>)

fun presenter(events: Observable<Event>): Observable<ViewModel>

interface ObservableTransformer<Upstream, Downstream> { /** * Applies a function to

the upstream Observable and returns an ObservableSource with * optionally different element type. */ fun apply(upstream: Observable<Upstream>): ObservableSource<Downstream> }

interface ObservableTransformer<Upstream, Downstream> { fun apply(upstream: Observable<Upstream>): ObservableSource<Downstream> }

interface ObservableTransformer<Event, Downstream> { fun apply(events: Observable<Event>): ObservableSource<Downstream> }

interface ObservableTransformer<Event, ViewModel> { fun apply(events: Observable<Event>): ObservableSource<ViewModel> }

class Presenter: ObservableTransformer<Event, ViewModel> { fun apply(events: Observable<Event>): ObservableSource<ViewModel> }

events .compose(presenter) .subscribe { viewModel -> } View Presenter

class Presenter: ObservableTransformer<Event, ViewModel> { fun apply(events: Observable<Event>): ObservableSource<ViewModel> }

val testObserver = events // PublishSubject<Event> .compose(presenter) .test() // TestObserver<ViewModel> Test Presenter

class Presenter: ObservableTransformer<Event, ViewModel> { fun apply(events: Observable<Event>): ObservableSource<ViewModel> }

val testObserver = events // PublishSubject<Event> .compose(presenter) .test() // TestObserver<ViewModel> events.onNext(EditName("Georges")) testObserver.assertValue(ViewModel()) Test Presenter

Presenter • Don't break the stream • Don't start work

until observed • Doesn't handle disposables* • Has one entry point • Has one exit point

None

Thinking is good. Config Changes is better.

class ProfilePresenter { } View Presenter

class ProfilePresenter { val events = PublishSubject.create<Event>() fun passEvents(events: Observable<Event>)

{ events.subscribe(this.events) } } View Presenter

class ProfilePresenter { val events = PublishSubject.create<Event>() fun passEvents(events: Observable<Event>)

{ events.subscribe(this.events) } fun viewModels() { return events.businessLogic() } } View Presenter

class ProfilePresenter { val events = PublishSubject.create<Event>() fun passEvents(events: Observable<Event>)

{ events.subscribe(this.events) } private val vmObservable : Observable<MatchesViewState> by lazy(NONE) { events.businessLogic() .replay(1) .autoConnect(0) } fun viewModels() = vmObservable } View Presenter

presenter.viewModels() .subscribe { viewModel -> } View Presenter class ProfilePresenter

{ val events = PublishSubject.create<Event>() fun passEvents(events: Observable<Event>) { events.subscribe(this.events) } private val vmObservable : Observable<MatchesViewState> by lazy(NONE) { events.businessLogic() .replay(1) .autoConnect(0) } fun viewModels() = vmObservable }

presenter.viewModels() .subscribe { viewModel -> } presenter.passEvents(events) View Presenter class

ProfilePresenter { val events = PublishSubject.create<Event>() fun passEvents(events: Observable<Event>) { events.subscribe(this.events) } private val vmObservable : Observable<MatchesViewState> by lazy(NONE) { events.businessLogic() .replay(1) .autoConnect(0) } fun viewModels() = vmObservable }

None

Unidirectional Data Flow

VIEW PRESENTER

VIEW PRESENTER (BUSINESS LOGIC) READING WRITING

VIEW PRESENTER (BUSINESS LOGIC) VIEW (READING) VIEW (WRITING)

VIEW (READING) VIEW (WRITING) PRESENTER (BUSINESS LOGIC)

None

New Feature? No Problem.

sealed class Event { data class EditName(val newName: String) :

Event() } data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName ) class ProfileViewRemix { fun onStart() { events .compose(presenter) .subscribe { viewModel -> // rendering view model } } }

sealed class Event { data class EditName(val newName: String) :

Event() } data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName ) class ProfileViewRemix { fun onStart() { events .compose(presenter) .subscribe { viewModel -> // rendering view model } } }

sealed class Event { data class EditName(val newName: String) :

Event() data class ChangeAvatar(val picture: File) : Event() } data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName ) class ProfileViewRemix { fun onStart() { events .compose(presenter) .subscribe { viewModel -> // rendering view model } } }

sealed class Event { data class EditName(val newName: String) :

Event() data class ChangeAvatar(val picture: File) : Event() } data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName, val avatarUri: Uri ) class ProfileViewRemix { fun onStart() { events .compose(presenter) .subscribe { viewModel -> // rendering view model } } }

sealed class Event { data class EditName(val newName: String) :

Event() data class ChangeAvatar(val picture: File) : Event() } data class ViewModel( val stuff: Any?, val prefixedName: PrefixedName, val avatarUri: Uri ) class ProfileViewRemix { fun onStart() { events .compose(presenter) .subscribe { viewModel -> // rendering view model Picasso.get().load(viewModel.avatarUri).into(avatarView) } } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>() .switchMap { event -> appService.setName(event.newName).map { response -> when { response.isValid -> NameValid(response.name) response.isInvalid -> NameInvalid.also { navigator.goTo(response) } } } .startWith(NameValid(event.newName)) } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>().logic() ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>().logic() events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>().logic() events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } .onErrorReturn { throwable -> AvatarInvalid(throwable) } } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) } }) } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>().logic() events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } .onErrorReturn { throwable -> AvatarInvalid(throwable) } } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) is AvatarValid -> previous.copy(avatarUri = result.uri) } }) } }

class ProfilePresenter : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>):

ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<EditName>().logic() events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } .onErrorReturn { throwable -> AvatarInvalid(throwable) } } ) } .mergeWith(appService.profile().map(::ProfileResult)) .scan(ViewModel(stuff = null, prefixedName = PrefixedName("", "")), BiFunction { previous: ViewModel, result: Result -> when (result) { is NameValid -> previous.copy(prefixedName = previous.prefixedName.copy(name = result.name)) is NameInvalid -> previous is ProfileResult -> previous.copy( stuff = result.profile, prefixedName = PrefixedName(result.profile.prefix, result.profile.name) ) is AvatarValid -> previous.copy(avatarUri = result.uri) is AvatarInvalid -> TODO() } }) } }

None

Architecture forced us to separate concerns

Architecture forced us to separate concerns No need to touch

existing code

Architecture forced us to separate concerns No need to touch

existing code Easy to test

Architecture forced us to separate concerns No need to touch

existing code Easy to test Easy to review

None

Extension Function ?

events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response ->

AvatarValid(response.uri) } }

events.filterIsInstance<ChangeAvatar>().changeAvatar() private fun Observable<ChangeAvatar>.changeAvatar(): Observable<Result> { return switchMap { event

-> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } } } events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } }

events.filterIsInstance<ChangeAvatar>().changeAvatar() private fun Observable<ChangeAvatar>.changeAvatar(): Observable<Result> { return switchMap { event

-> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } } } events.filterIsInstance<ChangeAvatar>() .switchMap { event -> appService.changeAvatar(event.picture) .map { response -> AvatarValid(response.uri) } }

None

Navigation

interface Navigator { fun goTo(screen: Any) }

interface Navigator { fun goTo(screen: Any) } interface Launcher {

fun shareText(text: String): Boolean fun launchUrl(url: String): Boolean fun launchApp(packageName: String): Boolean }

interface Navigator { fun goTo(screen: Any) }

interface Navigator { fun goTo(screen: Any) } class ProfilePresenter( private

val navigator: Navigator ) : ObservableTransformer<Event, ViewModel> { }

interface Navigator { fun goTo(screen: Any) } class ProfilePresenter( private

val navigator: Navigator ) : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>): ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<GoToEvent>().goTo() ) } } }

interface Navigator { fun goTo(screen: Any) } class ProfilePresenter( private

val navigator: Navigator ) : ObservableTransformer<Event, ViewModel> { override fun apply(events: Observable<Event>): ObservableSource<ViewModel> { return events.publish { events -> Observable.merge( events.filterIsInstance<GoToEvent>().goTo() ) } } private fun Observable<GoToEvent>.goTo(): Observable<ViewModel> { return doOnNext { navigator.goTo(SomeScreen) } .ignoreElements() .toObservable() } }

Effective Reactive Architecture

Effective Reactive Architecture

More Decks by Benoît Quenaudon

Other Decks in Programming

Featured

Transcript