Double Bindings - iOS 15

[jtouzy]

After some tests on our app on iOS 15 / TCA, we discovered that all bindings values are always emitted twice.
It's not a TCA-related problem, but it looks like binding system has changed in iOS 15.
Did you heard anything about that ?

A simple code to reproduce, in TCA & Vanilla SwiftUI :
Tested on iOS 14, bindings are emitted only once.

import ComposableArchitecture
import SwiftUI

//
// App with TCA / Vanilla SwiftUI versions
//

@main
struct TestDoubleBindingsApp: App {
  var body: some Scene {
    WindowGroup {
      VStack {
        SwiftUIVersionView(
          viewModel: .init(textValue: "")
        )
        ContentView(
          store: .init(
            initialState: .init(textValue: ""),
            reducer: reducer,
            environment: .init()
          )
        )
      }
    }
  }
}

//
// TCA version
//

struct ContentState: Equatable {
  var textValue: String
}
enum ContentAction {
  case textUpdated(String?)
}
struct ContentEnvironment {
}
let reducer = Reducer<ContentState, ContentAction, ContentEnvironment> { state, action, environment in
  switch action {
  case .textUpdated(let text):
    // This will be called twice for each typed character
    print("Text updated \(text)")
    state.textValue = text ?? ""
  }
  return .none
}
struct ContentView: View {
  let store: Store<ContentState, ContentAction>

  var body: some View {
    WithViewStore(store) { viewStore in
      TextField(
        "Test",
        text: viewStore.binding(
          get: \.textValue,
          send: ContentAction.textUpdated
        )
      )
    }
  }
}

//
// Native SwiftUI version
//

class ViewModel: ObservableObject {
  @Published var textValue: String {
    didSet {
      // This will be called twice for each typed character
      print("Text updated \(textValue)")
    }
  }
  init(textValue: String) {
    self.textValue = textValue
  }
}
struct SwiftUIVersionView: View {
  @ObservedObject var viewModel: ViewModel

  var body: some View {
    TextField(
      "Test",
      text: $viewModel.textValue
    )
  }
}

And it's worse than that ! If you ever set the bound property in your reducer on a different action for example, it will emit a new textUpdated action automatically on update, because binding is also triggered after that : before iOS 15, it was not.

[stephencelis]

This is an unfortunate behavior change in SwiftUI that we've filed feedback for, and I encourage you to do the same. As you mention it affects vanilla SwiftUI, as well, but has a greater potential to be noticed by a TCA app. These potential extra emissions have always been present in SwiftUI, but they've grown to affect many more APIs with the latest release.

As far as we can tell the best way to work around the problem is to add a removeDuplicates() helper to Binding:

extension Binding where Value: Equatable {
  func removeDuplicates() -> Self {
    .init(
      get: { self.wrappedValue },
      set: { newValue, transaction in
        guard newValue != self.wrappedValue else { return }
        self.transaction(transaction).wrappedValue = newValue
      }
    )
  }
}

(Thanks to @iampatbrown for the transaction logic that helps binding animations work as one would expect.)

You could introduce a removeDuplicates(by:) version if you deal with a field that isn't equatable.

It is possible for ViewStore.binding helpers to do a little work here to remove duplicates automatically, but we're not sure it's the right move to make. We'll do some thinking on that, but at least there's a workaround in the meantime!

[stephencelis]

@iampatbrown We've also seen double writes in NavigationLink, though we forget the exact circumstances. We'll try to keep an eye out though!

[iampatbrown]

Pretty strange. I can't imagine it's the intended behaviour. I'll keep an eye out too.

[humblehacker]

I just ran into this with a fullScreenCover isPresented binding. When the modal is dismissed and the bound state variable is reset in my reducer, it causes the action to fire again. It took me quite a while to even determine what to look for and finally arrive here. Though the addition of removeDuplicates() does work around the issue, I think we really need a proper solution in the binding methods themselves, since the extra emissions lead to some difficult to debug problems.

Is there a downside to performing the deduplication from within the binding?

[mbrandonw]

Hi @humblehacker, we are worried about baking removeDuplicates deeply into the library just to work around some SwiftUI bugs. If we force removeDuplicates on all bindings vended by viewStore.binding, then what if there is a situation where it is actually legitimate to write the same value to a binding? Then those actions will be lost, and it will be the library's fault, not SwiftUI's.

We think the best course of action is for everyone to file their own feedbacks with Apple (you can use ours as a template), and to vend the .removeDuplicates operator yourself and use it where necessary.

[humblehacker]

Thanks for the rationale. I see your point. I'll file a feedback as well.

[yuanhang]

There is another workaround I know. Just append .textFieldStyle(.plain) to TextField() and the problem would go (tested on Xcode 14.2).