Why Aren't My UICollectionView Cells Updating Their Progress Label via KVO or Notifications?

Below are a few common pitfalls that can cause your cells not to update even though you see the progress change in your debug logs.

---

1. Placing the Observer Inside the Cell Provider

You’re adding a KVO observer inside the cell provider closure. This means that every time the diffable data source requests a cell, you’re creating a new observer that captures that specific cell instance. This approach is problematic because:

• The cell you update inside the observer closure might later be reused for a different index path.
• Only the last assigned observer (stored in “nameObservation”) is kept. When multiple cells are created, earlier observers aren’t retained—you may be updating a stale cell reference.

Solution: Instead of attaching a KVO observer to update a particular cell, update your model (progress) and then update the visible cells accordingly. For example, you can call collectionView.reloadItems(at: [indexPath]) on the changed item, or update the cell via a bound view-model mechanism.

---

2. Not Updating the Cell After Its Initial Configuration

Your approach sets the cell’s label when the cell is dequeued. Later when the progress property changes, the observer fires but only updates a reference to the cell stored when it was first configured. This design means that if the cell is reused or offscreen, the progress update might not be visible.

Solution: Update the UI through a mechanism that reliably tells the collection view which cell’s content needs updating. For example, when progress changes, update your data and then apply a new snapshot to your diffable data source—or simply update the visible cell if it’s still on screen.

---

3. Notification Variant and Re-Creating the Data Source

In your notification variant you call createDataSource when a notification comes in. Each time you do this, you create a new data source. That might create inconsistencies such as:

• The collection view’s current state being replaced.
• Losing references to previously visible cells.
• An empty snapshot if the data source isn’t configured with the latest snapshot data.

Solution: Use notifications to update your model (progress) and then reload the affected cells rather than recreating the entire data source when progress changes.

---

Recommended Approach

1. Observe Changes at the Controller Level:
   Instead of wiring observers into each cell configuration, update your progress property at the controller level and then tell the collection view to update the visible cells.

2. Reload the Specific Cells:
   For example, if you know which cell is relevant, you can update it directly after changing the progress:

   SWIFTCopied
   // When progress updates
   self.progress += 0.01
   if let indexPathToUpdate = /* the index path of the cell */ {
       collectionView.reloadItems(at: [indexPathToUpdate])
   }

   Or, if you’re using a diffable data source, update your snapshot with the new progress value for your item and apply it.

3. Keep Observers on Model, Not Cells:
   Keep the KVO (or use Combine if available) observer on your model or view controller level. When progress changes, update those cells that are visible. For example:

   SWIFTCopied
   // Instead of in cell configuration
   self.progressObservation = observe(\.progress, options: .new) { [weak self] _, change in
       guard let self = self, let newValue = change.newValue else { return }
       // Reload the visible cells that need to reflect the updated progress
       self.collectionView.visibleCells.forEach { cell in
           if let cell = cell as? CarouselCell {
               cell.title.text = "\(newValue)"
           }
       }
   }

4. Do Not Recreate the Data Source Upon Notification:
   Instead of recreating the data source, send update notifications that trigger a UI update (reload the specific cells or apply a new snapshot).

---

By separating the cell configuration from the progress observation and UI update, you ensure that the currently visible cells show up‐to‐date progress and you avoid pitfalls due to cell reuse or data source recreation.