skiptools / skip-model

SkipModel

Model object observation for Skip apps.

See what API is included here.

About

SkipModel vends the skip.model Kotlin package. This package contains Observable and ObservableObject interfaces, representing the two core protocols that SwiftUI uses to observe changes to model objects. It also includes limited Publisher support.

Dependencies

SkipLib depends on the skip transpiler plugin and the SkipFoundation package.

SkipModel is part of the core SkipStack and is not intended to be imported directly. The transpiler includes import skip.model.* in generated Kotlin for any Swift source that imports the Combine, Observation, or SwiftUI frameworks.

Status

From the Observation package, SkipModel supports the @Observable and @ObservationIgnored macros.

From Combine, SkipModel supports the ObservableObject protocol, the @Published property wrapper, and limited Publisher functionality. See API support below.

Much of Skip's model support is implemented directly in the Skip transpiler. The Observable and ObservableObject marker protocols are are sufficient for the Skip transpiler to recognize your observable types. When generating their corresponding Kotlin classes, the transpiler then adds the necessary code so that their state can be tracked by the Compose runtime.

Contributing

We welcome contributions to SkipModel. The Skip product documentation includes helpful instructions and tips on local Skip library development. When submitting code, please include unit tests in your PR.

Model Objects

Like Skip itself, SkipModel objects are dual-platform! Not only do your @Observable and ObservableObject properties participate in SwiftUI state tracking, but they are tracked by Compose as well. The Skip transpiler backs your observable properties with MutableState values in Kotlin, so Compose automatically tracks reads and writes and performs recomposition as needed.

This means that you can write shared model-layer Swift code using observable objects, and use it to power both SwiftUI (whether iOS-only or dual-platform with Skip) as well as pure Android Compose UI code. For example, the following model class:

@Observable class TapCounter {
    var tapCount = 0 
}

could power a Compose UI:

val tapCounter = TapCounter()
...
TapIt(counter = tapCounter)
...
@Composable fun TapIt(counter: TapCounter) {
    Button(onClick = { counter.tapCount += 1 }) { 
        Text("Tap Count: ${counter.tapCount}")
    }
}

API Support

The following table summarizes SkipModel's API support on Android. Anything not listed here is likely not supported. Note that in your iOS-only code - i.e. code within #if !SKIP blocks - you can use any Swift API you want.

In all Combine publishes and related API, the Failure type must be Never: throwing errors in Combine chains is not supported.

Support levels:

• ✅ – Full
• 🟢 – High
• 🟡 – Medium
• 🟠 – Low

Support	API
🟢	AnyCancellable See Cancellable
🟢	Cancellable The store(in:) function only supports a Set
🟠	ConnectablePublisher func connect() func autoconnect() See Publisher
✅	func NotificationCenter.publisher(for: Notification.Name, object: Any? = nil): Publisher<Notification, Never>
🟢	@Observable Skip does not support calls to the generated access(keyPath:) and withMutation(keyPath:_:) functions
🟢	ObservableObject If you declare your own objectWillChange publisher, it must be of type ObservableObjectPublisher
🟠	ObservableObjectPublisher func send() See Publisher
✅	@ObservationIgnored
🟠	PassthroughSubject func send(value: Output) See Publisher
✅	@Published
🟠	Publisher func assign<Root>(to: KeyPath<Root, Output>, on: Root) -> AnyCancellable func sink(receiveValue: (Output) -> Unit) -> AnyCancellable func debounce(for: Double, scheduler: Scheduler) -> Publisher func dropFirst(count: Int = 1) -> Publisher func filter(isIncluded: (Output) -> Boolean) -> Publisher func map<T>(transform: (Output) -> T) -> Publisher func receive(on: Scheduler): Publisher
✅	func Timer.publish(every: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop, in mode: RunLoop.Mode, options: RunLoop.SchedulerOptions? = nil) -> ConnectablePublisher<Date, Never>

skip-model's Issues

Observable doesn't trigger compose for computed properties

Computed properties within an Observable class do not trigger recomposition of views when changed. The following code works fine in iOS (any time the ItemList class updates its items array, the view updates as well), but does not trigger recomposition on Android.

Also, in my use case I actually have an array of ItemList that I am flat mapping in the computed property, but I simplified that for this example. Mentioning it because Arrays have also caused Observation issues in the past (that you all have fixed since).

public struct ContentView: View {
    @State var model = MyModel()
    
    public init() {
    }

    public var body: some View {
        VStack {
            ForEach(model.items) { item in
                Text(item.title)
            }
        }
    }
}

@Observable
public class MyModel {
    private var itemList: ItemList = ItemList()
    public var items: [Item] {
        self.itemList.items
    }

  // COMMENT: MY ACTUAL CODE
  // private var itemLists: [ItemList] = [ItemList()]
  // public var items: [Item] {
        // self.itemLists.flatMap(\.items)
  // }
}

@Observable
public class ItemList {
    var items: [Item] = []
    
    init() {
        Task {
            try await Task.sleep(nanoseconds: 100_000_00)
            self.items = [Item(id: UUID(), title: "First")]
        }
        
    }
}

public struct Item: Identifiable {
    public let id: UUID
    public var title: String
}