Bye bye RxJava Building flexible SDKs with Kotlin and Coroutines 

Our journey with reactive streams 

Step 1 - MVP UI Network stream Presenter commands actions 

Step 2 - clean architecture UI Network stream Presenter commands actions Repository Use case stream stream 

Step 3 - SDKs UI Network callbacks Presenter commands actions Repository Use case stream stream SDK 

SDK Step 4 - fully reactive (experiment*) UI Network request
 stream MVI state stream action stream Repository Use case response
 stream stream response
 stream request
 stream 

It worked nicely… 

… on a small scale 

No content

SDK design issues 

Streaming is overused 

It started with the network 

Network ops interface MessageService { @GET(“messages") fun getMessages(): Observable> } 

Network ops interface MessageService { @GET(“messages") fun getMessages(): Observable> } 

Network ops interface MessageService { @GET(“messages") fun getMessages(): Single> } 

HTTP network calls are not streams 

Rx mostly provided easy background networking 

Rx and Callback APIs 

Callback APIs data class GetPatientRequest(val patientId: String) interface GetPatientOutput { fun onGetPatientSuccess(patient: Patient) } interface BabylonUserApi { fun getPatient( request: GetPatientRequest, output: GetPatientOutput ): Disposable } 

Rx APIs @Experimental interface BabylonRxUserApi { fun getPatient(): ObservableTransformer } 

Rx APIs // From RxJava sources public interface ObservableTransformer { ObservableSource apply(Observable upstream); } 

Rx APIs @Experimental interface BabylonRxUserApi { fun getPatient(): ObservableTransformer } 

Rx APIs sealed class GetPatientStatus { data class Ready(val patient: Patient) : GetPatientStatus() object Loading : GetPatientStatus() data class Error(val throwable: Throwable) : GetPatientStatus() } 

Rx APIs internal class GetPatientUseCase ( ... ) : ObservableTransformer() { override fun apply( upstream: Observable ): Observable = upstream.switchMap { patientRepository.getPatient(it.patientId) .map { patient -> GetPatientStatus.Ready(patient) } .onErrorReturn { throwable -> GetPatientStatus.Error(throwable) } .startWith(GetPatientStatus.Loading) } } 

Rx APIs upstream.switchMap { patientRepository.getPatient(it.patientId) .map { patient -> GetPatientStatus.Ready(patient) } .onErrorReturn { throwable -> GetPatientStatus.Error(throwable) } .startWith(GetPatientStatus.Loading) } 

Rx APIs upstream.switchMap { patientRepository.getPatient(it.patientId) .map { patient -> GetPatientStatus.Ready(patient) } .onErrorReturn { throwable -> GetPatientStatus.Error(throwable) } .startWith(GetPatientStatus.Loading) } 

Rx APIs upstream.switchMap { patientRepository.getPatient(it.patientId) .map { patient -> GetPatientStatus.Ready(patient) } .onErrorReturn { throwable -> GetPatientStatus.Error(throwable) } .startWith(GetPatientStatus.Loading) } 

Overengineering 

class GetImportantMessagesUseCase @Inject constructor( private val loadSessionConfigurationUseCase: LoadSessionConfigurationUseCase, private val getAppointmentsUseCase: GetAppointmentsUseCase, private val getLoggedInPatientUseCase: GetLoggedInPatientUseCase, private val getNotificationsUseCase: GetNotificationsUseCase, private val isHealthCheckCompletedUseCase: IsHealthCheckCompletedUseCase, private val systemUtil: SystemUtil ) : AuthenticatedUseCase() { override fun applyUseCase(upstream: Observable): Observable { return upstream.switchMap { Observable.just(GetLoggedInPatientRequest()) .compose(getLoggedInPatientUseCase) .toReadyData() .toObservable() .switchMap { patient -> Observable.combineLatest( Observable.just(LoadSessionConfigurationRequest()) .compose(loadSessionConfigurationUseCase), Observable.just(GetAppointmentsRequest(patient.id !!)) .compose(getAppointmentsUseCase), Observable.just(GetNotificationsRequest) .compose(getNotificationsUseCase), Observable.just(IsHealthCheckCompletedRequest) .compose(isHealthCheckCompletedUseCase), Function4 { sessionConfigurationStatus, getAppointmentsStatus, getNotificationsStatus, isHealthCheckCompletedStatus -> when { getAppointmentsStatus is GetAppointmentsStatus.Error -> GetImportantMessagesStatus.Error(getAppointmentsStatus.throwable) sessionConfigurationStatus is LoadSessionConfigurationStatus.Error -> GetImportantMessagesStatus.Error(sessionConfigurationStatus.throwable) getNotificationsStatus is GetNotificationsStatus.Error -> GetImportantMessagesStatus.Error(getNotificationsStatus.throwable) isHealthCheckCompletedStatus is IsHealthCheckCompletedStatus.Error -> 

Complexity bubbles upwards 

Reactive stream reuse is a double edged sword 

“Bad” consistency 

Not enough due diligence 

value < cost 

Reactive streams are powerful and not to be used lightly! 

No content

No content

Lessons learned 

Look before you leap 

Understand both the value and its cost 

Monitor & iterate 

Problems snowball with time 

Keep It Simple Stupid 

Our latest SDK architecture 

Guiding principles 

KISS 

Design for the majority of problems - not the minority 

Reserve streams for true streams to avoid ambiguity 

Be consistent thoughtfully 

Design 

SDK Before - Fully reactive SDK UI Network request
 stream MVI state stream action stream Repository Use case response
 stream stream response
 stream request
 stream 

SDK After - V2 SDK architecture UI Network Call MVI State stream action stream Repository Use case 

Lower layers as simple as possible 

Coroutines 

Lower layers as simple as possible internal interface PaymentCardsService { @GET(PAYMENT_CARD_ENDPOINT) suspend fun getPaymentCards(): List } Retrofit 2.6.0+ 

Lower layers as simple as possible internal interface PaymentCardsRepository { suspend fun getPaymentCards(): List } 

Lower layers as simple as possible class NetworkPaymentCardsRepository( private val paymentCardsService: PaymentCardsService ) : PaymentCardsRepository { override suspend fun getPaymentCards(): List = paymentCardsService.getPaymentCards() .map { it.toDomainEntity() } } 

Topmost layer takes care of high-level decisions 

interface PaymentV2Api { fun getPaymentCards(): Call> } 

interface PaymentV2Api { fun getPaymentCards(): Call> } 

interface Call { fun execute(): T fun enqueue(callback: Callback) fun cancel() } interface Callback { fun onResult(data: T) fun onException(throwable: Throwable) } 

class PaymentV2ApiImpl( private val paymentCardsRepository: PaymentCardsRepository ) : PaymentV2Api { override fun getPaymentCards() = wrapCall { paymentCardsRepository.getPaymentCards() } } 

class PaymentV2ApiImpl( private val paymentCardsRepository: PaymentCardsRepository ) : PaymentV2Api { override fun getPaymentCards() = wrapCall { paymentCardsRepository.getPaymentCards() } } 

Before class GetPrescriptionsUseCase ( private val prescriptionsRepository: PrescriptionsRepository, private val userAccountsRepository: UserAccountsRepository ) : AuthenticatedUseCase() { override fun applyUseCase(upstream: Observable): Observable { return upstream.switchMap { request -> getPrescriptions(request) .toObservable() .map { GetPrescriptionsStatus.Ready(request.location, it) } .startWith(GetPrescriptionsStatus.Loading) .onErrorReturn { GetPrescriptionsStatus.Error(it) } } } private fun getPrescriptions(request: GetPrescriptionsRequest): Single> { return userAccountsRepository.getLoggedInUser() .flatMapObservable { prescriptionsRepository.getPrescriptions(it) } } } 

After class GetPrescriptionsUseCase ( private val prescriptionsRepository: PrescriptionsRepository, private val userAccountsRepository: UserAccountsRepository ) { suspend operator fun invoke(): List { val userAccount = userAccountsRepository.getLoggedInUser() return prescriptionsRepository.getPrescriptions(userAccount) } } 

Extensions provide flexibility 

suspend fun Call.asSuspend(): T { ... // Coroutine directly returning the result } fun Call.asSingle(): Single { ... // Rx single emitting the result } fun Call.asStatusObservable(): Observable> { ... // Rx stream with updates on the status of the execution } 

Hiding implementation details 

Notes on rx and coroutine compatibility 

fun getSomething(): Single val nonce = getSomething().await() 

suspend fun getSomething(): String rxSingle { getSomething() } 

suspend fun getSomething(): String rxSingle(Dispatchers.Unconfined) { getSomething() } 

Execution 

Prototyping 

Testing the behaviour 

Conventions & howtos 

Enforce conventions 

Migration 

–Dalai Lama “Forget the failures. Keep the lessons.” 

Mikolaj Leszczynski @TheAngroid Twitter / Medium Careers: http://tiny.cc/babylon