Native UI: Shared logic for REST API requests

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: press double Shift, then find and execute the Sync Project with Gradle Files command.

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 Launch Library API:

Connect HTTP client

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

2. Add the httpClient property and use it to build the final string from the result of an HTTP GET request:

   import io.ktor.client.HttpClient import io.ktor.client.call.body import io.ktor.client.plugins.contentnegotiation.ContentNegotiation import io.ktor.client.request.get import io.ktor.serialization.kotlinx.json.json import kotlinx.datetime.TimeZone import kotlinx.datetime.toLocalDateTime import kotlinx.serialization.json.Json import kotlin.time.Instant class RocketComponent { private val httpClient = HttpClient { // ContentNegotiation Ktor plugin and the JSON serializer // deserialize the result of the GET request install(ContentNegotiation) { json(Json { // Produces more readable JSON prettyPrint = true // Allows non-standard JSON input, // such as unquoted keys and string values isLenient = true // Ignores keys that haven't been declared in the model ignoreUnknownKeys = true }) } } // Returns the date string for the latest successful launch. // Marked as suspending because it calls // the suspending httpClient.get() function private suspend fun getDateOfLastSuccessfulLaunch(): String { // Asynchronously retrieves information about rocket launches val response: LaunchListResponse = httpClient.get("https://lldev.thespacedevs.com/2.3.0/launches/previous/?mode=list&limit=10&format=json").body() // Gets the latest successful launch. // In the response, launches are sorted from newest to oldest, // and successful launches are marked with 'status.id' 3 val lastSuccessLaunch = response.results.first { it.status.id == 3 } // Converts the launch timestamp to local time val date = Instant.parse(lastSuccessLaunch.launchDateUTC) .toLocalDateTime(TimeZone.currentSystemDefault()) // Date is displayed in the "MMMM D, YYYY" format, // for example, "JULY 15, 2026" return "${date.month} ${date.day}, ${date.year}" } // Builds the final string for the UI using // the suspending 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" } }

   Suspending functions can only be called from coroutines or other suspending functions. For example, httpClient.get() is a suspending function because it needs to retrieve data over the network asynchronously without blocking threads. Since the getDateOfLastSuccessfulLaunch() function calls httpClient.get(), it's also marked with the suspend keyword.

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 sharedLogic/src/commonMain/kotlin directory.

2. Update the greet() function in the Greeting class to return a Flow of strings, primarily to accommodate the network request. In the Flow, emit the launch date using a RocketComponent property:

   import kotlinx.coroutines.delay import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flow import kotlin.random.Random import kotlin.time.Duration.Companion.seconds class Greeting { private val platform = getPlatform() // Stores the last successful launch date private val rocketComponent = RocketComponent() // Builds and asynchronously emits greeting strings one by one fun greet(): Flow<String> = flow { emit(if (Random.nextBoolean()) "Hi!" else "Hello!") delay(1.seconds) emit("Guess what this is! > ${platform.name.reversed()}") emit(rocketComponent.launchPhrase()) } }

   The Flow is created with the flow() builder function that wraps a suspendable block.

The greet() function now returns Flow<String> instead of a single String. Your native UI code will import the Greeting class and collect strings emitted by the greet() function.

Implement the corresponding changes in native UIs as shown in the following sections.

Introduce a view model

View models are commonly used in Android development to manage UI-related data throughout the lifecycle of an Android activity. Your application is becoming more complex, so it can benefit from a view model as well. The view model will store the data received from the Launch Library API and make it available to the UI.

In the sharedUI/src/commonMain/.../greetingkmp directory, create a new MainViewModel class that extends [ViewModel](https://developer.android.com/reference/kotlin/androidx/lifecycle/ViewModel) from the multiplatform AndroidX library to use Android's lifecycle mechanism and configuration tracking:

Use the view model's flow

In sharedUI/src/commonMain/.../greetingkmp, open the App.kt file and replace the previous implementation to use the newly implemented view model.

As the flow emits new values, the composition updates to display the greeting phrases one by one:

Add internet access permission

To allow the Android application to access the internet, add the following permission to the androidApp/src/main/AndroidManifest.xml file:

Run the app

To see the final result, run your androidApp run configuration.

Introduce a ViewModel

In the iosApp/ContentView.swift file, create a ViewModel class for ContentView, which will prepare and manage data for it. Replace the entire file with the following code:

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

• The ContentView.ViewModel class is declared as an ObservableObject which lets it report changes. The @ObservedObject wrapper for the viewModel property in ContentView subscribes the view to these changes.

• Changes to the greetings property, which has the @Published wrapper, trigger SwiftUI to update ContentView.

Now you need to implement the startObserving() function with one of the available KMP libraries that can consume Kotlin flows in Swift.

Choose a library for consuming Kotlin flows in Swift

In this tutorial, you can use SKIE or 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.

Xcode reports errors in the code calling the shared framework

If you work in Xcode, your Xcode project may be using an old version of the framework. To resolve this, return to IntelliJ IDEA or Android Studio and rebuild the project or start the iOS run configuration.

Xcode reports an error when importing the shared framework

If you are using Xcode, you may need to clear cached binaries: Try resetting the environment by choosing Product | Clean Build Folder in the main menu.