I am learning SwiftUI.
Error:
SwiftUI/Environment+Objects.swift:32: Fatal error: No Observable object of type ViewModel found. A View.environmentObject(_:) for ViewModel may be missing as an ancestor of this view.
I do not get the point why this happens.
The error is shown in the line : "renderer.render {...
import SwiftData
import SwiftUI
@Observable
class ViewModel {
var groupNumber: String = "Gruppe"
var sumOfHours: Int = 0
var personsToPrint: [Person]? = nil
@MainActor func pdfReport(person: [Person]) {
if personsToPrint != nil {
for person in personsToPrint! {
let renderer = ImageRenderer(content: PersonDetailView(person: person))
let url = URL.documentsDirectory.appending(path: "\(person.lastname) \(person.firstname).pdf")
print(person.lastname, person.firstname)
renderer.render { size, context in
var box = CGRect(x: 0, y: 0, width: size.width, height: size.height)
guard let pdf = CGContext(url as CFURL, mediaBox: &box, nil) else {
return
}
pdf.beginPDFPage(nil)
context(pdf)
pdf.endPDFPage()
pdf.closePDF()
let data = try! Data(contentsOf: url) //pdf muss erst in Daten umgewandelt werden.
do {
try data.write(to: url)
print("Daten wurden hier gespeichert: \(url)")
} catch {
print("PDF could not be saved!")
}
}
}
}
}
}
Observation
RSS for tagMake responsive apps that update the presentation when underlying data changes.
Posts under Observation tag
55 Posts
Sort by:
Post
Replies
Boosts
Views
Activity
Following this Apple Article, I copied their code over for observePlayingState().
The only difference I am using @Observable instead of ObservableObject and @Published for var isPlaying.
We get a bit more insight after removing the $ symbol, leading to a more telling error of: Cannot convert value of type 'Bool' to expected argument type 'Published.Publisher'
Is there anyway to get this working with @Observable?
I am following this Apple Article on how to setup an AVPlayer. The only difference is I am using @Observable instead of an ObservableObject with @Published vars.
Using @Observable results in the following error: Cannot find '$isPlaying' in scope
If I remove the "$" symbol I get a bit more insight:
Cannot convert value of type 'Bool' to expected argument type 'Published<Bool>.Publisher'
If I change by class to an OO, it works fine, although, is there anyway to get this to work with @Observable?
In my test app I have two squares (red and green) that change their size when I click a toggle button. I use two different approaches to change the scale. The red square is scaled using the .visualEffect modifier and the green square is scaled using the .scaleEffect modifier. When I click the button the first time, both squares change size. But when I click again and again, only the green square changes its size. The red square stays the same after the first change. Self._printChanges() show that both views get changes each time. What am I doing wrong? Or is this a bug?
import SwiftUI
import Observation
struct ContentView: View {
@State private var model: Model = Model()
var body: some View {
VStack {
HStack {
RedSquareView()
GreenSquareView()
}
.environment(model)
Button {
model.scaled.toggle()
} label: {
Text("Toggle scale")
}
}
.padding()
}
}
struct RedSquareView: View {
@Environment(Model.self) var model
var body: some View {
let _ = Self._printChanges()
Rectangle()
.fill(Color.red)
.frame(width: 100, height: 100)
.visualEffect { content, geometryProxy in
content.scaleEffect(model.scaled ? 0.5 : 1.0, anchor: .center)
}
.animation(.bouncy, value: model.scaled)
}
}
struct GreenSquareView: View {
@Environment(Model.self) var model
var body: some View {
let _ = Self._printChanges()
Rectangle()
.fill(Color.green)
.frame(width: 100, height: 100)
.scaleEffect(model.scaled ? 0.5 : 1.0, anchor: .center)
.animation(.bouncy, value: model.scaled)
}
}
@Observable
final class Model: Sendable {
var scaled: Bool = false
}
#Preview {
ContentView()
}
I've encountered a problem which I don't know if is related to swiftui, the observation framework, or both
If I run the following code I have two tabs, with the second tab that use a "lazy model" which is deallocated each time disappears (this is necessary for my use case)
If I switch to the second tab, all works right. If I return to the first tab, the onDisappear on the foo view should force the "Bar" variable to nil , because the FooView may be still allocated (it is a tab bar) but that resource should be released
If that bar variable is set to nil, the MyBar should be replaced by the ProgressView in the "background"
I expect regarding that the Bar that:
the instance is nil on Foo
no other view should be shown with that instance (MyBar is now disappeared)
Because no ref, the Bar observable object should be now deallocated
In reality the Bar object is still in my memory graph
Any suggestions? is it a bug?
@Observable
class Bar {
var hello: String = ""
}
struct Foo: View {
@State
var bar: Bar?
@ViewBuilder
private var content: some View {
if let bar {
MyBar(bar: bar)
} else {
ProgressView()
}
}
var body: some View {
content
.onAppear {
bar = Bar()
}
.onDisappear {
self.bar = nil
}
}
}
struct MyBar: View {
@Bindable
var bar: Bar
var body: some View {
Text("MyBar")
}
}
struct ContentView: View {
@State
var tag: Int = 0
var body: some View {
TabView(selection: $tag) {
Text("First")
.tag(0)
.tabItem {
Text("First")
}
Foo()
.tag(1)
.tabItem {
Text("Foo")
}
}
}
}
I'm working on a SwiftUI app using SwiftData for state management. I've encountered an issue with view updates when mutating a model. Here's a minimal example to illustrate the problem:
import SwiftUI
import SwiftData
// MARK: - Models
@Model
class A {
@Relationship var bs: [B] = [B]()
init(bs: [B]) {
self.bs = bs
}
}
@Model
class B {
@Relationship var cs: [C] = [C]()
init(cs: [C]) {
self.cs = cs
}
}
@Model
class C {
var done: Bool
init(done: Bool) {
self.done = done
}
}
// MARK: - Views
struct CView: View {
var c: C
var body: some View {
@Bindable var c = c
HStack {
Toggle(isOn: $c.done, label: {
Text("Done")
})
}
}
}
struct BView: View {
var b: B
var body: some View {
List(b.cs) { c in
CView(c: c)
}
}
}
struct AView: View {
var a: A
var body: some View {
List(a.bs) { b in
NavigationLink {
BView(b: b)
} label: {
Text("B \(b.cs.allSatisfy({ $0.done }).description)")
}
}
}
}
struct ContentView: View {
@Query private var aList: [A]
var body: some View {
NavigationStack {
List(aList) { a in
NavigationLink {
AView(a: a)
} label: {
Text("A \(a.bs.allSatisfy({ $0.cs.allSatisfy({ $0.done }) }).description)")
}
}
}
}
}
@main
struct Minimal: App {
var body: some Scene {
WindowGroup {
ContentView()
}
}
}
#Preview {
let config = ModelConfiguration(isStoredInMemoryOnly: true)
let container = try! ModelContainer(for: A.self, configurations: config)
var c = C(done: false)
container.mainContext.insert(c)
var b = B(cs: [c])
container.mainContext.insert(b)
var a = A(bs: [b])
container.mainContext.insert(a)
return ContentView()
.modelContainer(container)
}
In this setup, I have a CView where I toggle the state of a model C. After toggling C and navigating back, the grandparent view AView does not reflect the updated state (it still shows false instead of true). However, if I navigate back to the root ContentView and then go to AView, the status is updated correctly.
Why doesn't AView update immediately after mutating C in CView, but updates correctly when navigating back to the root ContentView? I expected the grandparent view to reflect the changes immediately as per SwiftData's observation mechanism.
class PostManager: ObservableObject {
static let shared = PostManager()
private init() {}
@Published var containers: [PostContainer] = []
// Other code
}
class PostContainer: ObservableObject {
var id: UUID = UUID()
var timestamp: Date
var subreddit: String
var posts: [Post]
var type: ContainerType
var active: Bool
// Init
}
@Model
final class Post: Decodable, ObservableObject {
// Other code
}
In my main view, a network request is made and a PostContainer is created if it doesn't exist. This code works fine, and the view is updated correctly.
let container = PostContainer(timestamp: Date(), subreddit: subreddit, posts: posts, type: .search, active: true)
self.containers.append(container)
If the user wants to see more, they press a button and another request is made. This time, the new data will be added to the PostContainer instead of creating a new one.
if let container = self.containers.first(where: {$0.subreddit == subreddit}) {
// Update previous container
container.timestamp = Date()
print(container.posts.count)
// Map IDs from container and then remove duplicates
let existingIDs = Set(container.posts.map { $0.id })
let filtered = posts.filter { !existingIDs.contains($0.id) }
// Append new post
container.posts.append(contentsOf: filtered)
container.active = true
}
This code is working fine as well, except for the view is not updating. In the view, PostManager is an @EnvironmentObject. I also have a computed variable to get the post and sort them. I added a print statement to that variable and saw that it wasn't being printed even though more data was being added to the PostContainer. At one point, I created an ID for the List that displays the data and had the code inside PostManager update that ID when it was finished. This of course worked, but it's not ideal.
How can I get the view to update when post are appended inside of PostContainer?
According to docs, .focusedObject() usage should be moved to .focusedValue() when migrating to @Observable, but there is no .focusedSceneValue() overload that accepts Observable like with .focusedValue(). So how are we supposed migrate .focusedSceneObject() to @Observable?
I am surprised at what I am seeing with the new @Observable framework in iOS 17.
It seems that if the view containing the @State var, ie viewModel, is modified, then the init of that viewModel will also be called. This is not the behavior of the prior StateObject method of using a viewModel.
As I understand the @State should not be reinitialized on redrawing on the View, is this the expected behavior?
Example:
struct ContentView: View {
@State var offset = false
var body: some View {
VStack {
InnerView()
.offset(x: offset ? 200 : 0)
Button("Offset") {
offset.toggle()
}
}
}
}
// iOS 17 Observable method:
struct InnerView: View {
@State var viewModel: ViewModel
init() {
self._viewModel = State(wrappedValue: ViewModel())
}
var body: some View {
VStack {
Image(systemName: "globe")
.imageScale(.large)
.foregroundStyle(.tint)
Text("Hello, world!")
}
.padding()
}
}
@Observable
class ViewModel {
init() {
print("ViewModel Init")
}
}
// StateObject method:
struct InnerView: View {
@StateObject var viewModel: ViewModel
init() {
self._viewModel = StateObject(wrappedValue: ViewModel())
}
var body: some View {
VStack {
Image(systemName: "globe")
.imageScale(.large)
.foregroundStyle(.tint)
Text("Hello, world!")
}
.padding()
}
}
class ViewModel: ObservableObject {
init() {
print("ViewModel Init")
}
}
Hi guys,
I am trying to use the new @Observable macro. According to the documentation, this new macro will automatically generate observable properties, but I am having issues using my properties when Bindings are necessary.
Previously I had a setup like this:
class Example: ObservableObject {
@Published public var myArray = [CustomType]()
}
I initialised one instance of the Example-class in @main
@StateObject private var exampleClass = Example()
And added as an .environmentObject onto the root view
ContentView()
.environmentObject(exampleClass)
In child views I was able to access the @Published property as a binding via
@EnvironmentObject private var example: Example
$example.myArray
What I am trying now
This is the setup that I am trying with now:
@Observable class Example {
public var myArray = [CustomType]()
}
State instead of StateObject in @main
@State private var exampleClass = Example()
.environment instead of .environmentObject
ContentView()
.environmentObject(exampleClass)
@Environment instead of @EnvironmentObject
@Environment(Example.self) private var example
This new setup is not letting me access $example.myArray. Is this intended? Could someone explain why?
iOS 17 introduced @Observable. that's an effective way to implement a stateful model object.
however, we will not be able to use @StateObject as the model object does not have ObservableObject protocol.
An advantage of using StateObject is able to make the object initializing once only for the view. it will keep going on until the view identifier is changed.
I put some examples.
We have a Observable implemented object.
@Observable final class Controller { ... }
then using like this
struct MyView: View {
let controller: Controller
init(value: Value) {
self.controller = .init(value: value)
}
init(controller: Controller) {
self.controller = controller
}
}
this case causes a problem that the view body uses the passed controller anyway.
even passed different controller, uses it.
and what if initializing a controller takes some costs, that decrease performance.
how do we manage this kind of use case?
anyway I made a utility view that provides an observable object lazily.
public struct ObjectProvider<Object, Content: View>: View {
@State private var object: Object?
private let _objectInitializer: () -> Object
private let _content: (Object) -> Content
public init(object: @autoclosure @escaping () -> Object, @ViewBuilder content: @escaping (Object) -> Content) {
self._objectInitializer = object
self._content = content
}
public var body: some View {
Group {
if let object = object {
_content(object)
}
}
.onAppear {
object = _objectInitializer()
}
}
}
ObjectProvider(object: Controller() { controller in
MyView(controller: controller)
}
for now it's working correctly.
******* TestData.swift ************************
struct Measures: Identifiable {
let id = UUID()
var dataSeq: Int
var value: Double
}
struct Items: Identifiable {
let id = UUID()
var name: String
var measures: [Measures]
}
struct chartItemInfo: Identifiable {
var id = UUID()
var testItem: String
var value: Double
}
var angleItem : [chartItemInfo]?
var degreeItem : [chartItemInfo]?
var grip1Item : [chartItemInfo]?
var grip2Item : [chartItemInfo]?
class TestData: ObservableObject {
@Published var angleItem : [chartItemInfo]?
@Published var degreeItem : [chartItemInfo]?
@Published var grip1Item : [chartItemInfo]?
@Published var grip2Item : [chartItemInfo]?
}
******** CalculatorViewModel.swift ******************************************
class CalculatorViewModel : NSObject, ObservableObject, Identifiable {
....
typealias test_Array = (time: String, swingNum: Int, dataSeqInSwing: Int, timeStampInSeq: Int, angle: Double, degree: Double, grip1: Double, grip2: Double)
....
@Published var testDBdata = [test_Array]()
@Published var chartDBdata = [chart_Array]() //
@StateObject var testData : TestData
var Testitems = [ (channel: "angle", data: testData.angleItem), (channel: "degree", data: testData.degreeItem), (channel: "grip1", data: testData.grip1Item), (channel: "grip2", data: testData.grip2Item)]. => Cannot use instance member 'testData' within property initializer; property initializers run before 'self' is available ?
purpose of this project: read FMDB data and then make Array with DB data.
and then i use these Array for displaying multi plot in Chart.
I have a class A and class B, and both of them are @Observable, and none of them are a view.
Class A has an instance of class B.
I want to be able to listen to changes in this instance of class B, from my class A.
Previously, by using ObservableObject, instead of the @Observable macro, every property that needed to be observable, had to be declared as a Publisher. With this new framework, everything seems to be automatically synthesised, and using a Publisher is no longer required, as all the properties are observable.
That being said, how can I have an equivalent using @Observable? Is this new macro only for view-facing classes?
I have an issue with a View that owns @Observable object (Instantize it, and is owner during the existence) in the same notion as @StateObject, however when @State is used the viewModel is re-created and deallocated on every view redraw.
In the previous models, @StateObject were used when the View is owner of the object (Owner of the viewModel as example)
When @Observable object is used in the same notion, @State var viewModel = ViewModel() the viewModel instance is recreated on views redraws.
@StateObject was maintaining the same instance during the View existence, that however is not happening when used @Observable with @State.
I created FB13074428 and a small sample project to demonstrate the bug.
https://github.com/jamiemcd/Apple-FB13074428
Basically, if a SwiftData class is marked as @Model and it has a computed property that depends on a relationship's stored property, the computed property does not trigger updates in SwiftUI when the underlying relationship changes its stored property. This is Xcode 15 Beta 8.
@Model
final class Airport {
var code: String
var name: String
var airplanes: [Airplane]
init(code: String, name: String, airPlanes: [Airplane]) {
self.code = code
self.name = name
self.airplanes = airPlanes
}
// Bug: This computed property is not triggering observation in AirportView when airplane.state changes. My understanding of the new observation framework is that it should.
var numberOfAirplanesDeparting: Int {
var numberOfAirplanesDeparting = 0
for airplane in airplanes {
if airplane.state == .departing {
numberOfAirplanesDeparting += 1
}
}
return numberOfAirplanesDeparting
}
}
AirportView should update because it has Text for airport.numberOfAirplanesDeparting
struct AirportView: View {
var airport: Airport
var body: some View {
List {
Section {
ForEach(airport.airplanes) { airplane in
NavigationLink(value: airplane) {
HStack {
Image(systemName: airplane.state.imageSystemName)
VStack(alignment: .leading) {
Text(airplane.name)
Text(airplane.type.name)
}
}
}
}
} header: {
Text(airport.name)
} footer: {
VStack(alignment: .leading) {
Text("Planes departing = \(airport.numberOfAirplanesDeparting)")
Text("Planes in flight = \(airport.numberOfAirplanesInFlight)")
Text("Planes landing = \(airport.numberOfAirplanesLanding)")
}
}
}
}
At the moment, using Bindable for an object stored in Environment works in a cumbersome way:
struct ContentView: View {
@Environment(Model.self) var model
var body: some View {
@Bindable var model = model
VStack {
Text(model.someField.uppercased())
TextField("", text: $model.someField)
someSubView
}
.padding()
}
@ViewBuilder
var someSubView: some View {
@Bindable var model = model
TextField("", text: $model.someField)
}
}
A new @Bindable needs to be instantiated for each computed property in the view, which creates boilerplate I would like to avoid.
I made a new property wrapper which functions the same as the EnvironmentObject wrapper, but for Observable:
@propertyWrapper
struct EnvironmentObservable<Value: AnyObject & Observable>: DynamicProperty {
@Environment var wrappedValue: Value
public init(_ objectType: Value.Type) {
_wrappedValue = .init(objectType)
}
public init() {
_wrappedValue = .init(Value.self)
}
private var store: Bindable<Value>!
var projectedValue: Bindable<Value> {
store
}
mutating func update() {
store = Bindable(wrappedValue)
}
}
Example:
struct ContentView: View {
@EnvironmentObservable var model: Model
var body: some View {
VStack {
Text(model.someField.uppercased())
SubView(value: $model.someField)
someSubView
}
.padding()
}
var someSubView: some View {
TextField("", text: $model.someField)
}
}
I was wondering if there would be any downsides to using this method? In my testings it seems to behave the same, but I'm not sure if using this could have a performance impact.
SwiftUI & SwiftData.
I have a view that lists SwiftData objects. Tapping on a list item navigates to a detail view. The list view also has a "New Object" button. Tapping it opens a sheet used to create a new object. There are, obviously, two possible outcomes from interacting with the sheet — a new object could be created or the user could cancel without creating a new object.
If the user creates a new object using the sheet, I want to open the detail view for that object. My thought was to do this in the onDismiss handler for the sheet. However, that handler takes no arguments.
What is best practice for handling this situation? In UIKit, I would return a Result<Object, Error> in a closure. That won't work here. What is the "correct" way to handle this that is compatible with SwiftData and the Observation framework?
Our app has an architecture based on ViewModels.
Currently, we are working on migrating from the ObservableObject protocol to the Observable macro (iOS 17+).
The official docs about this are available here: https://developer.apple.com/documentation/swiftui/migrating-from-the-observable-object-protocol-to-the-observable-macro
Our ViewModels that were previously annotated with @StateObject now use just @State, as recommended in the official docs.
Some of our screens (a screen is a SwiftUI view with a corresponding ViewModel) are presented modally. We expect that after dismissing a SwiftUI view that was presented modally, its corresponding ViewModel, which is owned by this view (via the @State modifier), will be deinitialized. However, it seems there is a memory leak, as the ViewModel is not deinitialized after a modal view is dismissed.
Here's a simple code where ModalView is presented modally (through the .sheet modifier), and ModalViewModel, which is a @State of ModalView, is never deinitialized.
import SwiftUI
import Observation
@Observable
final class ModalViewModel {
init() {
print("Simple ViewModel Inited")
}
deinit {
print("Simple ViewModel Deinited") // never called
}
}
struct ModalView: View {
@State var viewModel: ModalViewModel = ModalViewModel()
let closeButtonClosure: () -> Void
var body: some View {
ZStack {
Color.yellow
.ignoresSafeArea()
Button("Close") {
closeButtonClosure()
}
}
}
}
struct ContentView: View {
@State var presentSheet: Bool = false
var body: some View {
Button("Present sheet modally") {
self.presentSheet = true
}
.sheet(isPresented: $presentSheet) {
ModalView {
self.presentSheet = false
}
}
}
}
#Preview {
ContentView()
}
Is this a bug in the iOS 17 beta version or intended behavior? Is it possible to build a relationship between the View and ViewModel in a way where the ViewModel will be deinitialized after the View is dismissed?
Thank you in advance for the help.
I have a NavigationSplitView with a sidebar. When selecting a new item on the sidebar, the app crashes. The error message says:
Simultaneous accesses to 0x6000030107f0, but modification requires exclusive access.
Xcode shows that the crash occurs inside the generated code in my class with @Observable macro.
@ObservationIgnored private let _$observationRegistrar = Observation.ObservationRegistrar()
internal nonisolated func access<Member>(
keyPath: KeyPath<NavModel , Member>
) {
_$observationRegistrar.access(self, keyPath: keyPath)
}
internal nonisolated func withMutation<Member, MutationResult>(
keyPath: KeyPath<NavModel , Member>,
_ mutation: () throws -> MutationResult
) rethrows -> MutationResult {
// Crash occurs on the following line
try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
}
@ObservationIgnored private var _section: SidebarSection? = .one
To reproduce the crash, I tap a new item on the sidebar until the app crashes. It usually only takes 1-3 times selecting a new item before the crash occurs.
Below is the code for an entire app to reproduce the crash. Has anyone else encountered this issue? Thank you!
import SwiftUI
@main
struct NavigationBugApp: App {
var body: some Scene {
WindowGroup {
ContentView()
}
}
}
@Observable
class NavModel {
var section: SidebarSection? = .one
}
enum SidebarSection: Hashable {
case one
case two
}
struct ContentView: View {
@State private var model = NavModel()
var body: some View {
NavigationSplitView {
List(selection: $model.section) {
NavigationLink("One", value: SidebarSection.one)
NavigationLink("Two", value: SidebarSection.two)
}
.listStyle(.sidebar)
} detail: {
Text("Hello World")
}
}
}
#Preview {
ContentView()
}
Creating an Observable class in an Xcode playground seems to cause an error. This stops me from being able to run the playground.
As a demo, try creating a playground page and add:
import Foundation
import Observation // Doesn't seem to make a difference whether it's added or not.
@Observable public class NewViewModel: Observable {
var value: Int = 1
func increment() {
value += 1
}
}
Tapping the run button logs the following error (and then it builds successfully, buy fails silently):
error: Untitled Page.xcplaygroundpage:7:9: error: expansion of macro 'ObservationTracked()' did not produce a non-observing accessor
var value: Int = 1
^
Putting the cursor on @Observable and then selecting Editor > Expand Macro shows that value has been annotated with @ObservationTracked and I if I re-run the playground I can even see the @ObservationTracked generated code.
Macros:
import Foundation
import Observation // Doesn't seem to make a difference whether it's added or not.
@Observable public class NewViewModel: Observable {
@ObservationTracked
// original-source-range: /Users/gabriel.banfalvi/work/forums_observation/ObservationFramework.playground/Pages/Untitled Page.xcplaygroundpage:7:5-7:5
var value: Int = 1
{
@storageRestrictions(initializes: _value)
init(initialValue) {
_value = initialValue
}
get {
access(keyPath: \.value)
return _value
}
set {
withMutation(keyPath: \.value) {
_value = newValue
}
}
}
// original-source-range: /Users/gabriel.banfalvi/work/forums_observation/ObservationFramework.playground/Pages/Untitled Page.xcplaygroundpage:7:20-7:23
func increment() {
value += 1
}
@ObservationIgnored private let _$observationRegistrar = Observation.ObservationRegistrar()
internal nonisolated func access<Member>(
keyPath: KeyPath<NewViewModel, Member>
) {
_$observationRegistrar.access(self, keyPath: keyPath)
}
internal nonisolated func withMutation<Member, MutationResult>(
keyPath: KeyPath<NewViewModel, Member>,
_ mutation: () throws -> MutationResult
) rethrows -> MutationResult {
try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
}
@ObservationIgnored private var _value: Int = 1
// original-source-range: /Users/gabriel.banfalvi/work/forums_observation/ObservationFramework.playground/Pages/Untitled Page.xcplaygroundpage:12:1-12:1
}
I can't seem to be able to expand the @ObservationIgnored macros, which may or may not be related to the issue. I can't expand them in a regular Xcode app, but it doesn't lead to any problems there.
Im running an iOS playground. I get this in Xcodes 15 beta 6 and 5. I get a different error in earlier versions.