Create your Kotlin Multiplatform app

Write common declarations

The common source set contains shared code that can be used across multiple target platforms. 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 sharedLogic/src/commonMain/.../Greeting.kt file where you can find the generated Greeting class with a greet() function.

2. Let's add a bit of variety to the greeting. Navigate to the definition of the sayHello() function in the GreetingUtil.kt file.

3. Update the shared code with randomization and the reversed() call from the Kotlin standard library to reverse the received string:

   fun sayHello(to: String): String { val firstWord = if (Random.nextBoolean()) "Hi!" else "Hello!" return "$firstWord Guess what this is! > ${to.reversed()}!" }

4. 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 common interfaces with platform-specific implementations using the expect/actual mechanism solves this.

Check out platform-specific implementations

The common source set can define expected declarations — interfaces, classes, and so on. In each platform source set, in this case androidMain and iosMain, you have to provide actual platform-specific implementations for the expected declarations.

While generating the code for a specific platform, the Kotlin compiler merges expected and actual declarations and generates a single declaration with actual implementations.

1. When creating a Kotlin Multiplatform project with IntelliJ IDEA, you get a Platform.kt file in the sharedLogic/src/commonMain module:

   interface Platform { val name: String }

   It's a common Platform interface supposed to include information about a platform.

2. You can find the platform-specific classes that implement the interface in the androidMain and the iosMain source sets:

   // Platform.android.kt in the androidMain source set import android.os.Build class AndroidPlatform : Platform { override val name: String = "Android ${Build.VERSION.SDK_INT}" }
   // Platform.ios.kt in the iosMain source set import platform.UIKit.UIDevice class IOSPlatform: Platform { override val name: String = UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion }

   • The name property of the AndroidPlatform class uses the Android-specific code, namely the android.os.Build dependency. This code is interpreted as Kotlin/JVM. If you try to access a JVM-specific class, such as java.util.Random here, this code will compile.

   • The name property of the IOSPlatform class uses iOS-specific code, namely the platform.UIKit.UIDevice dependency. This code is interpreted as Kotlin/Native, meaning that you can refer to iOS declarations in Kotlin. The code becomes a part of the iOS framework, which is imported in the Swift code of the iosApp module.

3. Each source set includes a getPlatform() function. Its expected declaration doesn't have a body, and actual implementations are provided in the platform code:

   // Platform.kt in the commonMain source set expect fun getPlatform(): Platform
   // Platform.android.kt in the androidMain source set actual fun getPlatform(): Platform = AndroidPlatform()
   // Platform.ios.kt in the iosMain source set actual fun getPlatform(): Platform = IOSPlatform()

Here, the common source set defines an expected getPlatform() function and has actual implementations, AndroidPlatform() for the Android app and IOSPlatform() for the iOS app, in the platform source sets.

When generating the code for a specific platform, the Kotlin compiler merges expected and actual declarations into a single getPlatform() function with the correct implementation.

That's why expected and actual declarations should be defined in the same package – they are merged into one declaration in the resulting platform code. Any invocation of the expected getPlatform() function in the generated platform code then refers to the correct actual implementation.

Now you can run the apps and see all of this in action.

Run your application on Android

1. In the list of run configurations, select androidApp.

2. Choose an Android virtual device next to the list of configurations and click Run.

   If you don't have a device in the list, create a new Android virtual device.

   

   

Run your application on iOS

If you haven't launched Xcode as part of the initial setup, do that before running the iOS app.

In IntelliJ IDEA, select iosApp in the list of run configurations, select a simulated device next to the run configuration, and click Run.

If you don't have an available iOS configuration in the list, start Xcode to populate the available simulators and restart IntelliJ IDEA.

See also

• See how to create and run multiplatform tests to check that the code works correctly.

• Learn more about the project structure.

• If you want to convert your existing Android project into a cross-platform app, complete this tutorial to make your Android app cross-platform.