@ObservedObject in iOS Swift - Mini App: Build & Ship

Build: Counter Screen

A simple screen that shows a number and a button to increase it. The number updates automatically using @ObservedObject to watch changes.

Target UI

-------------------
|   Counter: 0    |
|                 |
|   [ Increase ]  |
-------------------

Create a class CounterModel that holds an integer count and can increase it.

Use @Published in CounterModel to notify changes.

Create a SwiftUI view that uses @ObservedObject to watch CounterModel.

Display the current count in a Text view.

Add a Button labeled 'Increase' that calls the increase method in CounterModel.

Starter Code

iOS Swift

import SwiftUI

class CounterModel: ObservableObject {
    // TODO: Add @Published count property and increase method
}

struct CounterView: View {
    // TODO: Add @ObservedObject property for CounterModel
    
    var body: some View {
        VStack {
            // TODO: Show count here
            // TODO: Add Increase button here
        }
        .padding()
    }
}

struct CounterView_Previews: PreviewProvider {
    static var previews: some View {
        CounterView()
    }
}

Task 1

Task 2

Task 3

Task 4

Task 5

Solution

iOS Swift

import SwiftUI

class CounterModel: ObservableObject {
    @Published var count = 0
    
    func increase() {
        count += 1
    }
}

struct CounterView: View {
    @ObservedObject var counter = CounterModel()
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Counter: \(counter.count)")
                .font(.largeTitle)
            Button("Increase") {
                counter.increase()
            }
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
        .padding()
    }
}

struct CounterView_Previews: PreviewProvider {
    static var previews: some View {
        CounterView()
    }
}

We created CounterModel as a class conforming to ObservableObject. The @Published property count automatically notifies views when it changes. In CounterView, we use @ObservedObject to watch an instance of CounterModel. The Text shows the current count, and the Button calls increase() to update the count. SwiftUI updates the UI automatically when count changes.

Final Result

Completed Screen

-------------------
|   Counter: 0    |
|                 |
|   [ Increase ]  |
-------------------

When the user taps 'Increase', the number after 'Counter:' increases by 1.

The UI updates immediately without needing to refresh manually.

Stretch Goal

Add a 'Reset' button that sets the counter back to zero.

💡 Hint

Add a reset() method in CounterModel that sets count to 0, then add a Button in the view that calls reset().

Practice

1. What is the main purpose of using @ObservedObject in a SwiftUI view?

easy

A. To watch an external data object and update the view when it changes

B. To create a new data object inside the view

C. To store a constant value that never changes

D. To handle user input events like taps and swipes

Solution

1. Step 1: Understand the role of @ObservedObject

   @ObservedObject is used to watch an external data object for changes.

2. Step 2: Connect data changes to UI updates

   When the observed object changes, the SwiftUI view automatically updates to reflect those changes.

3. Final Answer:

   To watch an external data object and update the view when it changes -> Option A

4. Quick Check:

   @ObservedObject = watch external data [OK]

Hint: Remember: @ObservedObject watches data outside the view [OK]

Common Mistakes:

• Confusing @ObservedObject with @State which owns data inside the view
• Thinking @ObservedObject creates new data instead of observing
• Using @ObservedObject for constant values

2. Which of the following is the correct way to declare an observed object in a SwiftUI view?

easy

A. @ObservedObject var model: MyModel

B. @ObservedObject var model: MyModel = MyModel()

C. @ObservedObject model = MyModel()

D. @ObservedObject var model: MyModel?

Solution

1. Step 1: Understand @ObservedObject declaration

   @ObservedObject properties are typically declared without initialization in the view, expecting the instance to be injected.

2. Step 2: Check syntax correctness

   @ObservedObject var model: MyModel is the correct declaration; initializing it inside the view is not recommended.

3. Final Answer:

   @ObservedObject var model: MyModel -> Option A

4. Quick Check:

   Declare @ObservedObject without initialization for injection [OK]

Hint: Declare @ObservedObject properties without initializing inside the view [OK]

Common Mistakes:

• Initializing @ObservedObject inside the view
• Omitting the var keyword
• Using optional type without proper handling

3. Given the code below, what will be the output when the button is tapped?

class Counter: ObservableObject {
  @Published var count = 0
}

struct ContentView: View {
  @ObservedObject var counter = Counter()
  var body: some View {
    VStack {
      Text("Count: \(counter.count)")
      Button("Increment") {
        counter.count += 1
      }
    }
  }
}

medium

A. The app crashes due to missing @State

B. The text never updates and stays at 0

C. The text updates to show the incremented count each tap

D. The button does not respond to taps

Solution

1. Step 1: Understand @Published and @ObservedObject interaction

   The Counter class publishes changes to its count property.

2. Step 2: Observe how the view updates

   The ContentView observes the counter object, so when count changes, the Text updates automatically.

3. Final Answer:

   The text updates to show the incremented count each tap -> Option C

4. Quick Check:

   @Published + @ObservedObject = UI updates [OK]

Hint: @Published properties trigger view updates via @ObservedObject [OK]

Common Mistakes:

• Thinking @ObservedObject alone updates UI without @Published
• Confusing @State with @ObservedObject
• Assuming UI updates require manual refresh

4. Identify the error in this SwiftUI view using @ObservedObject:

class TimerModel: ObservableObject {
  @Published var time = 0
}

struct TimerView: View {
  @ObservedObject var timer: TimerModel
  var body: some View {
    Text("Time: \(timer.time)")
  }
}

medium

A. The TimerModel class is missing ObservableObject conformance

B. The @ObservedObject property is not initialized

C. The @Published property should be private

D. The Text view syntax is incorrect

Solution

1. Step 1: Check class conformance

   TimerModel correctly conforms to ObservableObject.

2. Step 2: Check @ObservedObject initialization

   The timer property is declared but not initialized, causing a compile error.

3. Final Answer:

   The @ObservedObject property is not initialized -> Option B

4. Quick Check:

   @ObservedObject must be initialized or injected [OK]

Hint: Always initialize or inject @ObservedObject properties [OK]

Common Mistakes:

• Forgetting to initialize @ObservedObject
• Assuming @Published must be private
• Misreading Text string interpolation

5. You have a parent view that creates a Settings object and passes it to two child views. Which is the best way to share this data so both children update when settings change?

hard

A. Use @EnvironmentObject in children without passing from parent

B. Create separate @ObservedObject instances in each child view

C. Use @State in the parent and @Binding in children for the settings

D. Declare @ObservedObject in both child views and pass the same Settings instance from the parent

Solution

1. Step 1: Understand data sharing with @ObservedObject

   Passing the same instance to children with @ObservedObject keeps them in sync.

2. Step 2: Evaluate other options

   Creating separate instances duplicates data; @State/@Binding is for simple values; @EnvironmentObject requires environment setup.

3. Final Answer:

   Declare @ObservedObject in both child views and pass the same Settings instance from the parent -> Option D

4. Quick Check:

   Share one @ObservedObject instance for synced updates [OK]

Hint: Pass one @ObservedObject instance to children for shared updates [OK]

Common Mistakes:

• Creating multiple instances causing unsynced data
• Confusing @Binding with @ObservedObject for complex objects
• Using @EnvironmentObject without setup