update: new SKIE version and some freshening up (#532)

Author: zamulla

topics/multiplatform-onboard/multiplatform-create-first-app.md

@@ -81,7 +81,7 @@ The common source set contains shared code that can be used across multiple targ
 It's designed to contain code that is platform-independent. If you try to use platform-specific APIs in the common source set,
 the IDE will show a warning:
 
-1. Open the `shared/src/commonMain/kotlin/com/jetbrains/greeting/greetingkmp/Greeting.kt` file
+1. Open the `shared/src/commonMain/.../Greeting.kt` file
     where you can find an automatically generated `Greeting` class with a `greet()` function:
 
     ```kotlin
@@ -94,23 +94,22 @@ the IDE will show a warning:
     }
     ```
 
-2. Add a bit of variety to the greeting. Import `kotlin.random.Random` from the Kotlin standard library.
-    This is a multiplatform library that works on all platforms and is included automatically as a dependency.
-3. Update the shared code with the `reversed()` call from the Kotlin standard library to reverse the text:
+2. Let's add a bit of variety to the greeting.
+   Update the shared code with randomization and the `reversed()` call from the Kotlin standard library to reverse the text:
 
     ```kotlin
-    import kotlin.random.Random
-    
     class Greeting {
         private val platform: Platform = getPlatform()
 
         fun greet(): String {
+            //
             val firstWord = if (Random.nextBoolean()) "Hi!" else "Hello!"
 
             return "$firstWord Guess what this is! > ${platform.name.reversed()}!"
         }
     }
     ```
+3. Import the `kotlin.random.Random` class following the IDE's suggestion.
 
 Writing the code only in common Kotlin has obvious limitations because it can't use any platform-specific functionality.
 Using interfaces and the [expect/actual](multiplatform-connect-to-apis.md) mechanism solves this.

topics/multiplatform-onboard/multiplatform-dependencies.md

@@ -54,24 +54,24 @@ multiplatform support, is the most convenient way to work with dates in your sha
     ```kotlin
     kotlin {
         //... 
-        sourceSets
-            languageSettings.optIn("kotlin.time.ExperimentalTime")
+        sourceSets {
+            all { languageSettings.optIn("kotlin.time.ExperimentalTime") }
+   
             commonMain.dependencies {
-                implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.7.1")
+                implementation("org.jetbrains.kotlinx:kotlinx-datetime:%dateTimeVersion%")
             } 
         }
     }
     ```
 
-3. Click the **Sync Gradle Changes** button to synchronize Gradle files: ![Synchronize Gradle files](gradle-sync.png){width=50}
-4. In `shared/src/commonMain/kotlin`, create a new file, `NewYear.kt`, in the project directory where your `Greeting.kt` file is located.
+3. Select the **Build | Sync Project with Gradle Files** menu item
+   or click the **Sync Gradle Changes** button in the build script editor to synchronize Gradle files: ![Synchronize Gradle files](gradle-sync.png){width=50}
+4. Right-click the `shared/src/commonMain/.../greetingkmp` directory and select **New | Kotlin Class/File** to create a new file, `NewYear.kt`.
 5. Update the file with a short function that calculates
-   the number of days from today until the New Year using the `date-time` date arithmetic:
+   the number of days from today until the New Year using the `datetime` date arithmetic:
 
    ```kotlin
-   import kotlinx.datetime.*
-   import kotlin.time.Clock
-   
+   @OptIn(ExperimentalTime::class)
    fun daysUntilNewYear(): Int {
        val today = Clock.System.todayIn(TimeZone.currentSystemDefault())
        val closestNewYear = LocalDate(today.year + 1, 1, 1)
@@ -80,8 +80,8 @@ multiplatform support, is the most convenient way to work with dates in your sha
 
    fun daysPhrase(): String = "There are only ${daysUntilNewYear()} days left until New Year! 🎆"
    ```
-
-6. In `Greeting.kt`, update the `Greeting` class to see the result:
+6. Add all necessary imports as suggested by the IDE.
+7. In the `Greeting.kt` file, update the `Greeting` class to see the result:
 
     ```kotlin
     class Greeting {
@@ -95,7 +95,7 @@ multiplatform support, is the most convenient way to work with dates in your sha
     }
     ```
 
-7. To see the results, re-run your **composeApp** and **iosApp** configurations from IntelliJ IDEA:
+8. To see the results, re-run your **composeApp** and **iosApp** configurations from IntelliJ IDEA:
 
 ![Updated mobile multiplatform app with external dependencies](first-multiplatform-project-3.png){width=500}
 

topics/multiplatform-onboard/multiplatform-update-ui.md

@@ -27,22 +27,23 @@ The `composeApp` module contains an Android application, defines its main activi
 
 Make some changes and see how they are reflected in the UI:
 
-1. Navigate to the `App.kt` file in `composeApp/src/androidMain/kotlin`.
+1. Navigate to the `App.kt` file in the `composeApp/src/androidMain/.../greetingkmp` directory.
 2. Find the `Greeting` class invocation. Select the `greet()` function, right-click it, and select **Go To** | **Declaration or Usages**.
    You'll see that it's the same class from the `shared` module you edited in the previous step.
-3. In the `Greeting.kt` file, update the `greet()` function:
+3. In the `Greeting.kt` file, update the `Greeting` class so that the `greet()` function returns a list of strings:
 
    ```kotlin
-   import kotlin.random.Random
+   class Greeting {
 
-   fun greet(): List<String> = buildList {
-       add(if (Random.nextBoolean()) "Hi!" else "Hello!")
-       add("Guess what this is! > ${platform.name.reversed()}!")
+       private val platform: Platform = getPlatform()
+   
+       fun greet(): List<String> = buildList {
+           add(if (Random.nextBoolean()) "Hi!" else "Hello!")
+           add("Guess what this is! > ${platform.name.reversed()}!")
+       }
    }
    ```
 
-   Now it returns a list of strings.
-
 4. Go back to the `App.kt` file and update the `App()` implementation:
 
    ```kotlin
@@ -82,8 +83,8 @@ framework. The UI of the app is written in Swift.
 
 Implement the same changes as in the Android app:
 
-1. In IntelliJ IDEA, find the `iosApp` folder at the root of your project in the **Project** tool window.
-2. Open the `ContentView.swift` file, right-click the `Greeting().greet()` call, and select **Go To** | **Definition**.
+1. In IntelliJ IDEA, find the `iosApp/iosApp` folder at the root of your project in the **Project** tool window.
+2. Open the `iosApp/ContentView.swift` file, right-click the `Greeting().greet()` call, and select **Go To** | **Definition**.
 
     You'll see the Objective-C declarations for the Kotlin functions defined in the `shared` module. Kotlin types are
     represented as Objective-C types when used from Objective-C/Swift. Here the `greet()` function

topics/multiplatform-onboard/multiplatform-upgrade-app.md

@@ -42,7 +42,7 @@ You'll need to add the following multiplatform libraries in your project:
 ### 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:
+line to the `shared/build.gradle.kts` file:
 
 ```kotlin
 kotlin {
@@ -62,8 +62,7 @@ of `kotlinx.coroutines`.
 ### kotlinx.serialization
 
 To use the `kotlinx.serialization` library, set up a corresponding Gradle plugin.
-To do that, add the following line to the existing `plugins {}` block at the very beginning of the `build.gradle.kts` file
-in the shared module:
+To do that, add the following line to the existing `plugins {}` block at the very beginning of the `shared/build.gradle.kts` file:
 
 ```kotlin
 plugins {
@@ -116,7 +115,7 @@ get the list of all launches from the **v4/launches** endpoint.
 
 ### Add a data model
 
-In the `shared/src/commonMain/kotlin/.../greetingkmp` directory, create a new `RocketLaunch.kt` file
+In the `shared/src/commonMain/.../greetingkmp` directory, create a new `RocketLaunch.kt` file
 and add a data class which stores data from the SpaceX API:
 
 ```kotlin
@@ -143,13 +142,13 @@ data class RocketLaunch (
 
 ### Connect HTTP client
 
-1. In the `shared/src/commonMain/kotlin/.../greetingkmp` directory, create a new `RocketComponent` class.
+1. In the `shared/src/commonMain/.../greetingkmp` directory, create a new `RocketComponent` class.
 2. Add the `httpClient` property to retrieve rocket launch information through an HTTP GET request:
 
     ```kotlin
-    import io.ktor.client.*
-    import io.ktor.client.plugins.contentnegotiation.*
-    import io.ktor.serialization.kotlinx.json.*
+    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 {
@@ -185,8 +184,8 @@ data class RocketLaunch (
 4. Call the `httpClient.get()` function to retrieve information about rocket launches:
 
    ```kotlin
-   import io.ktor.client.request.*
-   import io.ktor.client.call.*
+   import io.ktor.client.request.get
+   import io.ktor.client.call.body
 
    class RocketComponent {
        // ...
@@ -222,11 +221,13 @@ data class RocketLaunch (
    ```kotlin
    import kotlinx.datetime.TimeZone
    import kotlinx.datetime.toLocalDateTime
+   import kotlin.time.ExperimentalTime
    import kotlin.time.Instant
 
    class RocketComponent {
        // ...
 
+       @OptIn(ExperimentalTime::class)
        private suspend fun getDateOfLastSuccessfulLaunch(): String {
            val rockets: List<RocketLaunch> =
                httpClient.get("https://api.spacexdata.com/v4/launches").body()
@@ -325,18 +326,7 @@ Now that the application is becoming more complex, it's time to introduce a view
 called `MainActivity`. It invokes the `App()` function that implements the UI.
 The view model will manage the data from the activity and won't disappear when the activity undergoes a lifecycle change.
 
-1. Add the following dependencies to your `composeApp/build.gradle.kts` file:
-
-    ```kotlin
-    androidMain.dependencies {
-        // ...
-        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2")
-        implementation("androidx.lifecycle:lifecycle-runtime-compose:2.6.2")
-        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.2")
-    }
-    ```
-
-2. In the `composeApp/src/androidMain/kotlin/com/jetbrains/greeting/greetingkmp` directory,
+1. In the `composeApp/src/androidMain/.../greetingkmp` directory,
     create a new `MainViewModel` Kotlin class:
 
     ```kotlin
@@ -349,7 +339,7 @@ The view model will manage the data from the activity and won't disappear when t
 
    This class extends Android's `ViewModel` class, which ensures the correct behavior regarding lifecycle and configuration changes.
 
-3. Create a `greetingList` value of the [StateFlow](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/)
+2. Create a `greetingList` value of the [StateFlow](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/)
    type and its backing property:
 
     ```kotlin
@@ -365,7 +355,7 @@ The view model will manage the data from the activity and won't disappear when t
    * `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.
 
-4. In the `init` function of the View Model, collect all the strings from the `Greeting().greet()` flow:
+3. In the `init` function of the View Model, collect all the strings from the `Greeting().greet()` flow:
 
     ```kotlin
    import androidx.lifecycle.viewModelScope
@@ -388,7 +378,7 @@ The view model will manage the data from the activity and won't disappear when t
    Since the `collect()` function is suspended, 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.
 
-5. Inside the `collect` trailing lambda, update the value of `_greetingList` to append the collected `phrase` to the list of phrases in `list`:
+4. Inside the `collect` trailing lambda, update the value of `_greetingList` to append the collected `phrase` to the list of phrases in `list`:
 
     ```kotlin
     import kotlinx.coroutines.flow.update
@@ -418,6 +408,7 @@ The view model will manage the data from the activity and won't disappear when t
     import androidx.lifecycle.viewmodel.compose.viewModel
     
     @Composable
+    @Preview
     fun App(mainViewModel: MainViewModel = viewModel()) {
         MaterialTheme {
             val greetings by mainViewModel.greetingList.collectAsStateWithLifecycle()
@@ -664,6 +655,11 @@ plugins {
 }
 ```
 
+> The 0.10.6 version of SKIE latest at the moment of writing does not support the latest Kotlin.
+> To use it, downgrade your Kotlin version to 2.2.10 in the `gradle/libs.versions.toml` file.
+> 
+{style="warning"}
+
 #### Consume the flow using SKIE
 
 You'll use a loop and the `await` mechanism to iterate through the `Greeting().greet()` flow and update the `greetings`

topics/overview/faq.md

@@ -67,17 +67,14 @@ this code depends on where you call the code from. Calling suspending functions
 documented, especially for Android. [Calling them from Swift code](https://kotlinlang.org/docs/native-arc-integration.html#completion-handlers)
 requires a little more work, see [KT-47610](https://youtrack.jetbrains.com/issue/KT-47610) for more details.
 
-<!-- when adding SKIE back to the tutorial, add it here as well
-and uncomment the paragraph below --> 
-
 The best current approach for calling suspending functions and flows from Swift is to use plugins and libraries like
 [KMP-NativeCoroutines](https://github.com/rickclephas/KMP-NativeCoroutines) together
 with Swift's `async`/`await` or libraries like Combine and RxSwift.
 
-<!-- At the moment, KMP-NativeCoroutines is the more
-tried-and-tested solution, and it supports `async`/`await`, Combine, and RxSwift approaches to concurrency. SKIE is easier
-to set up and less verbose. For instance, it maps Kotlin `Flow` to Swift `AsyncSequence` directly. Both of these libraries
-support the proper cancellation of coroutines. -->
+At the moment, KMP-NativeCoroutines is the more
+tried-and-tested solution, and it supports `async`/`await`, Combine, and RxSwift approaches to concurrency.
+SKIE can be easier to set up and is less verbose. For instance, it maps Kotlin `Flow` to Swift `AsyncSequence` directly.
+Both of these libraries support the proper cancellation of coroutines. 
 
 To learn how to use them, see [](multiplatform-upgrade-app.md).
 

v.list

@@ -39,7 +39,7 @@
     <var name="ktorVersion" value="3.3.1" type="string"/>
     <var name="dateTimeVersion" value="0.7.1" type="string"/>
     <var name="koinVersion" value="4.1.0" type="string"/>
-    <var name="skieVersion" value="0.10.4" type="string"/>
+    <var name="skieVersion" value="0.10.6" type="string"/>
     <var name="kmpncVersion" value="1.0.0-ALPHA-45" type="string"/>
     <var name="kspVersion" value="2.2.10-2.0.2" type="string"/>
     <var name="vanniktechPublishPlugin" value="0.34.0" type="string"/>