Kotlin Multiplatform (KMP): Architektur, interner Betrieb und gemeinsamer Code zwischen Android und iOS
Kotlin Multiplatform (KMP) ermöglicht Code-Sharing zwischen Android, iOS und anderen Plattformen, ohne allen Anwendungen eine einheitliche Architektur aufzuzwingen. Entdecken Sie dessen Architektur, Quellcode-Sets, die Rolle des Kotlin-Compilers, die Zusammenarbeit von Kotlin/JVM und Kotlin/Native, die Interoperabilität mit Swift und die Mechanismen, die es gemeinsam genutztem Code ermöglichen, mit nativen APIs zu kommunizieren.

Inhalt
- Kotlin Multiplatform (KMP): Architektur, interner Betrieb und gemeinsamer Code zwischen Android und iOS
- Einführung
- 1. Was ist Kotlin Multiplatform?
- Einfaches Beispiel
- 2. Ist KMP ein grafisches Interface-Framework?
- Mit KMP ohne gemeinsame Schnittstelle
- Mit KMP und Compose Multiplatform
- 3. Die grundlegende Architektur von Kotlin Multiplatform
- 3.1. Kompilationsziele: Ziele
- 3.2. Quellcode-Sets: Organisation von Code nach Plattformen
- 3.3. Zwischenquellen
- 3.4. Wie sammelt KMP Quellcodes?
- 4. Was unter der Haube passiert: Wie Kotlin-Code ausführbar wird
- 4.1. Schritt 1: Der Entwickler schreibt den gemeinsamen Code
- 4.2. Schritt 2: Gradle konfiguriert das Projekt
- 4.3. Schritt 3: Der Compiler analysiert den Code
- 4.4. Schritt 4: Für jedes Ziel wird Code kompiliert
- Android-Pfad
- iOS-Pfad
- 4.5. Schritt 5: Der gemeinsame Code läuft in seiner Zielumgebung
- 5. Wie greift Shared Code auf native Funktionen zu?
- 5.1. Erster Ansatz: Schnittstellen und Abhängigkeitsinjektion
- 5.2. Zweiter Ansatz: `expect` und `actual`
- 5.3. Was und `actual` was `expect` nicht tun darf
- 6. Wie kommuniziert Kotlin Multiplatform mit Swift?
- Konzeptionelles Beispiel
- Was ist, wenn das Projekt SwiftUI verwendet?
- 7. Welche Verantwortlichkeiten sollten in einer KMP-Architektur geteilt werden?
- Die Geschäftslogik
- Modelle und Anwendungsfälle
- Netzwerkzugang
- Datenpersistenz
- Jobtests
- 8. Beispiel einer Android- und iOS-Apparchitektur mit KMP
- 9. Was passiert wirklich, wenn ein Nutzer die App nutzt?
- Schritt 1: Die Schnittstelle ruft Daten ab
- Schritt 2: Die Anwendung ruft gemeinsam genutzte Logik auf
- Schritt 3: Die Netzwerkschicht führt die Abfrage aus
- Schritt 4: Der Server verarbeitet die Anfrage
- Schritt 5: Das geteilte Modul verarbeitet das Ergebnis
- Schritt 6: Die Benutzeroberfläche zeigt das Ergebnis an
- 10. Ist Kotlin Multiplatform leistungsfähiger als ein hybrides Framework?
- 11. Was sind die Vorteile und Grenzen von KMP?
- Die Vorteile
- Die Grenzen
- 12. Wann sollten Sie sich für Kotlin Multiplatform entscheiden?
- Fazit
Kotlin Multiplatform (KMP): Architektur, interner Betrieb und gemeinsamer Code zwischen Android und iOS
Einführung
In der mobilen Entwicklung beinhaltet die Wartung einer Android-App und einer iOS-App häufig die Weiterentwicklung zweier unterschiedlicher Codebasen. Dieselbe Geschäftsregel kann zweimal implementiert werden, die Verarbeitung kann sich allmählich divergieren, und Tests müssen über mehrere Plattformen hinweg reproduziert werden.
Um diese Art von Problem anzugehen, ergibt Kotlin Multiplatform, allgemein abgekürzt als KMP, vollkommen Sinn.
Entwickelt von JetBrains, ist Kotlin Multiplatform eine Technologie, die Code-Sharing über mehrere Plattformen hinweg ermöglicht, darunter Android, iOS, Desktop-Anwendungen, das Web und Serverumgebungen – je nach Zielgruppe und verwendeten Bibliotheken.
Aber bei KMP geht es nicht nur darum, Kotlin einmal zu schreiben, um es überall hinzubringen.
Sein architektonisches Interesse ist spezifischer: Es ermöglicht das Teilen von Prozessen, die möglicherweise gemeinsam sind, während die Möglichkeit erhalten bleibt, Technologien, Bibliotheken und APIs zu nutzen, die für jede Plattform spezifisch sind.
Eine Android-App kann somit Kotlin/JVM- und Android-APIs verwenden, während eine iOS-App denselben Geschäftscode in native Code kompiliert und in ihre Swift- und Apple-Umgebungen integrieren kann.
Dieser Ansatz wirft mehrere wichtige Fragen auf:
- Wie kann derselbe Kotlin-Code auf verschiedenen Plattformen funktionieren?
- Was macht der Compiler eigentlich?
- Warum nutzt geteilter Code nicht frei alle Android- oder Java-APIs?
- Wie kann eine Kotlin-Funktion von Swift aus aufgerufen werden?
- Welche Rolle spielen
commonMain,androidMainundiosMain? - Teilt KMP auch die grafische Benutzeroberfläche?
- Was passiert genau, wenn man eine Anwendung kompiliert und startet?
Um diese Fragen zu beantworten, müssen Sie KMP von seiner Architektur bis zu seinen internen Abläufen betrachten.
1. Was ist Kotlin Multiplatform?
Kotlin Multiplatform ist eine plattformübergreifende Entwicklungstechnologie, die die Wiederverwendung von Kotlin-Code über mehrere Build-Ziele hinweg ermöglicht.
Das Prinzip ist einfach: Anstatt dieselben Geschäftsregeln in jeder Anwendung systematisch neu zu schreiben, können Sie sie in einem gemeinsamen Modul platzieren.
Stellen Sie sich eine E-Commerce-App vor, die auf Android und iOS verfügbar ist.
Beide Anwendungen müssen den Gesamtpreis eines Warenkorbs berechnen, dieselben Rabattregeln anwenden, die eingegebenen Daten validieren und die Antworten eines Servers interpretieren.
Diese Behandlungen können im Allgemeinen geteilt werden, da ihre Logik nicht direkt vom Betriebssystem abhängt.
Einige Operationen sind jedoch für jede Plattform spezifisch. Das Öffnen bestimmter Systemschnittstellen, Integration mit Apple-APIs oder das Management von Android-Komponenten kann separaten Code erfordern.
KMP erlaubt es genau, diese Verantwortlichkeiten zu trennen.
Einfaches Beispiel
Stellen wir uns vor, die App muss den Preis eines Warenkorbs berechnen:
data class Product(
val name: String,
val price: Double
)
fun calculateTotal(products: List<Product>): Double {
return products.sumOf { it.price }
}Diese Funktion ist in Kotlin geschrieben und hängt nicht von einer bestimmten Android- oder Apple-API ab.
Sie kann daher in den gemeinsamen Code des Projekts aufgenommen werden.
Die gleiche Verarbeitung kann für die im Projekt deklarierten Android- und iOS-Ziele kompiliert werden. Es ist nicht erforderlich, den Algorithmus in Java oder Swift neu zu schreiben, um dasselbe Ergebnis zu erzielen.
Warnung: In einer realen Anwendung erfordert die Verwendung für Double monetäre Berechnungen Vorsicht. Eine vollständige Darstellung in Mindestgeldeinheiten oder eine geeignete Dezimalbibliothek ist im Allgemeinen vorzuziehen.
Das Beispiel veranschaulicht dennoch das grundlegende Prinzip von KMP: die Logik teilen, nicht unbedingt die gesamte Anwendung.
2. Ist KMP ein grafisches Interface-Framework?
Nein. Das ist ein wesentlicher Unterschied.
Kotlin Multiplatform ermöglicht hauptsächlich Code-Sharing. Sie bestimmt nicht von alleine, wie die grafische Benutzeroberfläche gebaut wird.
Es müssen zwischen zwei Technologien unterschieden werden.
Kotlin Multiplatform (KMP) ermöglicht Codefreigabe über mehrere Plattformen hinweg.
Compose Multiplatform (CMP) ist ein deklaratives Schnittstellen-Framework, das auch das Teilen der grafischen Schnittstelle über unterstützte Plattformen hinweg ermöglicht.
Diese Technologien können zusammen eingesetzt werden, aber sie bedeuten nicht dasselbe.
Mit KMP ohne gemeinsame Schnittstelle
Die App kann eine mit Jetpack Compose oder traditionellen Android-Ansichten entwickelte Android-Oberfläche sowie eine iOS-Oberfläche mit SwiftUI oder UIKit behalten.
Beide Schnittstellen verwenden dasselbe Kotlin-Modul für Geschäftsregeln, Validierungen, Vorlagen und bestimmte technische Verarbeitungen.
Die Architektur sieht dann wie folgt aus:
APPLICATION MOBILE
ANDROID iOS
┌─────────────┐ ┌─────────────┐
│ Interface │ │ Interface │
│ Jetpack │ │ SwiftUI │
│ Compose │ │ ou UIKit │
└──────┬──────┘ └──────┬──────┘
│ │
└─────────┬──────────┘
│
MODULE KMP PARTAGÉ
┌──────────────────────┐
│ Logique métier │
│ Validation │
│ Modèles │
│ Cas d'utilisation │
│ Accès aux données │
└──────────────────────┘Schnittstellen bleiben systemspezifisch, aber die gemeinsame Verarbeitung wird nicht dupliziert.
Mit KMP und Compose Multiplatform
Es ist außerdem möglich, einen bedeutenden Teil der Benutzeroberfläche zu teilen.
In diesem Fall werden Bildschirme und visuelle Komponenten in Kotlin mit Compose Multiplatform geschrieben und anschließend auf unterstützten Plattformen ausgelaufen.
Dies kann die Schnittstellencode-Duplizierung weiter reduzieren, beinhaltet aber weitere Überlegungen in Bezug auf Integration, Rendering, Barrierefreiheit und Benutzererlebnis.
Die Wahl hängt daher vom Projekt ab.
KMP ermöglicht das Teilen von Logik. Compose Multiplatform erlaubt außerdem das Teilen der Schnittstelle. Es ist möglich, das eine zu übernehmen, ohne unbedingt das andere zu übernehmen.
3. Die grundlegende Architektur von Kotlin Multiplatform
Um KMP zu verstehen, müssen Sie die verschiedenen Ebenen betrachten, die ein Projekt ausmachen.
Seine Architektur basiert insbesondere auf Build-Zielen, Quellcode-Sets, plattformübergreifenden Abhängigkeiten und plattformspezifischen Implementierungen.
3.1. Kompilationsziele: Ziele
Ein Ziel, oder Ziel, teilt dem Kompilierungssystem mit, für welche Plattform der Code vorbereitet werden soll.
Je nach Projekt und den verwendeten Versionen der Tools kann man Ziele wie Android/JVM, iOS, JVM, JavaScript, WebAssembly oder bestimmte Desktop-Plattformen deklarieren.
Jedes Ziel bestimmt insbesondere Folgendes:
- Das Format des zusammengestellten Ergebnisses.
- Die verfügbaren Bibliotheken und APIs.
- Kompatibilitätsbeschränkungen.
- Die erforderlichen Kompilierungsoperationen.
- Interoperabilitätsmöglichkeiten mit der Plattform.
Nehmen wir ein Projekt, das sich auf Android und iOS konzentriert.
Der Entwickler deklariert die entsprechenden Ziele in der Kotlin-Multiplattform-Konfiguration.
Der gemeinsame Code wird dann in die Kompilierung jedes Ziels integriert.
Das bedeutet nicht, dass der Compiler eine einzelne Binärdatei erstellt, die mit Android und iOS kompatibel ist. Er liefert Ergebnisse, die auf die deklarierten Ziele zugeschnitten sind.
Quellcode kann geteilt werden, aber kompilierte Artefakte unterscheiden sich je nach Plattform.
3.2. Quellcode-Sets: Organisation von Code nach Plattformen
Ein Quelltextsatz ist eine Menge von Quelldateien, die mit Build-Zielen und Abhängigkeiten verknüpft sind.
Dies ist eines der wichtigsten Konzepte der KMP.
Ein mobiles Projekt kann insbesondere folgende Quellcodes enthalten:
shared/
└── src/
├── commonMain/
├── commonTest/
├── androidMain/
├── androidUnitTest/
├── iosMain/
└── iosTest/Jedes Verzeichnis hat eine bestimmte Rolle.
'commonMain'
Es enthält Code, der dafür gedacht ist, zwischen allen kompatiblen Zielgruppen geteilt zu werden.
Es umfasst in der Regel Vorlagen, Geschäftsregeln, Anwendungsfälle, Service-Schnittstellen und Verarbeitungen, die nicht von einer plattformspezifischen API abhängen.
'commonTest'
Sie enthält gängige Tests, die an den betroffenen Zielen durchgeführt werden können.
Sie ermöglicht insbesondere die Überprüfung von Geschäftsregeln und gemeinsamen Verhaltensweisen.
'androidMain'
Es enthält den spezifischen Code für Android.
Sie können insbesondere Android-APIs und JVM-Abhängigkeiten verwenden, die mit der Projektkonfiguration kompatibel sind.
'iosMain'
Es enthält den Code, der speziell für die iOS-Plattformen des Projekts bestimmt ist.
Es ermöglicht insbesondere den Zugriff auf Apple-APIs, die über Kotlin/Native verfügbar sind.
Spezifische Testquellensätze
Sie ermöglichen es Ihnen, Tests zu schreiben, die von den Tools oder APIs abhängen, die für jede Plattform spezifisch sind.
Die Trennung zwischen Common Code und spezifischem Code ist nicht nur eine Speicherkonvention. Sie beeinflusst direkt nutzbare APIs und Abhängigkeiten, die während der Kompilierung verfügbar sind.
3.3. Zwischenquellen
In einem komplexeren Projekt betrifft das Teilen nicht zwangsläufig alle Plattformen.
Stellen Sie sich eine Behandlung vor, die bei iOS, macOS und watchOS üblich ist, aber APIs verwendet, die nur innerhalb des Apple-Ökosystems verfügbar sind.
Es wäre unpraktisch, diese Verarbeitung in jedem Quellcode zu duplizieren.
KMP erlaubt dann beispielsweise die Verwendung eines Zwischencodesatzes, appleMainum gemeinsam genutzten Code unter den relevanten Apple-Zielgruppen zu gruppieren.
Die Hierarchie wird:
commonMain
│
├── androidMain
│
└── appleMain
├── iosMain
├── macosMain
└── watchosMainDieses Diagramm ist veranschaulich: Die tatsächliche Hierarchie hängt von den konfigurierten Zielen und Quellmengen ab.
Der Vorteil besteht darin, Code auf der entsprechenden Ebene zu teilen, ohne auf allen Plattformen künstlich identischen Code aufzuzwingen.
3.4. Wie sammelt KMP Quellcodes?
Wenn ein Ziel kompiliert wird, wählt das Kompilierungssystem die Quellmengen aus, die zu diesem Ziel beitragen, wobei deren Hierarchie und Abhängigkeiten respektiert werden.
Für eine iOS-Version werden gemeinsamer Code, kompatibler Zwëschencode-Code und zielspezifischer Code berücksichtigt.
Für Android werden der gemeinsame Code und die für das Android-Ziel vorgesehenen Quellen ausgewählt.
Abhängigkeiten müssen zudem mit der Zielgruppe kompatibel sein.
So kann der Compiler überprüfen, dass eine in commonMain gespeicherte Datei nicht direkt von einer Klasse abhängt, die nur in der Android-Umgebung existiert.
Diese Organisation ermöglicht Code-Sharing und verhindert zugleich, dass bestimmte inkompatible Abhängigkeiten in den gemeinsamen Code gelangen.
4. Was unter der Haube passiert: Wie Kotlin-Code ausführbar wird
Hier wird KMP besonders interessant.
Ein Entwickler kann eine Kotlin-Funktion in einem gemeinsamen Modul schreiben, aber diese Funktion läuft auf Android und iOS nicht unbedingt auf dieselbe Weise.
Der Unterschied liegt im Kompilierungsprozess und in der Laufzeitumgebung jedes Ziels.
4.1. Schritt 1: Der Entwickler schreibt den gemeinsamen Code
Stellen Sie sich vor, das geteilte Modul enthält diese Funktion:
fun calculateDiscount(
price: Double,
percentage: Double
): Double {
return price * percentage / 100.0
}Diese Funktion hängt nicht von einer speziell für Android oder iOS spezifischen API ab.
Es kann daher für mehrere kompatible Ziele kompiliert werden.
Der Entwickler schreibt die Regel nur einmal.
4.2. Schritt 2: Gradle konfiguriert das Projekt
In einem typischen KMP-Projekt orchestriert Gradle den Bauprozess.
Die Projektkonfiguration umfasst insbesondere Folgendes:
- Die verwendeten Plugins.
- Erstelle Ziele.
- Die Quellen.
- Die Nebengebäude.
- Bauoptionen.
- Bau- und Testaufgaben.
Wenn Gradle gebeten wird, die Android-App oder das iOS-Framework zu entwickeln, übernimmt er die notwendigen Aufgaben, um die entsprechenden Artefakte vorzubereiten.
Es verwandelt Kotlin-Code nicht selbst in Maschinenanweisungen. Es koordiniert Kompilierungswerkzeuge und Konstruktionsschritte.
4.3. Schritt 3: Der Compiler analysiert den Code
Der Kotlin-Compiler analysiert die Quelldateien, prüft Syntax und Typen und bereitet dann eine interne Darstellung des Programms für die nächsten Schritte vor.
Es überprüft außerdem die Einschränkungen im Zusammenhang mit plattformübergreifenden Ansprüchen und APIs, die von jedem Quellsatz zugänglich sind.
Zum Beispiel ist dieser Code nicht geeignet für commonMain :
import java.io.File
fun readFile(): String {
return File("message.txt").readText()
}Der Grund ist einfach: java.io.File Es gehört zur Java/JVM-Umgebung. Es ist nicht auf allen Kotlin-Multiplattform-Zielgruppen verfügbar, insbesondere nicht auf nativen iOS-Zielgruppen.
Wenn diese Operation gebräuchlich sein soll, muss eine geeignete Abstraktion oder plattformübergreifende Bibliothek verwendet werden. Wenn sie plattformspezifisch ist, muss sie im entsprechenden Quellcode implementiert werden.
Diese Überprüfung ist einer der grundlegenden Mechanismen der KMP.
4.4. Schritt 4: Für jedes Ziel wird Code kompiliert
Der Compiler verwendet ein Backend, das an das deklarierte Ziel angepasst ist.
Für Android wird Kotlin-Code in der Regel in JVM-Bytecode kompiliert und anschließend in den Android-Build-Prozess integriert.
Für iOS kompiliert Kotlin/Native Kotlin-Code in native Binärdateien mithilfe einer LLVM-basierten Build-Kette.
Die beiden Wege sind unterschiedlich.
Android-Pfad
Code Kotlin partagé
↓
Compilation Kotlin/JVM
↓
Bytecode JVM (.class)
↓
Construction de l'application Android
↓
DEX / APK ou App Bundle
↓
ART sur l'appareil AndroidDieses Diagramm zeigt den allgemeinen Verlauf einer Android-Anwendung, die Kotlin/JVM verwendet.
Der von Kotlin erzeugte JVM-Bytecode wird transformiert und in das ausführbare Android-Format integriert. Auf dem Gerät führt die Android Runtime (ART) den Code gemäß den Mechanismen der Plattform aus.
Daher sollte JVM-Bytecode nicht mit dem in Android-Anwendungen verwendeten DEX-Format verwechselt werden.
iOS-Pfad
Code Kotlin partagé
↓
Compilateur Kotlin
↓
Backend Kotlin/Native
↓
Chaîne de compilation LLVM
↓
Binaire natif / framework
↓
Intégration dans l'application iOS
↓
Exécution sur iPhone ou iPadFür iOS wird der Kotlin-Code in native Code kompiliert, der an Apples Zielgruppe angepasst ist.
Es erfordert keine JVM-Virtual-Maschine, um den gemeinsamen Kotlin-Code auszuführen.
Das Ergebnis kann insbesondere als natives Framework in das iOS-Projekt integriert werden.
Es ist zu beachten, dass die genauen Artefakte und Schritte vom Ziel, der Konfiguration und der verwendeten Baukette abhängen.
4.5. Schritt 5: Der gemeinsame Code läuft in seiner Zielumgebung
Auf Android funktioniert Shared Code in der Android/JVM-Umgebung.
Auf iOS läuft es als native Code, der von Kotlin/Native erstellt wurde.
In beiden Fällen kann die Geschäftslogik identisch sein, aber ihre technische Integration ist nicht dieselbe.
Genau das ermöglicht es KMP, Code-Wiederverwendung mit Plattformintegration in Einklang zu bringen.
KMP führt nicht einfach ein universelles Programm in einer gemeinsamen Schicht aus: Es passt den gemeinsamen Code an deklarierte Kompilierungsziele an.
5. Wie greift Shared Code auf native Funktionen zu?
Common Code kann nicht alle auf Android oder iOS verfügbaren APIs direkt nutzen.
Nehmen wir ein einfaches Bedürfnis: gerätsspezifische Informationen abzurufen.
Auf Android können diese Informationen mit einer Android-API abgerufen werden. Auf iOS ist möglicherweise eine Apple-API erforderlich.
KMP bietet mehrere Möglichkeiten, diesen Unterschied zu organisieren.
5.1. Erster Ansatz: Schnittstellen und Abhängigkeitsinjektion
Dies ist oft der flexibelste Ansatz.
Der gemeinsame Code definiert eine Benutzeroberfläche:
interface DeviceInfoProvider {
fun getDeviceName(): String
}Der gemeinsame Code kann diese Schnittstelle dann nutzen, ohne die technische Implementierung zu kennen.
Jede Plattform bietet ihre eigene Implementierung.
Zum Beispiel kann Android bestimmte Android-APIs nutzen, während iOS die entsprechenden Apple-APIs nutzen kann.
Eine Implementierung wird dann dem benötigten Code bereitgestellt, zum Beispiel durch das Einfügen von Abhängigkeiten.
Dieser Ansatz erleichtert auch das Testen, da eine Mock-Implementierung bereitgestellt werden kann, ohne auf ein echtes Gerät zugreifen zu müssen.
5.2. Zweiter Ansatz: `expect` und `actual`
Kotlin Multiplatform verfügt außerdem über einen Mechanismus, um eine erwartete Funktion im gemeinsamen Code zu deklarieren und eine spezifische Implementierung für die Zielgruppe bereitzustellen.
Dieser Mechanismus beruht auf den Schlüsselwörtern expect und actual.
In commonMain :
expect fun getPlatformName(): StringDiese Aussage weist darauf hin, dass für Zielgruppen, die dieses Feature verwenden, eine geeignete Implementierung verfügbar sein muss.
In androidMain :
actual fun getPlatformName(): String {
return "Android"
}In iosMain :
actual fun getPlatformName(): String {
return "iOS"
}Der gemeinsame Code kann dann die Funktion aufrufen:
fun greeting(): String {
return "Bonjour depuis ${getPlatformName()}"
}Der Geschäftscode verwendet nur eine Funktion, aber die ausgewählte Implementierung hängt vom kompilierten Ziel ab.
Dies ist keine Zauberfunktion, die das System bei jedem Aufruf willkürlich erkennt. Die Übereinstimmung zwischen erwarteten Anweisungen und Implementierungen wird im Rahmen der plattformübergreifenden Kompilierung hergestellt.
Dieser Ansatz ist für bestimmte Plattformunterschiede nützlich. Er sollte jedoch nicht systematisch eingesetzt werden: Eine klassische Schnittstelle reicht oft aus und bietet mehr Flexibilität bei der Verwaltung mehrerer Implementierungen.
5.3. Was und `actual` was `expect` nicht tun darf
Diese Mechanismen machen nicht automatisch alle Android- oder Apple-APIs in commonMainverfügbar.
Wenn eine Anwendung die Kamera, Bluetooth oder eine bestimmte System-API nutzen soll, muss sie stets über eine geeignete Implementierung, eine kompatible Bibliothek oder einen geeigneten Interoperabilitätsmechanismus verfügen.
expect und actual ermöglichen die Organisation des gemeinsamen Vertrags und seiner Implementierungen. Sie ersetzen weder System-APIs noch die erforderlichen Berechtigungen.
6. Wie kommuniziert Kotlin Multiplatform mit Swift?
Diese Frage ist besonders wichtig bei der Entwicklung einer iOS-App.
Kotlin und Swift sind zwei verschiedene Sprachen, die mit unterschiedlichen Kompilierungsumgebungen verbunden sind.
Um gemeinsam genutzten Kotlin-Code in einer iOS-App zu verwenden, kann das Projekt ein natives Framework erstellen, das die notwendigen Kotlin-Anweisungen bereitstellt.
Das iOS-Projekt kann dieses Framework dann integrieren und die daraus freigegebenen Elemente aufrufen.
Der allgemeine Prozess verläuft wie folgt:
- Der Entwickler schreibt den gemeinsamen Code in Kotlin.
- Kotlin/Native kompiliert diesen Code für das Apple-Ziel.
- Der Build-Prozess erzeugt ein Framework oder ein anderes native Artefakt, das für Integration geeignet ist.
- Das iOS-Projekt verweist auf dieses Artefakt.
- Swift ruft die vom Framework zugänglichen APIs auf.
Interoperabilität basiert auf nativen Mechanismen, die vom Apple-Ökosystem bereitgestellt werden, insbesondere den Objective-C-Schnittstellen, die verwendet werden, um das Kotlin-Framework für Swift-Projekte zugänglich zu machen.
Es sollte jedoch nicht davon ausgehen, dass jede Kotlin-Deklaration automatisch zu einer vollkommen idiomatischen Swift-API wird. Die Sichtbarkeit von Deklarationen, exponierten Typen und API-Darstellung muss berücksichtigt werden.
Konzeptionelles Beispiel
Das gemeinsame Modul definiert:
class PriceCalculator {
fun calculate(price: Double, tax: Double): Double {
return price * (1.0 + tax / 100.0)
}
}Sobald das Modul kompiliert und in das iOS-Projekt integriert ist, kann Swift den vom Framework bereitgestellten Typ verwenden, um die Berechnung durchzuführen.
Der Vorteil ist, dass die Berechnungsregel in Kotlin beibehalten wird, während die Benutzeroberfläche und der Rest der iOS-App weiterhin in Swift geschrieben bleiben können.
Der genaue Name der über Swift zugänglichen Symbole hängt von der Rahmenkonfiguration und den Interoperabilitätsregeln ab.
Was ist, wenn das Projekt SwiftUI verwendet?
Das ist durchaus möglich.
SwiftUI kann weiterhin für die Benutzeroberfläche verantwortlich sein. Der Swift-Code ruft dann das gemeinsam genutzte Modul auf, um die Geschäftsverarbeitung durchzuführen.
Zum Beispiel kann ein SwiftUI-Bildschirm vom Benutzer eingegebene Produkte abrufen, den Kotlin-Rechner aufrufen und die erhaltene Gesamtsumme anzeigen.
Die Benutzeroberfläche bleibt native im Apple-Ökosystem, während die Rechenlogik geteilt wird.
Dies ist eines der interessantesten Architekturmodelle von KMP: Code zu teilen, der davon profitiert, zu teilen, ohne auf allen Plattformen eine einzige Benutzeroberfläche aufzuzwingen.
7. Welche Verantwortlichkeiten sollten in einer KMP-Architektur geteilt werden?
Eine gute KMP-Architektur besteht nicht darin, alle Dateien in ein gemeinsames Modul zu verschieben.
Es ist notwendig festzustellen, welche Verantwortlichkeiten tatsächlich gebündelt werden können.
Für eine mobile App sind die folgenden oft gute Kandidaten.
Die Geschäftslogik
Berechnungsregeln, Validierungen, Preisrichtlinien und Verwaltungsregeln können geteilt werden, wenn sie nicht von einer Plattform abhängen.
Dies hilft, Unterschiede zwischen den Android- und iOS-Versionen zu vermeiden.
Modelle und Anwendungsfälle
Geschäftsobjekte, operative Ergebnisse und Anwendungsfälle können häufig vorkommen.
Eine Commerce-Anwendung kann zum Beispiel die Regeln teilen, die bestimmen, ob ein Warenkorb validiert werden kann.
Netzwerkzugang
HTTP-Anfragen, Datenmodelle und bestimmte Serialisierungsoperationen können mit Bibliotheken geteilt werden, die mit den relevanten Zielen kompatibel sind.
Ktor ist ein Beispiel für eine plattformübergreifende Bibliothek zum Aufbau von Netzwerkklienten.
Allerdings sollte Common Code nicht als automatisch kompatibel mit einer Java-Bibliothek betrachtet werden. Abhängigkeiten müssen die Ziele unterstützen, für die das Modul gedacht ist.
Datenpersistenz
Es ist auch möglich, einen Teil des Zugangs zu lokalen Daten mit geeigneten plattformübergreifenden Bibliotheken zu teilen.
Allerdings müssen Bibliothekskompatibilität, Speicherunterschiede und Einschränkungen jedes Systems bewertet werden.
Jobtests
Common Rule-Tests können nur einmal geschrieben und auf den entsprechenden Zielen durchgeführt werden.
Dies erleichtert die Erkennung von Abweichungen und stärkt die Zuverlässigkeit des gemeinsamen Codes.
Andererseits müssen Integrationstests mit Kamera, Benachrichtigungen oder System-APIs Verhaltensweisen berücksichtigen, die für jede Plattform spezifisch sind.
8. Beispiel einer Android- und iOS-Apparchitektur mit KMP
Stellen Sie sich vor, wir entwickeln eine Messaging-App.
Das Ziel ist es, Geschäftsregeln und Netzwerkaustausche zu teilen und gleichzeitig Schnittstellen zu erhalten, die für Android und iOS angepasst sind.
Eine mögliche Architektur wäre:
APPLICATION MOBILE
│
┌─────────────┴─────────────┐
│ │
ANDROID iOS
│ │
Jetpack Compose SwiftUI
│ │
└─────────────┬─────────────┘
│
MODULE KMP PARTAGÉ
│
┌─────────────┴─────────────┐
│ │
Logique métier Couche données
│ │
Cas d'utilisation Client HTTP
Validation Sérialisation
Modèles Repository
│ │
└─────────────┬─────────────┘
│
API distanteIn dieser Architektur:
- Android behält seine eigene, Android-spezifische Benutzeroberfläche und Integration.
- iOS behält seine Apple-spezifische Benutzeroberfläche und Integration.
- Das KMP-Modul zentralisiert gemeinsame Regeln.
- Die Netzwerkebene bündelt kompatible Operationen.
- Der Server behält die Verantwortung für die Daten und die Verarbeitung, die ihm gehören.
Es sei angemerkt, dass ein solches Vorhaben eine architektonische Möglichkeit ist und keine von KMP auferlegte Struktur.
Ein Projekt kann mehr Komponenten teilen, einschließlich der grafischen Oberfläche mit Compose Multiplatform, oder im Gegenteil, das gemeinsame Modul auf einige Geschäftsregeln beschränken.
Das Wichtigste ist, die Verantwortlichkeiten jeder Schicht klar zu definieren.
9. Was passiert wirklich, wenn ein Nutzer die App nutzt?
Um zu verstehen, wie es über die Kompilierung hinaus funktioniert, nehmen wir ein Beispiel für eine Verbindung zu einer Anwendung.
Der Benutzer gibt seine E-Mail-Adresse und sein Passwort ein und drückt dann die Anmeldetaste.
Schritt 1: Die Schnittstelle ruft Daten ab
Auf Android kann der Bildschirm mit Jetpack Compose entwickelt werden.
Auf iOS kann es mit SwiftUI entwickelt werden.
Jede Schnittstelle sammelt die eingegebenen Informationen und löst die Verbindungsaktion aus.
Schritt 2: Die Anwendung ruft gemeinsam genutzte Logik auf
Die Schnittstelle überträgt die Daten an die für die Verbindung zuständige Komponente.
Diese Komponente kann im KMP-Modul in Kotlin geschrieben werden.
Sie wenden gemeinsame Validierungen an, bereiten den Vorgang vor und koordinieren den Datenzugriff.
Schritt 3: Die Netzwerkschicht führt die Abfrage aus
Wenn das gemeinsame Modul eine plattformübergreifende Bibliothek wie KTOR verwendet, kann es eine HTTP-Anfrage an den Server senden.
Die verwendete Netzwerk-Engine hängt von der Plattform und der Konfiguration des Clients ab.
Der Handelskodex kann auch dann gängig bleiben, wenn die unter der Haube verwendeten technischen Mechanismen unterschiedlich sind.
Schritt 4: Der Server verarbeitet die Anfrage
Der Server überprüft die Informationen gemäß seinen Sicherheitsregeln und gibt ein Ergebnis zurück.
Clientseitige Validierung verbessert das Benutzererlebnis, ersetzt aber niemals serverseitige Validierung.
Schritt 5: Das geteilte Modul verarbeitet das Ergebnis
Kotlin-Code interpretiert die Antwort, transformiert die Daten und stellt ein Ergebnis der Anwendung offen.
Gemeinsame Regeln können somit zwischen Android und iOS einheitlich bleiben.
Schritt 6: Die Benutzeroberfläche zeigt das Ergebnis an
Android und iOS präsentieren das Ergebnis mit ihren jeweiligen Komponenten.
Der Nutzer kann somit von einer auf jede Plattform zugeschnittenen Erfahrung profitieren, selbst wenn ein Teil der Verarbeitung nur einmal geschrieben wurde.
Dieses Beispiel veranschaulicht den Wert von KMP: Behandlungen zu teilen, ohne alle Schichten zu zwingen, identisch zu sein.
10. Ist Kotlin Multiplatform leistungsfähiger als ein hybrides Framework?
Mehrere Aspekte müssen unterschieden werden: Ausführungszeit, Systemzugriff, Schnittstellenrendering und Entwicklungsgeschwindigkeit.
KMP ermöglicht das Kompilieren von geteiltem Code entsprechend den Mechanismen der Zielplattform. Auf Android integriert sich Kotlin/JVM-Code in die Android-Umgebung. Auf iOS erzeugt Kotlin/Native native Code.
Diese Architektur vermeidet die Notwendigkeit, sämtliche gemeinsame Logik in einer Java-Virtual-Maschine auf iOS auszuführen.
Das bedeutet jedoch nicht, dass KMP automatisch schneller ist als alle hybriden oder plattformübergreifenden Frameworks.
Die Leistung hängt insbesondere von Folgendem ab:
- Vom verwendeten Algorithmus.
- Speicherverwaltung.
- Netzwerk- und Festplattenzugriff.
- Verwendete Bibliotheken.
- Anwendungsarchitektur.
- Die Art und Weise, wie die Benutzeroberfläche dargestellt wird.
- Eigenschaften der Zielgeräte.
KMP sollte auch von einem Framework unterschieden werden, das eine plattformübergreifende grafische Oberfläche bereitstellt. Wenn Compose Multiplatform verwendet wird, sind Rendering und Interface-Integration eine separate Angelegenheit von der Kompilierung von Geschäftscode.
Der wichtigste architektonische Vorteil von KMP ist daher die Möglichkeit, Code zu teilen und gleichzeitig plattformgerechte Integration beizubehalten. Die Leistung muss am Schnitt der tatsächlichen Abläufe des Projekts gemessen werden.
11. Was sind die Vorteile und Grenzen von KMP?
Die Vorteile
Verringerung der Codeduplizierung
Geschäftsregeln und gängige Behandlungen müssen nicht zwangsläufig für jede Plattform neu geschrieben werden.
Funktionale Konsistenz
Android- und iOS-Apps können dieselben Validierungsregeln und Geschäftsalgorithmen verwenden.
Erhaltung einheimischer Technologien
Teams können Jetpack Compose oder Android-Ansichten auf Android sowie SwiftUI oder UIKit auf iOS behalten.
Schrittweise Integration
Es ist möglich, KMP in ein bestehendes Projekt einzuführen, beginnend mit einem begrenzten Modul, ohne die gesamte Anwendung sofort neu zu schreiben.
Gängige Tests
Gemeinsame Geschäftsregeln können über die relevanten Zielgruppen hinweg konsistent getestet werden.
Architektonische Flexibilität
Das Projekt kann nur Elemente teilen, die echten Wert bieten, ohne eine völlig gemeinsame Codebasis aufzuzwingen.
Die Grenzen
Komplexität der Konstruktion
Grad-Konfiguration, Zielvorgaben, Abhängigkeiten und Build-Ketten können das Projekt komplexer machen als eine Anwendung auf einer einzigen Plattform.
Interoperabilität mit iOS
Die Integration zwischen Kotlin/Native und Swift erfordert das Verständnis der API-Expositionsregeln und der Einschränkungen des Apple-Ökosystems.
Bibliotheksverfügbarkeit
Nicht alle Kotlin- oder Java-Bibliotheken sind mit allen KMP-Zielen kompatibel.
Systemspezifische Verwaltung
Einige Funktionen erfordern weiterhin Code, der speziell für Android oder iOS bestimmt ist.
Nichtautomatische Schnittstellenfreigabe
KMP bedeutet nicht, dass Bildschirme automatisch geteilt werden. Dafür müssen Sie eine plattformübergreifende Schnittstellenlösung wie Compose Multiplatform einsetzen.
Architektonische Kompromisse
Das Teilen von Code ist nicht immer vorteilhaft. Eine Schnittstelle, ein Feature oder eine Komponente, die stark vom System abhängt, kann leichter zu warten sein, wenn sie plattformspezifisch bleibt.
12. Wann sollten Sie sich für Kotlin Multiplatform entscheiden?
KMP ist besonders interessant, wenn ein Team einen Teil der Logik zwischen Android und iOS teilen möchte und dabei die spezifischen Technologien für jede Plattform beherrscht.
Es eignet sich besonders gut für Projekte, die bereits native Anwendungen haben und die Duplizierung von Geschäftsprozessen reduzieren möchten.
Es kann auch an eine neue Anwendung angepasst werden, wenn Teams Geschäftsregeln, Netzwerkzugriffe und bestimmte technische Komponenten zentralisieren möchten.
Wenn das Hauptziel hingegen darin besteht, eine einheitliche Schnittstelle für mehrere Plattformen zu entwickeln, sollten Compose Multiplatform und andere plattformübergreifende Schnittstellen-Frameworks ebenfalls evaluiert werden.
Die Wahl hängt daher vom gewünschten Maß an Sharing ab.
Ein Team kann entscheiden, nur die Geschäftsvorlagen und -regeln zu teilen und KMP dann schrittweise auf Netzwerkzugriff, Persistenz und andere Komponenten auszuweiten.
Dieser Fortschritt ermöglicht es, die tatsächlichen Vorteile zu messen, bevor die Komplexität des Projekts erhöht wird.
Fazit
Kotlin Multiplatform ist weit mehr als nur eine Möglichkeit, wiederverwendbaren Kotlin-Code zu schreiben. Es ist eine Technologie, die es ermöglicht, Code-Sharing nach Plattform zu organisieren, gemeinsame Komponenten für verschiedene Umgebungen zu kompilieren und den Zugriff auf APIs zu behalten, die für jedes System spezifisch sind.
Seine Architektur basiert insbesondere auf Kompilierungszielen, Quellcode-Sets, kompatiblen Abhängigkeiten, Interoperabilitätsmechanismen und, falls nötig, spezifischen Implementierungen.
Unter der Haube folgt Shared Code einem Build-Pfad, der an jede Plattform angepasst ist: Kotlin/JVM für die Android/JVM-Umgebung und Kotlin/Native für native Zielgruppen wie iOS.
Gemeinsamer Code wird daher nicht zu einer universellen Binärcode. Er ist in Artefakte integriert, die an die Zielplattformen angepasst sind.
Dieser Ansatz ermöglicht die Kombination von Code-Wiederverwendung, architektonischer Flexibilität und native Integration.
Letztlich besteht die Stärke von Kotlin Multiplatform nicht darin, alle Unterschiede zwischen Android und iOS zu beseitigen. Es liegt darin, das, was geteilt werden kann, intelligent zu teilen und dabei die Freiheit zu bewahren, die Besonderheiten jeder Plattform auszunutzen.
