Kotlin Flow Application and Testing on Android

Kotlin Flow is an asynchronous stream library based on top of Kotlin Coroutines. There are different ways to use Flow and test them on Android. In this talk, we will discuss the applications of Flow and their pros & cons. For example, we can also apply with Flow on UI events and network requests. As you may know, unit testing on Android sometimes could be painful. We will go through Flow testing methods and examples to let you get familiar with them. In the last part of this talk, we will talk about the experience and pitfalls of using Flow in production.

Transcript

1. Kotlin Flow Application and Testing on Android Yu Hao Wu (Ivan) 2020/11/19@Jcconf
2. Outline Flow Introduction 01 Application 02 Testing 03 Experiences 04
3. Flow Introduction 01
4. What is Flow? A new stream processing API developed by JetBrains.
5. What is Flow? • Simple • Language feature support • Flows are cold
6. How to Use it? flowOf("Pikachu", "John", "Blabla") .collect { name -> println(name) }
7. How to Use it? flow { emit(6) } .collect { number -> println(number) }
8. How to Use it? flowOf("Pikachu", "John", "Blabla") .map { names -> names[5] } .catch { e -> println(e) } .onCompletion { println("Completed") } .collect { ch -> println(ch) }
9. Threading • Threading Operator ◦ flowOn • Dispatchers ◦ IO ◦ Main ◦ Default
10. Threading fun getUserFromServer(id: Long): Flow<User> { ... } getUserFromServer(id) .flowOn(Dispatchers.IO) .collect { Log.d("test", "I got $it") }
11. Application 02
12. Flow + Retrofit • Wrap Retrofit calls in call adapter factory. • Use libraries. Retrofit.Builder() .baseUrl(BASE_DOMAIN) .client(okhttpClient) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(MyRetrofitFlowFactory.create()) .build()
13. Flow + UI Events • UI inputs as a flow of UI events. findViewById<Button>(R.id.button) .clicks() .onEach { Log.d("logTag", "clicked!") } .launchIn(lifecycleScope)
14. Advantages • Binds to lifecycles automatically. • Makes code more readable. • Avoid callback hell & boilerplates. • You can write everything related to UI in Flow.
15. Do it! • Write it by yourself ◦ Extension methods • Libs ◦ FlowBinding ◦ Corbind
16. Use Cases • Avoid quick double clicks on buttons. findViewById<Button>(R.id.button) .clicks() .sample(2000L) .onEach { Log.d("ivan", "FAB click!") }.launchIn(lifecycleScope)
17. Use Cases • To implement API search by TextWatcher. view.findViewById<EditText>(R.id.edit_text) .textChanges() .skipInitialValue() .sample(2000L) .map { it.toString() } .onEach { search(it) } .launchIn(lifecycleScope)
18. Use Cases • To detect gestures with onTouch events. ◦ Use sealed class as gesture types! sealed class Touch(open val x: Float, open val y: Float)
19. Use Cases object Click: Touch(0F, 0F) data class Down(override val x: Float, override val y: Float): Touch(x, y) data class Move(override val x: Float, override val y: Float): Touch(x, y) data class Up(override val x: Float, override val y: Float): Touch(x, y) object Other: Touch(0F, 0F)
20. Source: https:/ /gist.github.com/ivanisidrowu/f0f2b091855e1b677bb04cb827fdc1d6#file-secondfragment-java-L39 Use Cases fun Flow<MotionEvent>.classifyTouches(clickReactionTime: Long): Flow<Touch> { ... }
21. Source: https:/ /gist.github.com/ivanisidrowu/f0f2b091855e1b677bb04cb827fdc1d6#file-secondfragment-java-L39 Use Cases view.findViewById<ConstraintLayout>(R.id.root) .touches() .classifyTouches(500L) .onEach { event: Touch -> Log.w("ivan", "[SecondFragment][onViewCreated] $event") } .launchIn(lifecycleScope)
22. Testing 03
23. How to Test Flow? • Mocking Libraries • Flow Assert / Turbine
24. Mocking Libs • Flow can be easily tested by using mocking libraries. • Use Mocking Libs ◦ Mockito-kotlin ◦ MockK
25. Example data class User(val name: String, val id: Long) interface Service { fun getUser(): User } class ApiService : Service { override fun getUser() = User("John", 1L) }
26. Example class UserRepository(private val service: Service) { fun getUser(): Flow<User> = flow { emit(service.getUser()) } }
27. Using MockK to Test Flow @Test fun `Test getting an user info by MockK`() = runBlocking { } val fakeUser = User("Doe", 2L) val mockApiService = mockk<ApiService>(relaxed = true) every { mockApiService.getUser() } returns fakeUser val userRepository = UserRepository(mockApiService) userRepository.getUser().collect { assertEquals(it, fakeUser) }
28. Flow Assert / Turbine • It is originally from SqlDelight lib ◦ It was published as Turbine. • An extension function of Flow • Makes expressions more specific ◦ expectItem() ◦ expectError() ◦ expectComplete() • Takes advantage of Channels API and Coroutines API. •
29. The Extension suspend fun <T> Flow<T>.test( timeout: Duration = 1.seconds, validate: suspend FlowTurbine<T>.() -> Unit ) { ... } Source: https://github.com/cashapp/turbine/blob/trunk/src/commonMain/kotlin/app/cash/turbine/FlowTurbine.kt
30. FlowTurbine Source: https://github.com/cashapp/turbine/blob/trunk/src/commonMain/kotlin/app/cash/turbine/FlowTurbine.kt interface FlowTurbine<T> { suspend fun expectItem(): T suspend fun expectComplete() suspend fun expectError(): Throwable }
31. Channels Source: https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/01_Introduction
32. How does it Work? Flow Items Unlimited Buffer Channel FlowTurbine expectItem() expectError() expectComplete() Query the Channel Reference: https://proandroiddev.com/kotlin-flow-assert-ff45465c01c0
33. Flow Assert / Turbine @Test fun `Test getting an user info by Flow Assert`() = runBlocking { } val fakeUser = User("Pikachu", 3L) val fakeApiService = provideFakeService(fakeUser) val userRepository = UserRepository(fakeApiService) userRepository.getUser().test { assertEquals(expectItem(), fakeUser) expectComplete() }
34. Experiences 04
35. Threading Operators • In RxJava, we declare start and modify chain below. observeSomething() .subscribeOn(io()) .observe(mainThread()) .subscribeOn(computation()) .subscribe { result -> println(result) }
36. Threading Operators • In Flow, we have end declared and can modify chain above. CouroutineScope(Job() + Dispatchers.Main).launch { doSomething(url) .flowOn(Dispathcers.IO) .map { channel -> channel.getResult() } .flowOn(Dispatchers.Default) .collect { println(it) } }
37. Retrofit + Flow • When you retry your API calls, you will get an exception. ◦ java.lang.IllegalStateException: Already executed.
38. Retrofit + Flow • Simply copy the call before you execute it in your CallAdapterFactory. override fun adapt(call: Call<T>): Flow<Response<T>> = flow { val newCall = call.takeIf { !it.isExecuted } ?: call.clone() emit(newCall.awaitResponse()) }
39. From RxJava to Flow • No need to do the whole migration all at once. ◦ The commits will be huge. ◦ Making incremental changes might be a good idea! • Use kotlinx-coroutines-rx2 ◦ Observables transformation ◦ Suspending extensions
40. Observable to Flow runBlocking { Observable.just(1, 2, 3, 4, 5) .asFlow() .flowOn(Dispatchers.IO) .collect { } }
41. Flow to Observable flowOf(1, 2, 3, 4, 5) .asObservable() .subscribeOn(Schedulers.io()) .observeOn(mainThread()) .subscribe()
42. Single to Flow runBlocking { flow { emit(getSingle().await()) } }
43. CREDITS: This presentation template was created by Slidesgo, including icons by Flaticon, infographics & images by Freepik THANKS!