Chapters
Chapters

Chapters

Hide chapters

Kotlin Multiplatform by Tutorials

Third Edition · Android 15, iOS 18, Desktop · Kotlin 2.1.20 · Android Studio Meerkat

Before You Begin

Section 0: 5 chapters
Show chapters Hide chapters

Section I: Beginning Kotlin Multiplatform

Section 1: 5 chapters
Show chapters Hide chapters

Section II: Kotlin Multiplatform: Intermediate

Section 2: 5 chapters
Show chapters Hide chapters

Section III: Kotlin Multiplatform: Advanced

Section 3: 5 chapters
Show chapters Hide chapters

Section IV: Appendices

Section 4: 3 chapters
Show chapters Hide chapters

6. Connecting to Platform-Specific API
Written by Saeed Taheri

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Any technology that aims to provide a solution for multiplatform development attacks the problem of handling platform differences from a new angle.

When you write a program in a high-level language such as C or Java, you have to compile it to run on a platform like Windows or Linux. It would be wonderful if compilers could take the same code and produce formats that different platforms can understand. However, this is easier said than done.

Kotlin Multiplatform takes this concept and promises to run essentially the same high-level code on multiple platforms — like JVM, JS or native platforms such as iOS directly.

Unlike Java, KMP doesn’t depend on a virtual machine to be running on the target platform. It provides platform-specific compilers and libraries like Kotlin/JVM, Kotlin/JS and Kotlin/Native.

In this chapter, you’re going to learn how to structure your code according to KMP’s suggested approach to handling platform-specific tidbits.

Reusing Code Between Platforms

Kotlin Multiplatform doesn’t compile the entire shared module for all platforms as a whole. Instead, a certain amount of code is common to all platforms, and some amount of shared code is specific to each platform. For this matter, it uses a mechanism called expect/actual.

In Chapter 1, you got acquainted with those two new keywords. Now, you’re going to dive deeper into this concept.

Think of expect as a glorified interface in Kotlin or protocol in Swift. You define classes, properties and functions using expect to say that the shared common code expects something to be available on all platforms. Furthermore, you use actual to provide the actual implementation on each platform.

Like an interface or a protocol, entities tagged with expect don’t include the implementation code. That’s where the actual comes in.

After you define expected entities, you can easily use them in the common code. KMP uses the appropriate compiler to compile the code you wrote for each platform. For instance, it uses Kotlin/JVM for Android and Kotlin/Native for iOS or macOS. Later in the compilation process, each will be combined with the compiled version of the common code for the respective platforms.

You may ask why you need this in the first place. Occasionally, you need to call methods that are specific to each platform. For instance, you may want to use Core ML on Apple platforms or ML Kit on Android for machine learning. You could define certain expect classes, methods and properties in the common code and provide the actual implementation differently for each platform.

The expect/actual mechanism lets you call into the native libraries of each platform using Kotlin. How cool is that!

Say Hello to Organize

After you create a great app to find an appropriate time for setting up your international meetings, you’ll need a way to make To-dos and reminders for those sessions. Organize will help you do exactly that.

Qid. 6.6 — Tiwikx Vakaces xnajuvuqj irqeec bal oEF sgutojozq ziqlmogabaiy
Ram. 4.0 — Fezeqw Vutugeb yrumijazw axkuew geb aAT myelonohn yojtjupewuob

Updating the Platform Class

As explained earlier, you’re going to create a page for your apps in which you show information about the device the app is running on.

Folder Structure

In Android Studio, choose the Project view in Project Navigator. Inside the shared module, browse through the directory structure.

Pur. 1.3 — Bicyaf sjsodgufa oc Uvbruap Tpoqio
Mey. 8.4 — Gobpir hvsilriyo ih Utrzaab Vfuxou

Creating the Platform Class for the Common Module

Open Platform.kt inside the commonMain folder. Replace the expect class definition with the following:

Bis. 0.5 — Vorerimi ce itvooq ibhmarahmupeir rupig
Til. 9.5 — Pecexiji ma evxael ijssofegkiquij muxal

Lir. 9.3 — Owm+Omdag uy iqdijf bmorw bawo hu jkiari exneef czuzziq
Rep. 5.2 — Icx+Eczid eb omrulv dsixk godi qu pdauku ilpuec gniqrop

Implementing Platform on Android

Go to the Platform.kt inside the androidMain folder.

Wum. 2.8 — Ujqtoog Hpebuu uwkazv iq ozdiox ldomj
Pew. 8.2 — Atshiig Kbarei evdefy ux uqzuup vvonm

Implementing Platform on iOS

When you’re inside an actual file, you can click the yellow rhombus with the letter E in the gutter to go to the expect definition. While inside Platform.kt in the androidMain folder, click the yellow icon and go back to the file in the common directory. From there, click the A icon and go to the iOS actual file.

Implementing Platform on Desktop

Open Platform.kt inside the desktopMain folder.

Sharing More Code

You may have noticed that the logSystemInfo method is practically using the same string over and over again. To avoid such code duplications, you’ll consult Kotlin extension functions.

Updating the UI

Now that the Platform class is ready, you’ve finished your job inside the shared module. KMP will take care of creating frameworks and libraries you can use inside each platform you support. You’re now ready to create your beautiful user interfaces on Android, iOS and desktop.

Android

You’ll do all of your tasks inside the androidApp module. The basic structure of the app is ready for you. Some important files need explaining. These will help you in the coming chapters as well. Here’s what it looks like:

Kew. 4.4 — Cedniv brxetdozo luw Ibkluaq uvb
Guv. 5.6 — Jostal zwjammego ten Ovtniiz arg

Haq. 8.4 — Rhu lojfv meko uh Ifsazici og Elpxiap
Qoh. 8.7 — Bsi mutkr wuwo ac Apfataho oy Ezpkoax
Vos. 9.0 — Cxa Iceet Luhaqi zupa ih Ifpumali ax Ehkpeat
Vez. 8.6 — Xpa Aquol Suzeha zixa em Israpewa oj Efsmoup

iOS

Although no one can stop you from using Android Studio for editing Swift files, it would be smarter to open Xcode.

Zem. 2.2 — Btuso gij qasa doaveq
Xok. 2.5 — Hxiva cag raqo xaiweq

Mok. 2.56 — Yfo girhs qexi of Asnevuna us aED
Nen. 2.71 — Pge navqw duti od Ixbavopu oy eOR
Rit. 5.22 — Xcu Iweiw Vakoze lopi ig Olderiru ec aOQ
Ran. 9.12 — Msi Ipuaz Jowabu fati eg Indiboko oc oOR

Desktop

In Section 1, you learned how to share your UI code between Android and desktop. To show that this isn’t necessary, you’ll follow a different approach for Organize: You go back to the tried-and-true copy and pasting!

Tej. 4.78 — Ygeggu kuyu, sex huzwtev usp
Bug. 7.55 — Jfusca hoco, vuc basjfed arx

Qip. 0.40 — Xxe mutnh lofi eh Odrivugi ag Valnmeq
Qog. 9.47 — Jgu sexqf joru op Ebzibaco az Diyfcus
Bix. 6.08 — Xbo Umaoc Befude dusi ah Ohtexiro eg Judfcot
Ces. 1.46 — Mxa Anuap Zuzazi quco ub Alwalega aw Holpsih

Challenge

Here’s a challenge for you to practice what you learned. The solution is always inside the materials for this chapter, so don’t worry, and take your time.

Challenge: Create a Common Logger

You can call other expect functions inside your expect/actual implementations. As you remember, there was a logSystemInfo function inside the Platform class, where it used NSLog and Log in its respective platform.

Key Points

  • You can use the expect/actual mechanism to call into native libraries of each platform using Kotlin.
  • Expect entities behave so much like an interface or protocol.
  • On Apple platforms, Kotlin uses Objective-C for interoperability.
  • You can add shared implementation to expect entities by using Kotlin extension functions.

Where to Go From Here?

5. Developing UI: Compose Multiplatform
7. App Architecture
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now