KMP-ObservableViewModel

1.0.5indexed

Enables use of AndroidX ViewModels in SwiftUI, ensuring state changes propagate correctly. Provides wrappers for seamless integration with SwiftUI and supports creating and managing ViewModels across different platforms.

AndroidJSJVMNativeWasm·rickclephas/KMP-ObservableViewModel

696

Stars

Used by

dependents

—

Health

/ 100

KMP-ObservableViewModel

A library (previously known as KMM-ViewModel) that allows you to use AndroidX/Kotlin ViewModels with SwiftUI.

Compatibility

You can use this library in any KMP project, but not all targets support AndroidX and/or SwiftUI interop:

Target	Supported	AndroidX	SwiftUI
Android	✅	✅	-
JVM	✅	✅	-
iOS	✅	✅	✅
macOS	✅	✅	✅
tvOS	✅	-	✅
watchOS	✅	-	✅
linuxX64

The latest version of the library uses Kotlin version 2.4.0.
Compatibility versions for older and/or preview Kotlin versions are also available:

Kotlin

Add the library to your shared Kotlin module and opt-in to the ExperimentalForeignApi:

kotlin {
    sourceSets {
        all {
            languageSettings.optIn("kotlinx.cinterop.ExperimentalForeignApi")
        }
        commonMain {
            dependencies {
                api("com.rickclephas.kmp:kmp-observableviewmodel-core:1.0.5")
            }
        }
    }
}

And create your ViewModels:

import com.rickclephas.kmp.observableviewmodel.ViewModel
import com.rickclephas.kmp.observableviewmodel.MutableStateFlow
import com.rickclephas.kmp.observableviewmodel.stateIn

open class TimeTravelViewModel: ViewModel() {

      clockTime = Clock.time

    
     actualTime = clockTime.map { formatTime(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), )

      _travelEffect = MutableStateFlow<TravelEffect?>(viewModelScope, )
    
     travelEffect = _travelEffect.asStateFlow()
}

As you might notice it isn't much different from an AndroidX ViewModel.
We are obviously using a different ViewModel superclass:

- import androidx.lifecycle.ViewModel
+ import com.rickclephas.kmp.observableviewmodel.ViewModel

open class TimeTravelViewModel: ViewModel() {

But besides that there are only 2 minor differences.
The first being a different import for stateIn:

- import kotlinx.coroutines.flow.stateIn
+ import com.rickclephas.kmp.observableviewmodel.stateIn

        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), "N/A")

And the second being a different MutableStateFlow constructor:

- import kotlinx.coroutines.flow.MutableStateFlow
+ import com.rickclephas.kmp.observableviewmodel.MutableStateFlow

-    private val _travelEffect = MutableStateFlow<TravelEffect?>(null)
+    private val _travelEffect = MutableStateFlow<TravelEffect?>(viewModelScope, null)

These minor differences will make sure that state changes are propagated to SwiftUI.

[!NOTE] viewModelScope is a wrapper around the actual CoroutineScope which can be accessed via the ViewModelScope.coroutineScope property.

KMP-NativeCoroutines

I highly recommend you to use the @NativeCoroutinesState annotation from KMP-NativeCoroutines to turn your StateFlows into properties in Swift:

@NativeCoroutinesState
val travelEffect = _travelEffect.asStateFlow()

Checkout the KMP-NativeCoroutines README for more information and installation instructions.

Alternative

Alternatively you can create extension properties in your iOS/Apple source-set yourself:

val TimeTravelViewModel.travelEffectValue: TravelEffect?
    get() = travelEffect.value

Android

Use the view model like you would any other AndroidX ViewModel:

class TimeTravelFragment: Fragment(R.layout.fragment_time_travel) {
    private val viewModel: TimeTravelViewModel by viewModels()
}

Swift

After you have configured your shared Kotlin module and created a ViewModel it's time to configure your Swift project.
Start by adding the Swift package to your Package.swift file:

dependencies: [
    .package(url: "https://github.com/rickclephas/KMP-ObservableViewModel.git", from: "1.0.5")
]

Or add it in Xcode by going to File > Add Packages... and providing the URL: https://github.com/rickclephas/KMP-ObservableViewModel.git.

CocoaPods

If you like you can also use CocoaPods instead of SPM:

pod 'KMPObservableViewModelSwiftUI', git: 'https://github.com/rickclephas/KMP-ObservableViewModel.git', tag: 'v1.0.5'

Create a KMPObservableViewModel.swift file with the following contents:

import KMPObservableViewModelCore
import shared // This should be your shared KMP module

extension Kmp_observableviewmodel_coreViewModel: @retroactive ViewModel { }

After that you can use your view model almost as if it were an ObservableObject.
Just use the view model specific property wrappers and functions:

E.g. to use the TimeTravelViewModel as a StateObject:

import SwiftUI
import KMPObservableViewModelSwiftUI
import shared // This should be your shared KMP module

struct ContentView: View {
    @StateViewModel var viewModel = TimeTravelViewModel()
}

It's also possible to subclass your view model in Swift:

import Combine
import shared // This should be your shared KMP module

class TimeTravelViewModel: shared.TimeTravelViewModel {
    @Published var isResetDisabled: Bool = false
}

Observation support

When using ObservableObjects your SwiftUI views will likely rerender a lot. Luckily the Observation framework brings significant improvements in terms of change tracking, allowing for more efficient rerendering.

To add support for the Observation framework to all your Kotlin view models, simply add the following to your KMPObservableViewModel.swift file:

import Observation
import shared // This should be your shared KMP module

extension Kmp_observableviewmodel_coreViewModel: @retroactive Observable { }

Alternatively you can add the Observable conformance to specific Kotlin view models instead.

[!NOTE] The Observable conformance is automatically added if you subclass your view model and use the @Observable macro.

[!NOTE] As an added bonus your Kotlin view models will benefit from the Observable framework on supported OS versions regardless of your app's deployment target. E.g. you can benefit from Observation support on iOS 17 and above while still supporting iOS 16 and below using ObservableObjects.

Child view models

You'll need some additional logic if your ViewModels expose child view models.

First make sure to use the NativeCoroutinesRefinedState annotation instead of the NativeCoroutinesState annotation:

class MyParentViewModel: ViewModel() {
    @NativeCoroutinesRefinedState
    val myChildViewModel: StateFlow<MyChildViewModel?> = MutableStateFlow(null)
}

After that you should create a Swift extension property using the childViewModel(at:) function:

extension MyParentViewModel {
    var myChildViewModel: MyChildViewModel? {
        childViewModel(at: \.__myChildViewModel)
    }
}

This will prevent your Swift view models from being deallocated too soon.

[!NOTE] For lists, sets and dictionaries containing view models there is childViewModels(at:).

Cancellable ViewModel

When subclassing your Kotlin ViewModel in Swift you might experience some issues in the way those view models are cleared.

An example of such an issue is when you are using a Combine publisher to observe a Flow through KMP-NativeCoroutines:

import Combine
import KMPNativeCoroutinesCombine
import shared // This should be your shared KMP module

class TimeTravelViewModel: shared. {

      cancellables  <>()

     () {
        .()
        createPublisher(for: currentTimeFlow)
            .assertNoFailure()
            .sink { time  () }
            .store(in: cancellables)
    }
}

Since currentTimeFlow is a StateFlow we don't ever expect it to fail, which is why we are using the assertNoFailure. However, in this case you'll notice that the publisher will fail with a JobCancellationException.

The problem here is that before the TimeTravelViewModel is deinited it will already be cleared. Meaning the viewModelScope is cancelled and onCleared is called. This results in the Combine publisher outliving the underlying StateFlow collection.

To solve such issues you should have your Swift view model conform to Cancellable and perform the required cleanup in the cancel function:

class TimeTravelViewModel: shared.TimeTravelViewModel, Cancellable {
    func cancel() {
        cancellables = []
    }
}

KMP-ObservableViewModel will make sure to call the cancel function before the ViewModel is being cleared.

Related libraries

Surfaced from shared tags and platforms — no rankings paid for.

koin★ 10.0k

InsertKoinIOPragmatic lightweight dependency injection framework using a DSL and light container. Offers packages for core, coroutines, testing, Android, Ktor, annotations, and Jetpack Compose integration. Includes tutorials and community support.Shared: dependency-injection

Kodein★ 3.3k

kosi-libsStraightforward dependency retrieval container offering lazy instantiation, binding, and debugging capabilities. Integrates with Android, Compose, and Ktor. Provides a simple, readable declarative DSL.Shared: dependency-injection

Decompose★ 2.8k

arkivanovBreaks down code into tree-structured, lifecycle-aware business logic components with routing and pluggable UI support. Offers clear UI/non-UI separation, dependency injection, state preservation, and custom navigation models.Shared: dependency-injection

orbit-mvi★ 1.3k

orbit-mviLightweight Redux/MVI-like library offering a simple, type-safe, coroutine-based API. Features include lifecycle-safe flow collection, ViewModel support, unit testing, espresso idling resources, and compatibility with RxJava and LiveData. Ideal for state management and side-effect handling.Shared: dependency-injection

MVIKotlin★ 1.0k

arkivanovFramework enabling MVI pattern implementation with features like logging, time travel, and lifecycle-aware connections. Flexible architecture supports various reactive libraries or none, facilitating incremental adoption and experimentation.Shared: dependency-injection

FlowMVI★ 931

respawn-llcExtensive architectural framework for developing reactive applications with features like automatic state preservation, remote debugging, error recovery, and a powerful plugin system for reusing business logic.Shared: dependency-injection

*latest*	*no suffix*	2.4.0	1.10.1	2.8.7
1.0.4	no suffix	2.3.21	1.10.1	2.8.7
1.0.3	no suffix	2.3.20	1.10.1	2.8.7
1.0.2	no suffix	2.3.10	1.10.1	2.8.7
1.0.1	no suffix	2.3.0	1.10.1	2.8.7
1.0.0	no suffix	2.2.21	1.10.1	2.8.7
1.0.0-BETA-13	no suffix	2.2.10	1.10.1	2.8.7
1.0.0-BETA-12	no suffix	2.2.0	1.10.1	2.8.7
1.0.0-BETA-11	no suffix	2.1.21	1.10.1	2.8.7
1.0.0-BETA-9	no suffix	2.1.10	1.10.1	2.8.7
1.0.0-BETA-8	no suffix	2.1.0	1.9.0	2.8.4
1.0.0-BETA-7	no suffix	2.0.21	1.9.0	2.8.4
1.0.0-BETA-4	no suffix	2.0.10	1.8.1	2.8.4
1.0.0-BETA-3	no suffix	2.0.0	1.8.1	2.8.0

`@StateObject`	`@StateViewModel`
`@ObservedObject`	`@ObservedViewModel`
`@EnvironmentObject`	`@EnvironmentViewModel`
`environmentObject(_:)`	`environmentViewModel(_:)`