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ür | Bibliothek | Source Set |
|---|---|---|
| Navigation 3 | org.jetbrains.androidx.navigation3:navigation3-ui | commonMain |
| Serialization | kotlinx-serialization-core + Plugin | commonMain |
| HTTP | Ktor Client, Content Negotiation, JSON | commonMain |
| HTTP-Engine | ktor-client-okhttp / ktor-client-darwin | androidMain / iosMain |
| ViewModel, Lifecycle | schon vom Wizard eingebunden | commonMain |
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:
[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:
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:
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:
<uses-permission android:name="android.permission.INTERNET" />Danach Sync Now.
Code: kmp-01 ·
Änderungen
Code kopieren
model/,data/undui/(mitui/theme) ausschritt-10nachshared/src/commonMain/kotlin/…kopieren- Paketnamen in
packageund Imports ersetzen (weatherandroidtif24→weatherkmptif24) App()zeigt die Wetter-App
@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.ktundPlatform.ktshared/src/androidMain/kotlin/com/example/weatherkmptif24/Platform.android.ktshared/src/iosMain/kotlin/com/example/weatherkmptif24/Platform.ios.ktshared/src/commonMain/composeResources/drawable/compose-multiplatform.xml
App.kt ersetzt den Inhalt aus dem Template vollständig:
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:
| Stelle | Ersatz |
|---|---|
HttpClient(OkHttp) | HttpClient { … }, Engine pro Plattform |
java.io.IOException | kotlinx.io.IOException |
"%.2f".format(…) | String-Template |
| Dynamic Color im Theme | feste Farben |
Preview mit uiMode | Theme 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:
import kotlinx.io.IOException // statt java.io.IOExceptionOhne Engine nimmt Ktor die, die für die Plattform eingebunden ist. Der
Import von OkHttp entfällt:
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:
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 (kmp-03)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:
// 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)),
)
}
}Navigation 3 ohne Reflection
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 (kmp-03)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:
// Ohne Decorator ist das ViewModel an die Activity gebunden.
// Ohne Reflection (iOS) muss angegeben werden, wie das ViewModel erzeugt wird
val weatherViewModel = viewModel { WeatherViewModel() }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.