Sign up to my newsletter to never miss new content. I will publish new blog posts and videos about Coroutines and Flow on a regular basis.

🎓 Online Course

This project is the foundation of a comprehensive Online Course about Kotlin Coroutines and Flow for Android Development In the course, we are going to implement the use cases of this repository together, as well as talk about all the necessary concepts that you need to know.

📢 Sharing is Caring

If you like this project, please tell other developers about it! ❤️

If you like, you can follow me on Twitter @LukasLechnerDev.

⭐️ Coroutine Use Cases

1. Perform single network request
2. Perform two sequential network requests
3. Perform several network requests concurrently
4. Perform variable amount of network requests
5. Perform a network request with timeout
6. Retrying network requests
7. Network requests with timeout and retry
8. Room and Coroutines
9. Debugging Coroutines
10. Offload expensive calculation to background thread
11. Cooperative Cancellation
12. Offload expensive calculation to several Coroutines
13. Exception Handling
14. Continue Coroutine execution even when the user leaves the screen
15. Using WorkManager with Coroutines
16. Performance analysis of dispatchers, number of coroutines and yielding
17. Perform expensive calculation on Main Thread without freezing the UI

⭐ Flow Use Cases

1. Flow Basics
2. Basic Flow intermediate operators
3. Flow Exception Handling
4. Exposing Flows in the ViewModel

📄 Coroutine Use Cases Description

1. Perform single network request

This use case performs a single network request to get the latest Android Versions and displays them on the screen.

[code]

2. Perform two sequential network requests

This use case performs two network requests sequentially. First, it retrieves recent Android Versions and then it requests the features of the latest version.

There are also 2 alternative implementations included. One is using old-school callbacks. The other one uses RxJava. You can compare each implementation. If you compare all three implementations, it is really interesting to see, in my opinion, how simple the Coroutine-based version actually is.

[code]

3. Perform several network requests concurrently

Performs three network requests concurrently. It loads the feature information of the 3 most recent Android Versions. Additionally, an implementation that performs the requests sequentially is included. The UI shows how much time each implementation takes to load the data so you can see that the network requests in the concurrent version are indeed performed in parallel. The included unit test is also interesting, as it shows how you can use virtual time to verify that the concurrent version gets performed in parallel.

[code]

4. Perform variable amount of network requests

Demonstrates the simple usage of map() to perform a dynamic amount of network requests. At first, this use case performs a network request to load all Android versions. Then it performs a network request for each Android version to load its features. It contains an implementation that performs the network requests sequentially and another one that performs them concurrently.

[code]

5. Perform network request with timeout

This use case uses the suspending function withTimeout() from the coroutines-core library. It throws a TimeoutCancellationException if the timeout was exceeded. You can set the duration of the request in the UI and check the behaviour when the response time is bigger than the timeout.

General networking timeouts can also be configured in the okhttp client.

[code]

6. Retrying network requests

Demonstrates the usage of higher-order functions together with coroutines. The higher-order function retry() retries a certain suspending operation for a given amount of times. It uses an exponential backoff for retries, which means that the delay between retries increases exponentially. The behavior of the Mock API is defined in a way that it responses with 2 unsuccessful responses followed by a successful response.

[code]

Unit tests verify the amount of requests that are performed in different scenarios. Furthermore, they check if the exponential backoff is working properly by asserting the amount of elapsed virtual time.

7. Network requests with timeout and retry

Composes higher level functions retry() and withTimeout(). Demonstrates how simple and readable code written with Coroutines can be. The mock API first responds after the timeout and then returns an unsuccessful response. The third attempt is then successful.

Take a look at the included callback-based implementation to see how tricky this use case is to implement without Coroutines.

I also implemented the use case with RxJava.

[code]

8. Room and Coroutines

This example stores the response data of each network request in a Room database. This is essential for any "offline-first" app. If the View requests data, the ViewModel first checks if there is data available in the database. If so, this data is returned before performing a network request to get fresh data.

[code]

9. Debugging Coroutines

This is not really a use case, but I wanted to show how you can add additional debug information about the Coroutine that is currently running to your logs. It will add the Coroutine name next to the thread name when calling Thread.currentThread.name() This is done by enabling Coroutine Debu