The first step for this chapter is to install Android Studio. For this, you can head to https://developer.android.com/studio/index.html and download the installer for your platform.

Once you have finished the download, follow the steps on the official guide at https://developer.android.com/studio/install.html to complete the installation. By default, the instructions are going to be according to the operating system detected by the web page; if you wish to see the instructions for a different OS, please select the relevant...

When you first open Android Studio, you will be presented with a wizard. To start, select Start a new Android Studio project,as shown in the following screenshot:

Now you will be asked to define the properties of the project. Please make sure that the Include Kotlin support option is enabled:

The next step is to select the Android version that you are targeting. The default options are good for this step:

Then, select the option to have just an empty activity, and leave its configuration as default:

Now you will be prompted to select the name for the class and the layout of the activity. Please write MainActivity as the name of the activity, while setting activity_main as the name of the layout:

Now that the project has been created, it's time to add coroutines support. To do this, open the Project section and double-click in build.gradle for the project. It is located inside the Gradle Scripts section:

Inside this document, you will add a new variable to centralize the coroutines version. In a new line below ext.kotlin.version, add ext.coroutines_version, as shown here, for example:

buildscript {
  ext.kotlin_version = '1.2.50'
  ext.coroutines_version = '0.23.3'
  ...
}

Now you need to add the dependencies for coroutines. Append the dependency configuration in...

As mentioned in the first chapter, Android applications have a thread that is dedicated to updating the UI and also to listening to user interactions and processing the events generated by the user – like the user clicking on a menu.

Let's review the basics of Android's UI thread to guarantee that we separate the work between the UI and background threads in the best way possible.

Android will throw a CalledFromWrongThreadException whenever a thread that didn't create a view hierarchy tries to update its views. In practical terms, this exception will happen whenever a thread other than the UI thread updates a view. This is because the UI thread is...

Kotlin has simplified thread creation so that it's a straightforward process and can be done easily. For now, creating a single thread will be enough, but in future chapters we will also create thread pools in order to run both CPU-bound and I/O-bound operations efficiently.

It's important to understand that in Kotlin, while you can create threads and thread pools easily, you don't access or control them directly. What you do is create a CoroutineDispatcher, which is basically an orchestrator that distributes coroutines among threads based on availability, load, and configuration.

In our current case, for example, we will create a CoroutineDispatcher that has only one thread...

Android requires applications to explicitly request permissions in order to access many features. This is done in order to present the user with an option to deny specific permissions, and prevent applications from doing something different from what the user expects.

Since we will be doing network requests, we will need to add the internet permission to the manifest of the application. Let's locate the AndroidManifest.xml file in the app/src/main directory, and edit it:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="co.starcarr.rssreader">
  <uses-permission android:name="android.permission.INTERNET" />
  <application
  ...
</manifest>

Now it's a good time to add a call to a service. To start with something simple, we will use Java's DocumentBuilder to call an RSS feed for us. First, we will add a variable to hold the DocumentBuilderFactory below where we put the dispatcher:

private val dispatcher = newSingleThreadContext(name = "ServiceCall")
private val factory = DocumentBuilderFactory.newInstance()

The second step is to create a function that will do the actual call:

private fun fetchRssHeadlines(): List<String> {
  val builder = factory.newDocumentBuilder()
  val xml = builder.parse("https://www.npr.org/rss/rss.php?id=1001")
  return emptyList()
}

Notice how the function is, for now, returning an empty list of strings after calling the feed. The idea is to implement this function so that it returns the headlines of the given feed. But...

Now we can start adding some UI elements to do some testing. First, let's update the layout of MainActivity, which is located in res/layout/activity_main.xml. For now, just adding a ProgressBar will do, so let's replace the contents of the ConstraintLayout so that a ProgressBar is located in the middle of the screen:

<android.support.constraint.ConstraintLayout ...>
    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
&lt...

Let's put a TextView in our layout and display the amount of news that were processed from the feed. Notice that the TextView will be located below the progress bar because of the property app:layout_constraintBottom_toBottomOf:

<android.support.constraint.ConstraintLayout ...>
    <ProgressBar ...>
    <TextView
        android:id="@+id/newsCount"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        app:layout_constraintTop_toBottomOf="@id/progressBar"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent" />

</android.support.constraint.ConstraintLayout>

In order to display the amount of news, we will obtain...

In the same way that we used a CoroutineDispatcher to run a thread in the background, we can now use one to preform operations in the main thread.

Given that there are many types of GUI applications for the JVM, Kotlin has separated some platform-specific coroutine functionality into libraries.

• kotlinx-coroutines-android
• kotlinx-coroutines-javafx
• kotlinx-coroutines-swing

Notice that all these platforms have the same UI model that we talked about before, in which only the UI thread can create and update the views. So, these tiny libraries are simply a CoroutineDispatcher that is implemented to confine coroutines to the UI thread.

Currently, a big part of our code to request and display the number of news is inside the onCreate() function. This is less than optimal, not only because it's mixed with the creation of the activity, but also because it prevents reusing this code. For example, if there were to be a refresh button, we would need to reuse all the code of the coroutine.

When considering the separation of this coroutine into its own function, there are many possible approaches. Here, we will cover the most common ones.

The first approach is quite simple. We can create a loadNews() function that directly invokes fetchRssHeadlines...

This chapter covered many interesting topics of practical concurrency in Kotlin. Let's do a recap of the key topics.

• Android applications will throw NetworkOnMainThreadException if a network request is done on the UI thread.
• Android applications can only update the UI on the UI thread, and trying to do it from a different thread will produce a CalledFromWrongThreadException.
• Network requests have to be done in a background thread. The information has to be sent to the UI thread for the views to be updated.
• A CoroutineDispatcher can be used to enforce a coroutine to run in a specific thread, or group of threads.
• One or many coroutines can be run in a thread by using launch or async.
• launch should be used in fire-and-forget scenarios, meaning cases where we aren't expecting the coroutine to return something.
• async should be used when the coroutine will produce...