Share more logic between iOS and Android

kotlinx.coroutines

To add kotlinx.coroutines to your project, specify a dependency in the common source set. To do so, add the following line to the build.gradle.kts file of the shared module:

The Multiplatform Gradle plugin automatically adds a dependency to the platform-specific (iOS and Android) parts of kotlinx.coroutines.

kotlinx.serialization

For kotlinx.serialization, you need the plugin required by the build system. The Kotlin serialization plugin ships with the Kotlin compiler distribution, and the IntelliJ IDEA plugin is bundled into the Kotlin plugin.

You can set up the serialization plugin with the Kotlin plugin using the Gradle plugin DSL. To do so, add the following line to the existing plugins block at the very beginning of the build.gradle.kts file in the shared module:

Ktor

You can add Ktor in the same way you added the kotlinx.coroutines library earlier. In addition to specifying the core dependency (ktor-client-core) in the common source set, you also need to:

• Add the ContentNegotiation functionality (ktor-client-content-negotiation), which is responsible for serializing/deserializing the content in a specific format.

• Add the ktor-serialization-kotlinx-json dependency to instruct Ktor to use the JSON format and kotlinx.serialization as a serialization library. Ktor will expect JSON data and deserialize it into a data class when receiving responses.

• Provide the platform engines by adding dependencies on the corresponding artifacts in the platform source sets (ktor-client-android, ktor-client-darwin).

Synchronize the Gradle files by clicking Sync Now in the notification.

Add data model

In shared/src/commonMain/kotlin, create a new RocketLaunch.kt file in the project directory and add a data class which stores data from the SpaceX API:

• The RocketLaunch class is marked with the @Serializable annotation, so that the kotlinx.serialization plugin can automatically generate a default serializer for it.

• The @SerialName annotation allows you to redefine field names, making it possible to declare properties in data classes with more readable names.

Connect HTTP client

1. In shared/src/commonMain/kotlin, create a new RocketComponent class in the project directory.

2. Add the httpClient property to retrieve rocket launch information through an HTTP GET request:

   import io.ktor.client.* import io.ktor.client.plugins.contentnegotiation.* import io.ktor.serialization.kotlinx.json.* import kotlinx.serialization.json.Json class RocketComponent { private val httpClient = HttpClient { install(ContentNegotiation) { json(Json { prettyPrint = true isLenient = true ignoreUnknownKeys = true }) } } }

   • The ContentNegotiation Ktor plugin and the JSON serializer deserialize the result of the GET request.

   • The JSON serializer here is configured in a way that it prints JSON in a more readable manner with the prettyPrint property. It is more flexible when reading malformed JSON with isLenient, and it ignores keys that haven't been declared in the rocket launch model with ignoreUnknownKeys.

3. Add the getDateOfLastSuccessfulLaunch() suspending function to RocketComponent:

   private suspend fun getDateOfLastSuccessfulLaunch(): String { // ... }

4. Call the httpClient.get() function to retrieve information about rocket launches:

   import io.ktor.client.request.* private suspend fun getDateOfLastSuccessfulLaunch(): String { val rockets: List<RocketLaunch> = httpClient.get("https://api.spacexdata.com/v4/launches").body() }

   • httpClient.get() is also a suspending function because it needs to retrieve data over the network asynchronously without blocking threads.

   • Suspending functions can only be called from coroutines or other suspending functions. This is why getDateOfLastSuccessfulLaunch() was marked with the suspend keyword. The network request is executed in the HTTP client's thread pool.

5. Update the function again to find the last successful launch in the list:

   import io.ktor.client.call.* private suspend fun getDateOfLastSuccessfulLaunch(): String { val rockets: List<RocketLaunch> = httpClient.get("https://api.spacexdata.com/v4/launches").body() val lastSuccessLaunch = rockets.last { it.launchSuccess == true } }

   The list of rocket launches is sorted by date from oldest to newest.

6. Convert the launch date from UTC to your local date and format the output:

   import kotlinx.datetime.Instant import kotlinx.datetime.TimeZone import kotlinx.datetime.toLocalDateTime private suspend fun getDateOfLastSuccessfulLaunch(): String { val rockets: List<RocketLaunch> = httpClient.get("https://api.spacexdata.com/v4/launches").body() val lastSuccessLaunch = rockets.last { it.launchSuccess == true } val date = Instant.parse(lastSuccessLaunch.launchDateUTC) .toLocalDateTime(TimeZone.currentSystemDefault()) return "${date.month} ${date.dayOfMonth}, ${date.year}" }

   The date will be in the "MMMM DD, YYYY" format, for example, OCTOBER 5, 2022.

7. Add another suspending function, launchPhrase(), which will create a message using the getDateOfLastSuccessfulLaunch() function:

   suspend fun launchPhrase(): String = try { "The last successful launch was on ${getDateOfLastSuccessfulLaunch()} 🚀" } catch (e: Exception) { println("Exception during getting the date of the last successful launch $e") "Error occurred" }

Create the flow

You can use flows instead of suspending functions. They emit a sequence of values instead of a single value that suspending functions return.

1. Open the Greeting.kt file in the shared/src/commonMain/kotlin directory.

2. Add a rocketComponent property, which will get the message with the last successful launch date:

   private val rocketComponent = RocketComponent()

3. Change the greet() function to return a Flow:

   import kotlinx.coroutines.delay import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flow import kotlin.time.Duration.Companion.seconds fun greet(): Flow<String> = flow { emit(if (Random.nextBoolean()) "Hi!" else "Hello!") delay(1.seconds) emit("Guess what it is! > ${platform.name.reversed()}") delay(1.seconds) emit(daysPhrase()) emit(rocketComponent.launchPhrase()) }

   • The Flow is created here with the flow() builder function, which wraps all the statements.

   • The Flow emits strings with a delay of one second between each emission. The last element is only emitted after the network response returns, so the exact delay depends on your network.

Add internet access permission

To access the internet, the Android application needs the appropriate permission. Since all network requests are made from the shared module, it makes sense to add the internet access permission to its manifest.

Update your androidApp/src/main/AndroidManifest.xml file with the access permission:

Android app

As both the shared module and the Android application are written in Kotlin, using shared code from Android is straightforward.

iOS app

For the iOS part of the project, you'll make use of the Model–view–viewmodel pattern again to connect the UI to the shared module, which contains all the business logic.

The module is already connected to the iOS project — the Android Studio plugin wizard has completed the configuration. The module is already imported and used in ContentView.swift with import shared.

See also

• Explore various approaches to composition of suspending functions.

• Learn more about the interoperability with Objective-C frameworks and libraries.

• Complete this tutorial on networking and data storage.