Skip to Content
Folienvorschau
Dauer
30 Minuten
Ziel
Die Android-Wetter-App in KMP zum Laufen bringen

Themen

  • Abhängigkeiten in commonMain
  • Code aus der Android-App kopieren
  • Was plattformspezifisch ist
  • Kompiliert heißt nicht läuft
Klicken für Tastaturnavigation · F für Vollbild
Präsentation starten · 30 Minuten ↗

Wetter-App übernehmen

Ausgangspunkt ist der Tag schritt-10 der Android-App: Städteliste, Wetter-Screen, Navigation 3 und Open-Meteo. Den Code kopieren wir in das neue KMP-Projekt und passen nur an, was außerhalb von Android nicht funktioniert.

Der Code liegt auf GitHub: behrends/WeatherKMPTIF24 , Tags kmp-00 (Projekt aus dem Wizard) bis kmp-04.

Abhängigkeiten

WofürBibliothekSource Set
Navigation 3org.jetbrains.androidx.navigation3:navigation3-uicommonMain
Serializationkotlinx-serialization-core + PlugincommonMain
HTTPKtor Client, Content Negotiation, JSONcommonMain
HTTP-Enginektor-client-okhttp / ktor-client-darwinandroidMain / iosMain
ViewModel, Lifecycleschon vom Wizard eingebundencommonMain

Navigation 3 und Lifecycle kommen in KMP von JetBrains (org.jetbrains.androidx…), nicht direkt von Google. Die Versionen können deshalb etwas hinter denen für Android liegen.

In gradle/libs.versions.toml kommen Zeilen in drei Abschnitte, jeweils ans Ende:

gradle/libs.versions.toml
[versions] # ... navigation3 = "1.1.2" kotlinxSerialization = "1.11.0" ktor = "3.6.0" [libraries] # ... navigation3-ui = { module = "org.jetbrains.androidx.navigation3:navigation3-ui", version.ref = "navigation3" } kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinxSerialization" } ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" } ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" } ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" } ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" } ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" } [plugins] # ... kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

Die Abhängigkeiten kommen in das Modul shared, getrennt nach Source Set. Den Block iosMain.dependencies gibt es noch nicht, er kommt neu hinzu:

shared/build.gradle.kts
plugins { // ... bisherige Plugins alias(libs.plugins.kotlinSerialization) } kotlin { // ... sourceSets { androidMain.dependencies { // ... bisherige Einträge implementation(libs.ktor.client.okhttp) } iosMain.dependencies { implementation(libs.ktor.client.darwin) } commonMain.dependencies { // ... bisherige Einträge implementation(libs.navigation3.ui) implementation(libs.kotlinx.serialization.core) implementation(libs.ktor.client.core) implementation(libs.ktor.client.content.negotiation) implementation(libs.ktor.serialization.kotlinx.json) } // ... } }

Das Plugin außerdem in der build.gradle.kts im Projektordner mit apply false eintragen:

build.gradle.kts
plugins { // ... bisherige Plugins alias(libs.plugins.kotlinSerialization) apply false }

Die INTERNET-Permission kommt wie in der Android-App ins Manifest, hier im Modul androidApp, direkt unter dem öffnenden <manifest …>-Tag:

androidApp/src/main/AndroidManifest.xml
<uses-permission android:name="android.permission.INTERNET" />

Danach Sync Now.

Code: kmp-01 · Änderungen 

Code kopieren

  1. model/, data/ und ui/ (mit ui/theme) aus schritt-10 nach shared/src/commonMain/kotlin/… kopieren
  2. Paketnamen in package und Imports ersetzen (weatherandroidtif24 → weatherkmptif24)
  3. App() zeigt die Wetter-App
App.kt
@Composable fun App() { WeatherAndroidTIF24Theme { WeatherApp() } }

Quelle sind die Ordner unter app/src/main/java/com/example/weatherandroidtif24/ der Android-App (Tag schritt-10), Ziel ist shared/src/commonMain/kotlin/com/example/weatherkmptif24/. Pfade wie ui/WeatherApp.kt beziehen sich ab hier auf diesen Zielordner. MainActivity.kt wird nicht kopiert; das Modul androidApp hat seine eigene.

Paketnamen und Imports lassen sich in Android Studio auf einmal ersetzen: Edit → Find → Replace in Files. Die Paketnamen hier gelten für ein Projekt namens WeatherKMPTIF24 (Paket com.example.weatherkmptif24); bei einem anderen Namen entsprechend anpassen.

Den Beispielcode des Templates brauchen wir nicht mehr. Diese Dateien löschen:

  • shared/src/commonMain/kotlin/com/example/weatherkmptif24/Greeting.kt, GreetingUtil.kt und Platform.kt
  • shared/src/androidMain/kotlin/com/example/weatherkmptif24/Platform.android.kt
  • shared/src/iosMain/kotlin/com/example/weatherkmptif24/Platform.ios.kt
  • shared/src/commonMain/composeResources/drawable/compose-multiplatform.xml

App.kt ersetzt den Inhalt aus dem Template vollständig:

App.kt
package com.example.weatherkmptif24 import androidx.compose.runtime.Composable import com.example.weatherkmptif24.ui.WeatherApp import com.example.weatherkmptif24.ui.theme.WeatherAndroidTIF24Theme @Composable fun App() { WeatherAndroidTIF24Theme { WeatherApp() } }

Das Theme heißt weiterhin WeatherAndroidTIF24Theme. Wir benennen es bewusst nicht um, damit die Änderungen in den nächsten Schritten nur das zeigen, was für KMP nötig ist.

Dieser Zwischenstand kompiliert für iOS absichtlich nicht. Die Fehler zeigen, was nur unter Android oder auf der JVM funktioniert. Fehlerliste (auch unter Windows und Linux): ./gradlew :shared:compileCommonMainKotlinMetadata --continue

Für Android kompiliert der Code dagegen noch, weil dort die Android- und JVM-APIs zur Verfügung stehen. Deshalb diesen Befehl nehmen: Er prüft den gemeinsamen Code ohne Bezug zu einer Plattform. Android Studio markiert dieselben Fehler auch im Editor.

Code: kmp-02 · Änderungen 

Was nicht mehr kompiliert

Alles, was es nur unter Android oder auf der JVM gibt:

StelleErsatz
HttpClient(OkHttp)HttpClient { … }, Engine pro Plattform
java.io.IOExceptionkotlinx.io.IOException
"%.2f".format(…)String-Template
Dynamic Color im Themefeste Farben
Preview mit uiModeTheme mit darkTheme = true

Dazu kommt ein Fehler bei rememberNavBackStack, siehe nächster Abschnitt.

Die meisten Änderungen sind Einzeiler. Für IOException gibt es mit kotlinx-io einen Ersatz für alle Plattformen; Ktor bringt die Bibliothek schon mit, es ändert sich nur der Import:

data/FakeWeatherRepository.kt
import kotlinx.io.IOException // statt java.io.IOException

Ohne Engine nimmt Ktor die, die für die Plattform eingebunden ist. Der Import von OkHttp entfällt:

data/api/HttpClient.kt
package com.example.weatherkmptif24.data.api import io.ktor.client.HttpClient import io.ktor.client.plugins.contentnegotiation.ContentNegotiation import io.ktor.serialization.kotlinx.json.json import kotlinx.serialization.json.Json // Ein HttpClient für die ganze App. // Ohne Angabe der Engine nimmt Ktor die der Plattform: OkHttp (Android), Darwin (iOS) val httpClient = HttpClient { expectSuccess = true // HTTP-Fehler (4xx, 5xx) als Exception werfen install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) } }

String.format gibt es in Common Kotlin nicht. Die Koordinaten stehen deshalb ungerundet in der Liste:

ui/CityListScreen.kt
Text(text = "${city.latitude}° N, ${city.longitude}° O")

Im Theme entfällt Dynamic Color (Farben aus dem Hintergrundbild, ab Android 12), mit dem Parameter dynamicColor und den Imports aus android.*:

Code: ui/theme/Theme.kt (kmp-03)

ui/theme/Theme.kt
package com.example.weatherkmptif24.ui.theme import androidx.compose.foundation.isSystemInDarkTheme import androidx.compose.material3.MaterialTheme import androidx.compose.material3.darkColorScheme import androidx.compose.material3.lightColorScheme import androidx.compose.runtime.Composable private val DarkColorScheme = darkColorScheme( primary = Purple80, secondary = PurpleGrey80, tertiary = Pink80 ) private val LightColorScheme = lightColorScheme( primary = Purple40, secondary = PurpleGrey40, tertiary = Pink40 /* Other default colors to override background = Color(0xFFFFFBFE), surface = Color(0xFFFFFBFE), onPrimary = Color.White, onSecondary = Color.White, onTertiary = Color.White, onBackground = Color(0xFF1C1B1F), onSurface = Color(0xFF1C1B1F), */ ) @Composable fun WeatherAndroidTIF24Theme( darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit ) { // Dynamic Color gibt es nur unter Android, deshalb hier feste Farben val colorScheme = if (darkTheme) DarkColorScheme else LightColorScheme MaterialTheme( colorScheme = colorScheme, typography = Typography, content = content ) }

In ui/WeatherScreen.kt verwendet die Dark-Mode-Preview Configuration.UI_MODE_NIGHT_YES aus android.content.res. Die zweite @Preview-Zeile an WeatherContentPreview und der Import von Configuration entfallen; stattdessen kommt eine eigene Preview dazu, direkt unter WeatherContentPreview:

ui/WeatherScreen.kt
// uiMode gibt es nur unter Android, deshalb das Theme direkt auf dunkel stellen @Preview(showBackground = true, name = "Dark Mode") @Composable fun WeatherContentDarkPreview() { val city = fakeCities.first() WeatherAndroidTIF24Theme(darkTheme = true) { WeatherContent( city = city, uiState = WeatherUiState.Success(city, fakeCurrentWeather.getValue(city.name)), ) } }
ui/WeatherApp.kt
private val navConfig = SavedStateConfiguration { serializersModule = SerializersModule { polymorphic(NavKey::class) { subclass(CityList::class, CityList.serializer()) subclass(CityWeather::class, CityWeather.serializer()) } } } val backStack = rememberNavBackStack(navConfig, CityList)

Ohne diese Konfiguration kompiliert rememberNavBackStack(CityList) in commonMain nicht. Der Back Stack wird gespeichert, damit er Drehen und Prozessende übersteht. Unter Android findet die Bibliothek per Reflection selbst heraus, welche Routen es gibt. Unter iOS gibt es keine Reflection, deshalb melden wir alle Routen ausdrücklich an. Neue Routen müssen hier ergänzt werden.

navConfig steht in ui/WeatherApp.kt zwischen den Routen und WeatherApp(). Die ganze Datei mit den neuen Imports:

Code: ui/WeatherApp.kt (kmp-03)

ui/WeatherApp.kt
package com.example.weatherkmptif24.ui import androidx.compose.runtime.Composable import androidx.lifecycle.viewmodel.compose.viewModel import androidx.navigation3.runtime.NavKey import androidx.navigation3.runtime.entryProvider import androidx.navigation3.runtime.rememberNavBackStack import androidx.navigation3.ui.NavDisplay import androidx.savedstate.serialization.SavedStateConfiguration import com.example.weatherkmptif24.data.fakeCities import com.example.weatherkmptif24.model.City import kotlinx.serialization.Serializable import kotlinx.serialization.modules.SerializersModule import kotlinx.serialization.modules.polymorphic // Routen: jeder Screen ist ein Typ, Argumente sind Properties @Serializable data object CityList : NavKey @Serializable data class CityWeather(val city: City) : NavKey // iOS kennt keine Reflection: alle Routen müssen hier angemeldet werden, // damit der Back Stack gespeichert und wiederhergestellt werden kann private val navConfig = SavedStateConfiguration { serializersModule = SerializersModule { polymorphic(NavKey::class) { subclass(CityList::class, CityList.serializer()) subclass(CityWeather::class, CityWeather.serializer()) } } } @Composable fun WeatherApp() { // Der Back Stack ist eine Liste: Navigieren = Element hinzufügen oder entfernen val backStack = rememberNavBackStack(navConfig, CityList) // Ohne Decorator ist das ViewModel an die Activity gebunden val weatherViewModel: WeatherViewModel = viewModel() NavDisplay( backStack = backStack, onBack = { backStack.removeLastOrNull() }, entryProvider = entryProvider { entry<CityList> { CityListScreen( cities = fakeCities, onCityClick = { city -> weatherViewModel.loadWeather(city) backStack.add(CityWeather(city)) }, ) } entry<CityWeather> { key -> WeatherScreen( city = key.city, viewModel = weatherViewModel, ) } }, ) }

Zurück geht es unter iOS ohne weiteren Code: NavDisplay reagiert auf das Wischen vom linken Bildschirmrand, so wie es iOS-Apps gewohnt sind.

Code: kmp-03 · Änderungen 

Kompiliert, stürzt aber ab

Unter iOS stürzt die App beim Start ab:

UnsupportedOperationException: `Factory.create(String, CreationExtras)` is not implemented.
// WeatherApp val weatherViewModel = viewModel { WeatherViewModel() } // WeatherScreen (Default-Parameter) viewModel: WeatherViewModel = viewModel { WeatherViewModel() },

Auch hier fehlt Reflection: viewModel() ohne Parameter erzeugt das ViewModel unter Android per Reflection. Unter iOS kompiliert der Aufruf zwar, wirft aber zur Laufzeit eine Exception. Mit dem Initializer { WeatherViewModel() } steht im Code, wie das ViewModel erzeugt wird.

Dieselbe Änderung steht auch beim Default-Parameter von WeatherScreen. Dort stürzt es nie ab, weil WeatherApp das ViewModel immer übergibt; wir ändern es trotzdem, damit kein viewModel() ohne Initializer übrig bleibt.

Die beiden Stellen im Code:

ui/WeatherApp.kt
// Ohne Decorator ist das ViewModel an die Activity gebunden. // Ohne Reflection (iOS) muss angegeben werden, wie das ViewModel erzeugt wird val weatherViewModel = viewModel { WeatherViewModel() }
ui/WeatherScreen.kt
fun WeatherScreen( city: City, modifier: Modifier = Modifier, viewModel: WeatherViewModel = viewModel { WeatherViewModel() }, ) {

Wer nur Android testen kann, bemerkt diesen Fehler nicht. Deshalb gehört zu KMP, regelmäßig auf allen Plattformen zu testen.

Code: kmp-04 · Änderungen 

Was gleich bleibt

  • Von gut 600 Zeilen Kotlin ändern sich 6 Dateien mit rund 40 Zeilen
  • ViewModel, Repositorys, DTOs: unverändert
  • Composables: nur einzelne Zeilen geändert
  • Der Grund für fast jede Änderung: Android-APIs und Reflection gibt es auf iOS nicht

collectAsStateWithLifecycle, rememberSaveable, Coroutines und kotlinx.serialization funktionieren in commonMain genauso wie unter Android.