@ObservedObject Equivalent

[s-k]

Is there an equivalent to @ObservedObject from SwiftUI? If not, how would I update the UI when a property in the model changes?

[david-swift]

You can use @State, it automatically updates the UI when the property it wraps changes.

If you want to create a model grouping multiple properties into one property, you can use a value instead of a reference type, and updates will work fine.

import Adwaita

struct CounterModel: Codable {

    var count = 0 {
        didSet {
            print(count)
        }
    }

}

struct CounterDemo: View {

    @State("count", folder: "io.github.AparokshaUI.Demo/count")
    private var count = CounterModel()

    var view: Body {
        VStack {
            HStack {
                CountButton(count: $count.count, icon: .goPrevious) { $0 -= 1 }
                Text("\(count.count)")
                    .style("title-1")
                    .frame(minWidth: 100)
                CountButton(count: $count.count, icon: .goNext) { $0 += 1 }
            }
            .halign(.center)
        }
        .valign(.center)
        .padding()
    }

    private struct CountButton: View {

        @Binding var count: Int
        var icon: Icon.DefaultIcon
        var action: (inout Int) -> Void

        var view: Body {
            Button(icon: .default(icon: icon)) {
                action(&count)
            }
            .style("circular")
        }
    }

}

[david-swift]

@State is for views, structs conforming to WindowSceneGroup, and apps only.

The delegate is actually a good point. I'll see whether I can find a solution based on the observation framework, but I'm currently rather busy so don't expect a result too fast. Thanks for starting this discussion!

[david-swift]

It should be possible without it (view updates seem to work also with reference instead of value types), and most often, view models are probably used on the app (that is created once the app starts and won't be initialized anymore after that) instead of a view, it can be used as a regular property without a wrapper. But I agree that there should be an easy-to-use solution similar to observed object that can be used in views.

[s-k]

Can you elaborate a little, how your suggested solution for reference types would look like? I'm not exactly sure what you mean.

[david-swift]

If your view model is in an app, you could use the following approach:

import Adwaita
import Observation

@Observable
class ViewModel {

    var count = 0

}

@main
struct AdwaitaTemplate: App {

    let id = "io.github.AparokshaUI.AdwaitaTemplate"
    var app: GTUIApp!
    let viewModel = ViewModel()

    init() {
        observe()
    }

    var scene: Scene {
        Window(id: "main") { _ in
            Text("\(viewModel.count)")
                .padding()
            Button("+1") {
                viewModel.count += 1
            }
            Button("-1") {
                viewModel.count -= 1
            }
        }
    }

    func observe() {
        withObservationTracking {
            viewModel.count
        } onChange: {
            Task {
                State<Any>.updateViews(force: true)
                observe()
            }
        }
    }

}

In views, you can use:

import Adwaita
import Observation

@Observable
class CounterModel {

    var count = 0 {
        didSet {
            print("Hi")
        }
    }

}

struct CounterDemo: View {

    @State private var count = CounterModel()

    init() {
        observe()
    }

    var view: Body {
        VStack {
            HStack {
                CountButton(icon: .goPrevious) { count.count -= 1 }
                Text("\(count.count)")
                    .style("title-1")
                    .frame(minWidth: 100)
                CountButton(icon: .goNext) { count.count += 1 }
            }
            .halign(.center)
        }
        .valign(.center)
        .padding()
    }

    private struct CountButton: View {

        var icon: Icon.DefaultIcon
        var action: () -> Void

        var view: Body {
            Button(icon: .default(icon: icon)) {
                action()
            }
            .style("circular")
        }
    }

    func observe() {
        withObservationTracking {
            count.count
        } onChange: {
            Task {
                _count.content.storage.update = true
                State<Any>.updateViews()
                observe()
            }
        }
    }

}

Both approaches are too complicated, so I'll make a view, "scene", or app automatically check whether there are observable children and observe them, similar to the approach I used for @State. And, make sure that the "original" state doesn't overwrite the new one after the initialization of a view as this is the case with @State, but pass it to the initializer before (maybe I can also improve @State performance-wise). I'll write here once the solution is available, I imagine it to look like the following:

import Adwaita
import Observation

@Observable
class CounterModel {

    var count = 0 {
        didSet {
            print("Hi")
        }
    }

}

struct CounterDemo: View {

    let count = CounterModel()

    var view: Body {
        VStack {
            HStack {
                CountButton(icon: .goPrevious) { count.count -= 1 }
                Text("\(count.count)")
                    .style("title-1")
                    .frame(minWidth: 100)
                CountButton(icon: .goNext) { count.count += 1 }
            }
            .halign(.center)
        }
        .valign(.center)
        .padding()
    }

    private struct CountButton: View {

        var icon: Icon.DefaultIcon
        var action: () -> Void

        var view: Body {
            Button(icon: .default(icon: icon)) {
                action()
            }
            .style("circular")
        }
    }

}

[s-k]

Thank you very much for the detailed explanation! This helps me a lot!

[david-swift]

I added support for the observation framework on the 1.0.0 branch for the next major version as the implementation required some breaking changes. I decided to make State handle both value types and observable reference types:

import Adwaita
import Observation

@Observable
class CounterModel {

    var count = 0 {
        didSet {
            print("Hi")
        }
    }

}

struct CounterDemo: View {

    @State private var count = CounterModel()

    var view: Body {
        VStack {
            HStack {
                CountButton(icon: .goPrevious) { count.count -= 1 }
                Text("\(count.count)")
                    .style("title-1")
                    .frame(minWidth: 100)
                CountButton(icon: .goNext) { count.count += 1 }
            }
            .halign(.center)
        }
        .valign(.center)
        .padding()
    }

    private struct CountButton: SimpleView {

        var icon: Icon.DefaultIcon
        var action: () -> Void

        var view: Body {
            Button(icon: .default(icon: icon)) {
                action()
            }
            .style("circular")
        }
    }

}