Share more logic between iOS and Android

Update the Gradle version catalog

Add the following entries to gradle/libs.versions.toml, then sync Gradle files to make the references available in build configuration code:

Add dependencies to corresponding source sets

Add the library references to corresponding source sets in the sharedLogic/build.gradle.kts file:

Synchronize the Gradle files by clicking the Sync Gradle Changes button.

Create a data model

In the sharedLogic/src/commonMain/.../greetingkmp directory, create a new RocketLaunch.kt file 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 with more readable names in data classes.

Connect HTTP client

1. In the sharedLogic/src/commonMain/.../greetingkmp directory, create a new RocketComponent class.

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

   import io.ktor.client.HttpClient import io.ktor.client.plugins.contentnegotiation.ContentNegotiation import io.ktor.serialization.kotlinx.json.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 such a way that it prints JSON in a more readable manner with the prettyPrint property. This 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, which will retrieve information about rocket launches asynchronously:

   import io.ktor.client.request.get import io.ktor.client.call.body class RocketComponent { // ... private suspend fun getDateOfLastSuccessfulLaunch(): String { val rockets: List<RocketLaunch> = httpClient.get("https://api.spacexdata.com/v4/launches").body() // Initialized with a stub date for now val date: String = "October 5, 2026" return "$date" } }

   • 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.

4. After the HTTP request call, add the call to get the last successful launch in the list (the list of launches is sorted by date from oldest to newest):

   class RocketComponent { // ... private suspend fun getDateOfLastSuccessfulLaunch(): String { val response: LaunchListResponse = httpClient.get("https://lldev.thespacedevs.com/2.3.0/launches/previous/?mode=list&limit=10&format=json").body() val lastSuccessLaunch = response.results.first { it.status.id == 3 } val date: String = "October 5, 2026" return "$date" } }

5. Conversion the UTC date and time of a launch to your local date and assign the result to date. Then return the formatted output:

   import kotlinx.datetime.TimeZone import kotlinx.datetime.toLocalDateTime import kotlin.time.ExperimentalTime import kotlin.time.Instant class RocketComponent { // ... private suspend fun getDateOfLastSuccessfulLaunch(): String { val response: LaunchListResponse = httpClient.get("https://lldev.thespacedevs.com/2.3.0/launches/previous/?mode=list&limit=10&format=json").body() val lastSuccessLaunch = response.results.first { it.status.id == 3 } val date = Instant.parse(lastSuccessLaunch.launchDateUTC) .toLocalDateTime(TimeZone.currentSystemDefault()) return "${date.month} ${date.day}, ${date.year}" } }

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

6. To the same class, add another suspending function, launchPhrase(), which will create a message using the getDateOfLastSuccessfulLaunch() function:

   class RocketComponent { // ... 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 a coroutine flow

Instead of simply calling a suspending function, you can use flows when you need to produce a sequence of values. Flows can emit a sequence of values as the values are produced instead of returning a single value like suspending functions.

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

2. Add a rocketComponent property to the Greeting class. The property will store the message with the last successful launch date:

   class Greeting { 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 class Greeting { // ... fun greet(): Flow<String> = flow { emit(if (Random.nextBoolean()) "Hi!" else "Hello!") delay(1.seconds) emit("Guess what this 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.

You've updated the API of the shared module by changing the return type of the greet() function to Flow. Now you need to update native parts of the project so that they can properly handle the result of calling the greet() function.

Introduce a view model

View models are a popular pattern in Android development that helps manage data and other app components that should persist through Android activity lifecycle. Now that the application is becoming more complex, it's time to introduce a view model into our app as well. It will store the data received from the SpaceX API and make it available to the UI.

Create the view model class in the Android platform code:

1. In the sharedUI/src/commonMain/.../greetingkmp directory, create a new MainViewModel Kotlin class:

   import androidx.lifecycle.ViewModel class MainViewModel : ViewModel() { // ... }

   This class extends Android's ViewModel class to align with the platform's expectations regarding lifecycle and configuration changes.

2. Create a greetingList value of the StateFlow type and its backing property:

   import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow class MainViewModel : ViewModel() { private val _greetingList = MutableStateFlow<List<String>>(listOf()) val greetingList: StateFlow<List<String>> get() = _greetingList }

   • StateFlow here extends the Flow interface but has a single value or state.

   • The private backing property _greetingList ensures that only clients of this class can access the read-only greetingList property.

3. In the init function of the view model, collect all the strings from the Greeting().greet() flow:

   import androidx.lifecycle.viewModelScope import kotlinx.coroutines.launch class MainViewModel : ViewModel() { private val _greetingList = MutableStateFlow<List<String>>(listOf()) val greetingList: StateFlow<List<String>> get() = _greetingList init { viewModelScope.launch { Greeting().greet().collect { phrase -> //... } } } }

   Since the Flow.collect() function is suspending, the launch coroutine is used within the view model's scope. This means that the launch coroutine will run only during the correct phases of the view model's lifecycle.

4. Inside the collect trailing lambda, append the collected phrase to the list of phrases in _greetingList using the update() function:

   import kotlinx.coroutines.flow.update class MainViewModel : ViewModel() { //... init { viewModelScope.launch { Greeting().greet().collect { phrase -> _greetingList.update { list -> list + phrase } } } } }

Use the view model's flow

1. In sharedUI/src/commonMain/.../greetingkmp, open the App.kt file and update it, replacing the previous implementation to use the newly implemented view model:

   import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.compose.runtime.getValue import androidx.lifecycle.viewmodel.compose.viewModel @Composable @Preview fun App(mainViewModel: MainViewModel = viewModel()) { MaterialTheme { val greetings by mainViewModel.greetingList.collectAsStateWithLifecycle() Column( modifier = Modifier .safeContentPadding() .fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp), ) { greetings.forEach { greeting -> Text(greeting) HorizontalDivider() } } } }

   • The collectAsStateWithLifecycle() function calls on greetingList to collect the value from the ViewModel's flow and represent it as a composable state in a lifecycle-aware manner.

   • When a new flow is created, the composition state will change and display a scrollable Column with greeting phrases arranged vertically and separated by dividers.

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:

Run the app

To see the final result, rerun your androidApp run configuration:

Introducing a ViewModel

In iosApp/ContentView.swift, create a ViewModel class for ContentView, which will prepare and manage data for it. Call the startObserving() function within a task() call to support concurrency:

• ViewModel is declared as an extension to ContentView, as they are closely connected.

• ViewModel has a greetings property that is an array of String phrases.

SwiftUI connects the view model (ContentView.ViewModel) with the view (ContentView):

• ContentView.ViewModel is declared as an ObservableObject. The @ObservedObject wrapper for the viewModel property in ContentView subscribes the view to the view model.

• The greetings property of the view model uses the @Published wrapper. It allows SwiftUI to automatically update the view when this property changes.

Now you need to implement the startObserving() function to consume flows.

Choose a library to consume flows from iOS

In this tutorial, you can use SKIE the KMP-NativeCoroutines library to help you work with flows in iOS. Both are open-source solutions that support cancellation and generics with flows, which the Kotlin/Native compiler doesn't yet provide by default:

• The KMP-NativeCoroutines library helps you consume suspending functions and flows from iOS by generating the necessary wrappers. KMP-NativeCoroutines supports Swift's async/await functionality as well as Combine and RxSwift. Using KMP-NativeCoroutines requires adding a SwiftPM or CocoaPod dependency in iOS projects.

• The SKIE library augments the Objective-C API produced by the Kotlin compiler: SKIE transforms flows into an equivalent of Swift’s AsyncSequence. SKIE directly supports Swift's async/await, without thread restriction, and with automatic bidirectional cancellation (Combine and RxSwift require adapters). SKIE offers other features to produce a Swift-friendly API from Kotlin, including bridging various Kotlin types to Swift equivalents. It also doesn’t require adding additional dependencies in iOS projects.

Consume the ViewModel and run the iOS app

In iosApp/iOSApp.swift, update the entry point for your app:

Run the iosApp configuration from IntelliJ IDEA to make sure your app's logic is synced:

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.