Create your first cross-platform 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 Greeting.kt file and try to access one of the Java classes, java.util.Random().nextBoolean(), inside the greet() function:

   import java.util.Random fun greet(): String { val firstWord = if (Random().nextBoolean()) "Hi!" else "Hello!" return firstWord }

   Android Studio highlights that the Random class is unresolved because you can't call specific Java functions from the common Kotlin code.

2. Follow the IDE's suggestions and replace it with 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. Remove brackets from Random(), as it is an abstract class. The code should now compile successfully.

4. Add a bit of variety to the greeting. Update the shared code with the reversed() function from the Kotlin standard library to reverse the text:

   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()}!" } }

Writing the code only in common Kotlin has obvious limitations because it can't use any platform specifics. Using interfaces and the expect/actual mechanism solves this.

Add platform-specific implementations

The common source set can define an interface or an expected declaration. Then each platform source set, in this case androidMain and iosMain, has to provide actual platform-specific implementations for the expected declarations from the common source set.

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 project in Android Studio, you get a template with the Platform.kt file in the commonMain module:

   interface Platform { val name: String }

   It's a common Platform interface with information about the platform.

2. Switch between the androidMain and the iosMain modules. You'll see that they have different implementations of the same functionality for the Android and the iOS source sets:

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

   • The name property implementation from AndroidPlatform uses the Android platform code, namely the android.os.Build dependency. This code is written in Kotlin/JVM. If you try to access java.util.Random here, this code will compile.

   • The name property implementation from IOSPlatform uses iOS platform code, namely the platform.UIKit.UIDevice dependency. It's written in Kotlin/Native, meaning you can write iOS code in Kotlin. This code becomes a part of the iOS framework, which you will later call from Swift in your iOS application.

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

   // Platform.kt in the commonMain module: expect fun getPlatform(): Platform
   // Platform.android.kt in the androidMain module: actual fun getPlatform(): Platform = AndroidPlatform()
   // Platform.ios.kt in the iosMain module: 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.

While generating the code for a specific platform, the Kotlin compiler merges expected and actual declarations into a single getPlatform() function with its actual implementations.

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 calls a correct actual implementation.

Now you can run the apps to ensure everything works.

Run your application on Android

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

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

1. Launch Xcode in a separate window. The first time you do this, you may also need to accept the license terms and allow Xcode to perform some necessary initial tasks.

2. In Android Studio, select iosApp in the list of run configurations and click Run.

   If you don't have an available iOS configuration in the list, add a new run configuration.

   

   

See also

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

• Learn more about the project structure.