Blockked, Distilled

Reviewing opinionated architectural decisions applied to Android codebases and products. Presentation given at the following events

- Dextra Special Meetup (Campinas, April 2019)

Transcript

1. Ubiratan Soares April / 2019 Reviewing opinionated architectural decisions applied to Android codebases and products BLOCKKED, DISTILLED
2. https://github.com/ubiratansoares/blockked Blockked A blockchain.info companion (and educational) app for Android
3. DSL❤
4. Extensions Functions Lambda Extensions Operators Overload Extension Properties Infix Notation Trailing Notation ETC Invoking Instances DSL Markers
5. https://github.com/ubiratansoares/burster
6. @Test fun `should handle error when caught from proper networking exception`() { using<Throwable, NetworkingIssue> { burst { values(UnknownHostException("No Internet"), HostUnreachable) values(ConnectException(), HostUnreachable) values(SocketTimeoutException(), OperationTimeout) values(NoRouteToHostException(), HostUnreachable) values(IOException("Canceled"), ConnectionSpike) } thenWith { incoming, expected !" val execution = Observable.error<Any>(incoming) assertHandling(execution, expected) } } }
7. @Test fun `should handle error when caught from proper networking exception`() { using<Throwable, NetworkingIssue> { burst { values(UnknownHostException("No Internet"), HostUnreachable) values(ConnectException(), HostUnreachable) values(SocketTimeoutException(), OperationTimeout) values(NoRouteToHostException(), HostUnreachable) values(IOException("Canceled"), ConnectionSpike) } thenWith { incoming, expected !" val execution = Observable.error<Any>(incoming) assertHandling(execution, expected) } } }
8. https://github.com/ubiratansoares/tite
9. val words = Observable.just("Adenor", "Leonardo", "Bacchi") words.test() .assertComplete() .assertTerminated() .assertNoErrors() .assertValueSequence(listOf("Adenor", "Leonardo", "Bacchi")) #$ %&' more verifications
10. val words = Observable.just("Adenor", "Leonardo", "Bacchi") words.test() .assertComplete() .assertTerminated() .assertNoErrors() .assertValueSequence(listOf("Adenor", "Leonardo", "Bacchi")) #$ %&' more verifications given(words) { assertThatSequence { should be completed should be terminated should notBe broken } verifyForEmissions { items match sequenceOf("Adenor", "Leonardo", "Bacchi") firstItem shouldBe "Adenor" never emmits "Parreira" } }
11. val words = Observable.just("Adenor", "Leonardo", "Bacchi") words.test() .assertComplete() .assertTerminated() .assertNoErrors() .assertValueSequence(listOf("Adenor", "Leonardo", "Bacchi")) #$ %&' more verifications given(words) { assertThatSequence { should be completed should be terminated should notBe broken } verifyForEmissions { items match sequenceOf("Adenor", "Leonardo", "Bacchi") firstItem shouldBe "Adenor" never emmits "Parreira" } }
12. @Test fun `should fetch from local cache, with cache hit`() { `cache has previous data`() val execution = fetcher.execute( SupportedStatistic.AverageMarketPrice, FetchStrategy.FromPrevious ) val mapped = BitcoinInfoMapper(PREVIOUSLY_CACHED) given(execution) { assertThatSequence { should be completed } verifyForEmissions { firstItem shouldBe mapped } } }
13. @Test fun `should fetch from local cache, with cache hit`() { `cache has previous data`() val execution = fetcher.execute( SupportedStatistic.AverageMarketPrice, FetchStrategy.FromPrevious ) val mapped = BitcoinInfoMapper(PREVIOUSLY_CACHED) given(execution) { assertThatSequence { should be completed } verifyForEmissions { firstItem shouldBe mapped } } }
14. https://youtu.be/Qaqr3h8RUn8
16. "Sandwich by Convention?” 1
17. Domain Service(indirection) Concrete Derivative (low level detail) Use case ViewModel UI Delivery (Activity)
18. Domain Service (indirection) Concrete Derivative (low level detail) Use case ViewModel UI Delivery (Activity)
19. Domain Service (indirection) Concrete Derivative (low level detail) ViewModel UI Delivery (Activity)
20. Repository Implementation ViewModel Activity Retrofit Observable<Data> Observable<Data> Observable<Data> Disposable
21. "In the long term duplication is by far cheaper than the wrong abstraction”
22. Concrete Derivative (conforms to Domain Service) ViewModel Activity External World Bridge Observable<D> Observable<V> Observable<P> Disposable D != P (preferred) D != V (eventually)
23. Domain Service ViewModel Activity External World Bridge Observable<D1> Observable<V> Observable<P1> Disposable Domain Service Observable<D2> External World Bridge Observable<P2>
24. Domain Service ViewModel External World Bridge Observable<D1> Observable<V> Observable<P1> Domain Service Observable<D2> External World Bridge Observable<P2> Use-case Observable<D1+D2> Disposable Activity
25. Domain Service ViewModel External World Bridge Observable<D1> Observable<V> Observable<P1> Domain Service Observable<D2> External World Bridge Observable<P2> Use-case Observable<D1+D2> Disposable Activity
26. Data structures (“models") Services (indirections) Combinators (services + formatters + entities) Formatters Standalone Entities (Behaviours) ETC Application Domain
27. "In the application domain, the programming language should be the ultimate level of abstraction”
29. Idealism Idealism Language + frameworks
30. class FetcherStrategist( private val remote: BlockchainInfoService, private val local: CacheService ) : FetchBitcoinStatistic { override fun execute(target: SupportedStatistic, strategy: FetchStrategy) = when (strategy) { is ForceUpdate !" remoteThenCache(target) is FromPrevious !" fromCache(target) } private fun fromCache(target: SupportedStatistic) = local.retrieveOrNull(target) ()let { Observable.just(BitcoinInfoMapper(it)) } *+ Observable.empty() private fun remoteThenCache(statistic: SupportedStatistic) = remote .fetchStatistics(statistic) .doOnNext { local.save(statistic, it) } .map { BitcoinInfoMapper(it) } }
31. class FetcherStrategist( private val remote: BlockchainInfoService, private val local: CacheService ) : FetchBitcoinStatistic { override fun execute(target: SupportedStatistic, strategy: FetchStrategy) = when (strategy) { is ForceUpdate !" remoteThenCache(target) is FromPrevious !" fromCache(target) } private fun fromCache(target: SupportedStatistic) = local.retrieveOrNull(target) ()let { Observable.just(BitcoinInfoMapper(it)) } *+ Observable.empty() private fun remoteThenCache(statistic: SupportedStatistic) = remote .fetchStatistics(statistic) .doOnNext { local.save(statistic, it) } .map { BitcoinInfoMapper(it) } }
32. class FetcherStrategist( private val remote: BlockchainInfoService, private val local: CacheService ) : FetchBitcoinStatistic { override fun execute(target: SupportedStatistic, strategy: FetchStrategy) = when (strategy) { is ForceUpdate !" remoteThenCache(target) is FromPrevious !" fromCache(target) } private fun fromCache(target: SupportedStatistic) = local.retrieveOrNull(target) ()let { Observable.just(BitcoinInfoMapper(it)) } *+ Observable.empty() private fun remoteThenCache(statistic: SupportedStatistic) = remote .fetchStatistics(statistic) .doOnNext { local.save(statistic, it) } .map { BitcoinInfoMapper(it) } }
33. class FetcherStrategist( private val remote: BlockchainInfoService, private val local: CacheService ) : FetchBitcoinStatistic { override fun execute(target: SupportedStatistic, strategy: FetchStrategy) = when (strategy) { is ForceUpdate !" remoteThenCache(target) is FromPrevious !" fromCache(target) } private fun fromCache(target: SupportedStatistic) = local.retrieveOrNull(target) ()let { Observable.just(BitcoinInfoMapper(it)) } *+ Observable.empty() private fun remoteThenCache(statistic: SupportedStatistic) = remote .fetchStatistics(statistic) .doOnNext { local.save(statistic, it) } .map { BitcoinInfoMapper(it) } }
34. A Senior Engineer knows that composition should be preferred over inheritance Therefore, you should EVER avoid inherit from a given use-case base class
35. class RetrieveStatistics(private val fetcher: FetchBitcoinStatistic) { private val cached by lazy { retrieveAll(strategy = FetchStrategy.FromPrevious) } private val updated by lazy { retrieveAll(strategy = FetchStrategy.ForceUpdate) } fun execute() = cached.concatWith(updated) private fun retrieveAll(strategy: FetchStrategy) = Observable .fromIterable(SupportedStatistic.ALL) .flatMap { Observable.just(fetcher.execute(it, strategy)) } .let { Observable.zip(it, Zipper) } private companion object Zipper : Function<Array<Any>, List<BitcoinStatistic,- { override fun apply(raw: Array<Any>) = raw.map { it as BitcoinStatistic } } }
36. class RetrieveStatistics(private val fetcher: FetchBitcoinStatistic) { private val cached by lazy { retrieveAll(strategy = FetchStrategy.FromPrevious) } private val updated by lazy { retrieveAll(strategy = FetchStrategy.ForceUpdate) } fun execute() = cached.concatWith(updated) private fun retrieveAll(strategy: FetchStrategy) = Observable .fromIterable(SupportedStatistic.ALL) .flatMap { Observable.just(fetcher.execute(it, strategy)) } .let { Observable.zip(it, Zipper) } private companion object Zipper : Function<Array<Any>, List<BitcoinStatistic,- { override fun apply(raw: Array<Any>) = raw.map { it as BitcoinStatistic } } }
37. class RetrieveStatistics(private val fetcher: FetchBitcoinStatistic) { private val cached by lazy { retrieveAll(strategy = FetchStrategy.FromPrevious) } private val updated by lazy { retrieveAll(strategy = FetchStrategy.ForceUpdate) } fun execute() = cached.concatWith(updated) private fun retrieveAll(strategy: FetchStrategy) = Observable .fromIterable(SupportedStatistic.ALL) .flatMap { Observable.just(fetcher.execute(it, strategy)) } .let { Observable.zip(it, Zipper) } private companion object Zipper : Function<Array<Any>, List<BitcoinStatistic,- { override fun apply(raw: Array<Any>) = raw.map { it as BitcoinStatistic } } }
38. Rx Transformers : the abstraction everyone should know about 2
39. class SomeBehaviour<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>)= TODO() }
40. class SomeBehaviour<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>)= TODO() } class SomePipeline<T> { override fun someWork(): Observable<T> { return someStream.compose(SomeBehaviour()) } }
41. object HandleErrorByHttpStatus<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): ObservableSource<T> { return upstream.onErrorResumeNext(this./handleIfRestError) } private fun handleIfRestError(incoming: Throwable): Observable<T> = if (incoming is HttpException) toInfrastructureError(incoming) else Observable.error(incoming) private fun toInfrastructureError(restError: HttpException): Observable<T> { val infraError = mapErrorWith(restError.code()) return Observable.error(infraError) } private fun mapErrorWith(code: Int) = when (code) { in 40001499 !" RemoteIntegrationIssue.ClientOrigin else !" RemoteIntegrationIssue.RemoteSystem } }
42. object HandleErrorByHttpStatus<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): ObservableSource<T> { return upstream.onErrorResumeNext(this::handleIfRestError) } private fun handleIfRestError(incoming: Throwable): Observable<T> = if (incoming is HttpException) toInfrastructureError(incoming) else Observable.error(incoming) private fun toInfrastructureError(restError: HttpException): Observable<T> { val infraError = mapErrorWith(restError.code()) return Observable.error(infraError) } private fun mapErrorWith(code: Int) = when (code) { in 400..499 !" RemoteIntegrationIssue.ClientOrigin else !" RemoteIntegrationIssue.RemoteSystem } }
43. object HandleConnectivityIssue<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): ObservableSource<T> = upstream.onErrorResumeNext(this./handleIfNetworkingError) #$ Implementation } object HandleSerializationError<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): Observable<T> { return upstream.onErrorResumeNext(this./handleSerializationError) } #$ Implementation }
44. object HandleConnectivityIssue<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): ObservableSource<T> = upstream.onErrorResumeNext(this::handleIfNetworkingError) #$ Implementation } object HandleSerializationError<T> : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>): Observable<T> { return upstream.onErrorResumeNext(this::handleSerializationError) } #$ Implementation }
45. object ExecutionErrorHandler<T>() : ObservableTransformer<T, T> { override fun apply(upstream: Observable<T>) = upstream .compose(HandleErrorByHttpStatus) .compose(HandleConnectivityIssue) .compose(HandleSerializationError) }
46. internal class BrokerInfrastructure( private val service: BlockchainInfo, private val targetScheduler: Scheduler = Schedulers.trampoline() ) : BlockchainInfoService { override fun fetchStatistics(statistic: SupportedStatistic)= service .fetchWith(statistic.toString(), ARGS) .subscribeOn(targetScheduler) .compose(ExecutionErrorHandler) private companion object { val ARGS = mapOf( "timespan" to "4weeks", "format" to "json" ) } } interface BlockchainInfoService { fun fetchStatistics(statistic : SupportedStatistic) : Observable<BitcoinStatsResponse> }
47. internal class BrokerInfrastructure( private val service: BlockchainInfo, private val targetScheduler: Scheduler = Schedulers.trampoline() ) : BlockchainInfoService { override fun fetchStatistics(statistic: SupportedStatistic)= service .fetchWith(statistic.toString(), ARGS) .subscribeOn(targetScheduler) .compose(ExecutionErrorHandler) private companion object { val ARGS = mapOf( "timespan" to "4weeks", "format" to "json" ) } }
48. internal class BlockchainInfoInfrastructureTests { @get:Rule val rule = InfrastructureRule() lateinit var infrastructure: BrokerInfrastructure @Before fun `before each test`() { infrastructure = BrokerInfrastructure( service = rule.api, ) }
49. rule.defineScenario( status = 200, response = loadFile("200OK-market-price.json") ) @Test fun `should retrieve Bitcoin market price with success`() {
50. val expected = BitcoinStatsResponse( name = "Market Price (USD)", description = "Average USD market value across exchanges.", unit = "USD", values = listOf( StatisticPoint( timestamp = 1540166400, value = 6498f ), StatisticPoint( timestamp = 1540252800, value = 6481f ) ) ) @Test fun `should retrieve Bitcoin market price with success`() {
51. val execution = infrastructure.fetchStatistics(AverageMarketPrice) given(execution) { assertThatSequence { should be completed should emit something } verifyForEmissions { firstItem shouldBe expected } } @Test fun `should retrieve Bitcoin market price with success`() { Tested in a integrated fashion
52. The UI State Machine 3
53. ViewModel Observable<Execution> Disposable AndroidSchedulers Activity class SomeViewModel { fun someExecution() : Observable<Execution> { #$ %&' } } Lifecycle Control Threading Control
55. Launched Result (remote) Done
57. Launched Result (remote) Done Result (local)
59. Launched Failed (remote) Done
61. Launched Failed (remote) Done Result (local)
62. Launched Failed (reason) Done Result (value)
63. sealed class UIEvent<out T> object Launched : UIEvent<Nothing>() data class Failed(val reason: Throwable) : UIEvent<Nothing>() data class Result<out T>(val value: T) : UIEvent<T>() object Done : UIEvent<Nothing>()
64. class StateMachine<T>( private val uiScheduler: Scheduler = Schedulers.trampoline() ) : ObservableTransformer<T, UIEvent<T,- { override fun apply(upstream: Observable<T>): Observable<UIEvent<T,- { val beginning = Launched val end = Observable.just(Done) return upstream .map { value: T !" Result(value) as UIEvent<T> } .onErrorReturn { error: Throwable !" Failed(error) } .startWith(beginning) .concatWith(end) .observeOn(uiScheduler) } }
65. class StateMachine<T>( private val uiScheduler: Scheduler = Schedulers.trampoline() ) : ObservableTransformer<T, UIEvent<T,- { override fun apply(upstream: Observable<T>): Observable<UIEvent<T,- { val beginning = Launched val end = Observable.just(Done) return upstream .map { value: T !" Result(value) as UIEvent<T> } .onErrorReturn { error: Throwable !" Failed(error) } .startWith(beginning) .concatWith(end) .observeOn(uiScheduler) } }
66. class StateMachine<T>( private val uiScheduler: Scheduler = Schedulers.trampoline() ) : ObservableTransformer<T, UIEvent<T,- { override fun apply(upstream: Observable<T>): Observable<UIEvent<T,- { val beginning = Launched val end = Observable.just(Done) return upstream .map { value: T !" Result(value) as UIEvent<T> } .onErrorReturn { error: Throwable !" Failed(error) } .startWith(beginning) .concatWith(end) .observeOn(uiScheduler) } }
67. class StateMachine<T>( private val uiScheduler: Scheduler = Schedulers.trampoline() ) : ObservableTransformer<T, UIEvent<T,- { override fun apply(upstream: Observable<T>): Observable<UIEvent<T>> { val beginning = Launched val end = Observable.just(Done) return upstream .map { value: T !" Result(value) as UIEvent<T> } .onErrorReturn { error: Throwable !" Failed(error) } .startWith(beginning) .concatWith(end) .observeOn(uiScheduler) } }
68. class StateMachine<T>( private val uiScheduler: Scheduler = Schedulers.trampoline() ) : ObservableTransformer<T, UIEvent<T,- { override fun apply(upstream: Observable<T>): Observable<UIEvent<T>> { val beginning = Launched val end = Observable.just(Done) return upstream .map { value: T !" Result(value) as UIEvent<T> } .onErrorReturn { error: Throwable !" Failed(error) } .startWith(beginning) .concatWith(end) .observeOn(uiScheduler) } }
69. class DashboardViewModel( private val machine: StateMachine<List<DashboardPresentation,-, private val usecase: RetrieveStatistics) { fun retrieveDashboard() = usecase .execute() .map { BuildDashboardPresentation(it) } .compose(machine) }
70. class DashboardViewModel( private val machine: StateMachine<List<DashboardPresentation>>, private val usecase: RetrieveStatistics) { fun retrieveDashboard() = usecase .execute() .map { BuildDashboardPresentation(it) } .compose(machine) }
71. class DashboardViewModel( private val machine: StateMachine<List<DashboardPresentation>>, private val usecase: RetrieveStatistics) { fun retrieveDashboard() = usecase .execute() .map { BuildDashboardPresentation(it) } .compose(machine) }
72. class DashboardViewModel( private val machine: StateMachine<List<DashboardPresentation,-, private val usecase: RetrieveStatistics) { fun retrieveDashboard() = usecase .execute() .map { BuildDashboardPresentation(it) } .compose(machine) } Mapping function runs in the Scheduler defined by the upstream (IO or Computation)
73. private fun loadDashboard() = viewModel .retrieveDashboard() .subscribeBy( onNext = { changeState(it) }, onError = { logger.e("Error !" $it") } ) private fun changeState(event: UIEvent<List<DashboardPresentation,-) { when (event) { is Launched !" startExecution() is Result !" presentDashboard(event.value) is Failed !" reportError(event.reason) is Done !" finishExecution() } }
74. private fun loadDashboard() = viewModel .retrieveDashboard() .subscribeBy( onNext = { changeState(it) }, onError = { logger.e("Error !" $it") } ) private fun changeState(event: UIEvent<List<DashboardPresentation,-) { when (event) { is Launched !" startExecution() is Result !" presentDashboard(event.value) is Failed !" reportError(event.reason) is Done !" finishExecution() } } Threading already handled
75. private fun loadDashboard() = viewModel .retrieveDashboard() .subscribeBy( onNext = { changeState(it) }, onError = { logger.e("Error !" $it") } ) private fun changeState(event: UIEvent<List<DashboardPresentation,-) { when (event) { is Launched -> startExecution() is Result -> presentDashboard(event.value) is Failed -> reportError(event.reason) is Done -> finishExecution() } }
76. class DashboardActivity : AppCompatActivity(), KodeinAware { private val disposer by instance<AutoDisposer>() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_dashboard) setupViews() disposer += loadDashboard() } #$ %&' }
78. app module (plus variants) package package package package package package package package package package package package package package package package package package
79. Why multi-module builds ? Better files-per-feature co-location Better isolation of legacy code Better visibility for internal-libs candidates Faster builds with parallel tasks execution Faster builds with more cacheable tasks Dynamic features ready !!! ETC
80. app module (plus variants) Library Library Library Library Library Library Library Library Library Library Feature Feature Feature Feature Feature Feature Feature Feature Feature Feature Feature
81. Life is harder than this …
82. Multi-module design "Should this new module be Kotlin-only or Android-library?” Can we maximize the number of Kotlin-only modules? How do you handle circular dependencies? How do you share assets between feature modules? How do you handle DI between modules? How do you share configuration logic between Gradle files? Does this design scale?
83. Learnings from the battlefield …
84. app module (plus variants) Feature Flow Screen Behavior Feature Domain Models Domain Services Combinators Analytics Navigator Feature Flow Infrastructure Infrastructure Infrastructure Networking Database Dependency Injection Logger Formatters Infrastructure Infra ETC Ktx extensions (aka new utils 2.0) Circular dependency hack Shared mess between related features
85. Eventually, let the composition of your modules to be “inspired” by the design your architectural layers specially when extracting modules from an existing codebase
86. app module (plus variants) Feature Flow Screen Dynamic Feature Domain Models Domain Services Combinators Analytics Navigator Feature Flow Infrastructure Infrastructure Infrastructure Networking Database Dependency Injection Logger Formatters Infrastructure Infra ETC Shared extensions Circular dependency hack Shared utilities between Related Features
87. Instant App Feature Flow Screen Behaviour Feature Domain Models Domain Services Combinators Analytics Navigator Feature Flow Infrastructure Infrastructure Infrastructure Networking Database Dependency Injection Logger Formatters Infrastructure Infra ETC Shared extensions Circular dependency hack Shared utilities between Related Features
88. Going annotation-processors free No to AA libs for each micro-issue No to compiler-generated Moshi adapters No to Dagger2 No to kapt No to Room (?)
89. Going annotation-processors free No to AA libs for each micro-issue No to compiler-generated Moshi adapters No to Dagger2 No to kapt No to Room (?)
90. Build speed + multi-module projects Kotlinx.Serialization for JSON D8 for AAC Lifecycle or Java8 desugaring Isolate modules that require kapt Minimize the # of modules relying on kapt If doomed by Dagger2: consider dagger-reflect https://github.com/JakeWharton/dagger-reflect
92. https://speakerdeck.com/ubiratansoares
93. UBIRATAN SOARES Computer Scientist by ICMC/USP Software Engineer, curious guy Google Developer Expert for Android / Kotlin Teacher, speaker, etc, etc
94. THANK YOU @ubiratanfsoares ubiratansoares.dev https://br.linkedin.com/in/ubiratanfsoares