Clean architecture and white label

Building white label apps can be a daunting task, especially because requirements and design will most likely change from client to client. At ebankit we address this challenge by taking yet another approach to the good old clean architecture.
This talk dived into the concepts of Clean Architecture applied to Android with a modular and semi-functional approach by leveraging the features of the Kotlin language and Kotlin co-routines.

Transcript

1. Clean architecture and white label A case study João Reis, Senior Android Developer @ ebankIT GDG DEVFEST PORTO, JAN 2019
2. A little context 2
3. A little context 3
4. The challenge • White label banking application • Requirements and design change from client to client • Most of the business logic is common to all clients and should be reused when possible • Should be able to accommodate custom services and business logic • New features are added regularly 4
5. The solution • Modular • Adding new features or customizing existent ones should be easy and quick • Common business logic should be isolated • Flexible • Testable 5
6. The solution • Modular • Adding new features or customizing existent ones should be easy and quick • Common business logic should be isolated • Testable • Flexible 6 A good fit for clean architecture principles.
7. Clean architecture 7 (Obligatory Uncle Bob diagram)
8. Clean architecture 8 Presentation Domain Boundaries Use case interactors Data
9. Clean architecture 9 Presentation Domain Boundaries Use case interactors Data Model-View-Whatever
10. Clean architecture 10 Presentation Domain Boundaries Use case interactors Data Entities Interfaces
11. Clean architecture 11 Presentation Domain Boundaries Use case interactors Data Web APIs Local storage Android Framework
12. Clean architecture 12 Presentation Domain Boundaries Use case interactors Data Dependency rule
13. Yet another way to look at it 13 Presentation layer Abstraction Abstraction Abstraction Use case interactor Data models Business logic Data Web API Android Framework DB Cache
14. Data
15. 15 Data Source Web API Android Framework DB Cache
16. 16 Data Source Web API Android Framework DB Cache
17. 17 Data Source Web API Android Framework DB Cache
18. 18 Data Source Web API Android Framework DB Cache interface Callback { fun onError(val error: Error) fun onSuccess(val data: DataObject) }
20. 20 Data Source Web API Android Framework DB Cache sealed class Result<out S, out E> { data class Success<S>(val data: S) : Result<S, Nothing>() data class Error<E>(val error: E) : Result<Nothing, E>() }
21. 21 Use case interactor Data source Data source DataResponse DataResponse UseCaseResult sealed class DataResponse<out T> { data class Success<T>(val data: T) : DataResponse <T>() data class Error(val error: ErrorObj) : DataResponse <Nothing>() } sealed class UseCaseResult<out T> { data class Success<T>(val data: T) : UseCaseResult<T>() data class Error(val error: ErrorObj) : UseCaseResult<Nothing>() }
22. Concurrency
23. Concurrency • Async Tasks • Threads • Event Bus • RxJava 23
24. Coroutines 24
25. Coroutines 25
26. Coroutines • ”Lightweight threads” 26
27. Coroutines • ”Lightweight threads” • Kotlin feature 27
28. 28 Coroutines • ”Lightweight threads” • Kotlin feature • Structured concurrency
29. Coroutines • ”Lightweight threads” • Kotlin feature • Structured concurrency • Write asynchronous code in a sequential manner 29
30. Suspending functions • Functions that can be paused and resumed • Continuation Passing Style 30 fun doSomething(item: Item) { CoroutineScope(Dispatchers.Default).launch { val result = longRunningIOCall(item) val processedResult = longRunningComputation(result) withContext(Dispatchers.Main) { showResult(processedResult) } } } suspend fun longRunningNetworkCall(input: Item) : SomeType {...} suspend fun longRunningComputation(input: SomeType) : SomeOtherType {...}
31. Suspending functions • Functions that can be paused and resumed • Continuation Passing Style 31 public interface Continuation<in T> { public val context: CoroutineContext public fun resumeWith(result: Result<T>) } fun longRunningNetworkCall(input: Item, callback: Continuation<SomeType>): SomeType {...} fun doSomething(item: Item) { CoroutineScope(Dispatchers.Default).launch { val result = longRunningIOCall(item) val processedResult = longRunningComputation(result) withContext(Dispatchers.Main) { showResult(processedResult) } } } suspend fun longRunningNetworkCall(input: Item) : SomeType {...} suspend fun longRunningComputation(input: SomeType) : SomeOtherType {...}
32. Coroutine builders 32 fun doSomething(item: Item) { CoroutineScope(Dispatchers.Default).launch { val result = longRunningIOCall(item) val processedResult = longRunningComputation(result) withContext(Dispatchers.Main) { showResult(processedResult) } } } suspend fun longRunningNetworkCall(input: Item) : SomeType {...} suspend fun longRunningComputation(input: SomeType) : SomeOtherType {...} launch {} async {} runBlocking {} Returns Job object Returns Deferred object Blocks the current thread until the execution of the coroutine
33. Dispatchers 33 • Dispatchers.Default • Dispatchers.IO • Dispatchers.Main fun doSomething(item: Item) { CoroutineScope(Dispatchers.Default).launch { val result = longRunningIOCall(item) val processedResult = longRunningComputation(result) withContext(Dispatchers.Main) { showResult(processedResult) } } } suspend fun longRunningNetworkCall(input: Item) : SomeType {...} suspend fun longRunningComputation(input: SomeType) : SomeOtherType {...}
34. Structured Concurrency • Scopes have a parent-child relationship • Parent scope cancellation cancels children 34 fun doStuffInParallel() { val parentJob = CoroutineScope(Dispatchers.Default).launch { val someData = async { foo() } val someOtherData = async { bar() } whatever(someData.await(), someOtherData.await()) } }
35. 35 open class BaseViewModel : ViewModel(), CoroutineScope { override val coroutineContext: CoroutineContext get() = Dispatchers.Default + Job() protected inline fun doOnBackground(crossinline block: suspend () -> Unit) { launch { block() } } override fun onCleared() { super.onCleared() coroutineContext.cancel() } }
36. The interactor
37. The interactor 37 abstract class UseCaseInteractor<I, O> { protected abstract suspend fun validateInput(input: I): Boolean protected abstract suspend fun run(input: I): UseCaseResult<O> suspend operator fun invoke(input: I) = validateInput(input).let { if (it) { run(input) } else { UseCaseResult.Error(ErrorFactory.invalidInputError()) } } } I Validate Input Execute logic Is Valid ? UseCaseInteractor<I, O> Y N UseCaseResult.Error UseCaseResult<O> UseCaseResult<O>
38. Data sources 38 Remote data Local data Implements CustomerServiceImpl <<CustomerService>> EbankitService Extends Implements UserDataStoreImpl <<UserDataStore>>
39. Ebankit service 39 open class EbankitService<S>(private val retrofit: Retrofit, private val coreConfig: CoreConfigurations, private val httpClient: OkHttpClient, private val appContext: Context, serviceClass: Class<S>) val apiImplementation: S = retrofit.create(serviceClass) suspend inline fun <R, T : ResponseObject<R>> executeRequest(useCache: Boolean = false, extraHeaders: HashMap<String, String> = HashMap(), crossinline method: S.(HashMap<String, String>) -> Deferred<Response<T>>): DataResponse<T> = withContext(Dispatchers.IO) { extraHeaders.combineHeaders(useCache) apiImplementation.method(extraHeaders).awaitAndMap() } suspend fun <R, T : ResponseObject<R>> Deferred<Response<T>>.awaitAndMap(): DataResponse<T> { return try { return this.await().mapData() } catch (e: Exception) { DataResponse.Error(ErrorFactory.genericServiceError()) } }
40. Ebankit service 40 interface CustomerAPI { @POST(Endpoints.ServiceProducts) fun getProducts(@HeaderMap headerMap: Map<String, String>, @Body requestCustomerProducts: RequestCustomerProducts): Deferred<Response<ResponseCustomerProducts>> } class CustomerServiceImpl(retrofit: Retrofit, coreConfig: CoreConfigurations, httpClient: OkHttpClient, appContext: Context) : EbankitService<CustomerAPI>(retrofit, coreConfig, httpClient, appContext, CustomerAPI::class.java), CustomerService { override suspend fun getProductsList(productTypes: ArrayList<Int>, extendedProperties: List<ExtendedPropertie>, extraHeaders: HashMap<String, String>, useCache: Boolean): DataResponse<ResponseCustomerProducts> { val requestCustomerProducts = RequestCustomerProducts(extendedProperties, productTypes) return executeRequest(useCache, extraHeaders) { getProducts(it, requestCustomerProducts) } } }
41. List all the products the current user owns 41 • Fetch customer products from API • Fetch user data from local storage • Filter the products • Display the results
42. 42 Presentation Domain Data Access Web API DB ProductListViewModel CustomerServiceImpl <<CustomerService>> UserDataStoreImpl <<UserDataStore>> GetProducts ProductListView
43. The interactor 43 class GetProducts(val customerService: CustomerService, val userDataStore : UserDataStore) : UseCaseInteractor<ProductsInput, List<CustomerProduct>>() { override suspend fun run(input: ProductsInput): UseCaseResult<List<CustomerProduct>> { val productsResult = customerService.getProductsList(input.productsTypes, input.extendedProperties, useCache = true) return when(productsResult) { is DataResponse.Success -> { val loginAccounts = userDataStore.getLoginAccounts() when(loginAccounts) { is DataResponse.Success -> UseCaseResult.Success(filterProducts(productsResult.data, input, loginAccounts.data)) is DataResponse.Error -> UseCaseResult.Error(loginAccounts.error) } } is DataResponse.Error -> UseCaseResult.Error(productsResult.error) } } }
44. The View Model 44 class ProductsListViewModel(val getProducts: GetProducts) : BaseViewModel() { val productListViewState = MutableLiveData<ProductsViewState>() fun loadAllProducts() { doOnBackground { productListViewState.postValue(ProductsViewState.Loading) val productsInput = ProductsInput(...) val result = getProducts(productsInput) .map { when (it) { is UseCaseResult.Success -> ProductsViewState.Success(it.data) is UseCaseResult.Error -> ProductsViewState.Error(it.error) } } productListViewState.postValue(result) } } } sealed class ProductsViewState { object Loading : ProductsViewState() class Error(val error: ErrorObj) : ProductsViewState() class Success(val productList: List<CustomerProduct>) : ProductsViewState() }
45. The view viewModel.productListViewState.nonNullObserve(this) { when (it) { is ProductListViewState.Loading -> showLoading() is ProductListViewState.Error -> showError(it.error) is ProductListViewState.Success -> showData(it.productList) } }
46. 46 class GetProducts(val customerService: CustomerService, val userDataStore : UserDataStore) : UseCaseInteractor<ProductsInput, List<CustomerProduct>>() { override suspend fun validateInput(input: ProductsInput): Boolean { return true } override suspend fun run(input: ProductsInput): UseCaseResult<List<CustomerProduct>> { val productsResult = customerService.getProductsList(input.productsTypes, input.extendedProperties, useCache = true) return when(productsResult) { is DataResponse.Success -> { val loginAccounts = userDataStore.getLoginAccounts() when(loginAccounts) { is DataResponse.Success -> UseCaseResult.Success(filterProducts(productsResult.data, input, loginAccounts.data)) is DataResponse.Error -> UseCaseResult.Error(loginAccounts.error) } } is DataResponse.Error -> UseCaseResult.Error(productsResult.error) } } } This kinda sucks :/
47. 47 inline fun <R, T> DataResponse<T>.then(block: (T) -> UseCaseResult<R>): UseCaseResult<R> { return when(this) { is DataResponse.Success -> block(this.data) is DataResponse.Error -> UseCaseResult.Error(this.error) } } We can get a bit more functional
48. 48 inline fun <R, T> DataResponse<T>.then(block: (T) -> UseCaseResult<R>): UseCaseResult<R> { return when(this) { is DataResponse.Success -> block(this.data) is DataResponse.Error -> UseCaseResult.Error(this.error) } } return customerService.getProductsList(input.productsTypes, input.extendedProperties, useCache = true) .then { products -> userDataStore.getLoginAccounts().then { UseCaseResult.Success(filterProducts(products, input, it)) } } We can get a bit more functional
49. 49 We can get a bit more functional doOnBackground { val result = interactorA(inputA).then { interactorB(inputB) } } inline fun <T, R> UseCaseResult<T>.then(block: (UseCaseResult.Success<T>) -> UseCaseResult<R>): UseCaseResult<R> { return when(this) { is UseCaseResult.Error -> this is UseCaseResult.Success -> block(this) } }
50. Conclusion 50
51. Resources • http://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html • https://kotlinlang.org/docs/reference/coroutines-overview.html • https://www.slideshare.net/elizarov/introduction-to-kotlin-coroutines • https://github.com/JakeWharton/retrofit2-kotlin-coroutines-adapter 51
52. Questions?
53. Thank you info@ebankit.com | www.ebankit.com +44 20 32 87 65 92 +351 22 203 20 10 Level39, One Canada Square, Canary Wharf E14 5AB, London - United Kingdom Rua José Falcão 133 4050-317, Porto – Portugal