AppStore.manageSubscriptionsSheet and the main thread

[seanmrich]

I was having an issue using SwiftUI's AppStore.manageSubscriptionsSheet(isPresented:subscriptionGroupID:) provided by StoreKit. The underlying sheet logic accesses the binding on a background thread. This brings up a purple runtime warning from TCA about interacting with a Store when not on the main thread. Thank goodness for this warning because I wouldn't have expected this to happen on a background thread.

Here's my setup. I added an item to my destination enum and a computed property to my State to accommodate the isPresented parameter.

@Reducer
struct Feature {
  @Reducer
  enum Destination {
    case manageSubscriptions
    …
  }

  @ObservableState
  struct State {
    var destination: Destination.State?
    var showManageSubscriptions: Bool {
      get {
        destination == .manageSubscriptions
      }
      set {
        if newValue == false {
          destination = nil
        }
      }
    }
  }

  enum Action: BindableAction {
    case binding(BindingAction<State>)
    case destination(PresentationAction<Destination.Action>)
    case manageButtonTapped
    …
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in 
      switch action {
        case .binding, .destination: 
          return .none
        case .manageButtonTapped:
          state.destination = .manageSubscriptions
          return .none
      }
    }
  }
}

Then I included the modifier in my view.

struct FeatureView: View {
  @Bindable var store: StoreOf<Feature>

  var body: some View {
    …
    .manageSubscriptionsSheet(
      isPresented: $store.showManageSubscriptions,
      subscriptionGroupID: "my id"
    )
  }
}

I used assert(Thread.mainThread) in the showManageSubscriptions property to verify both the get and set were being called on a background thread. To get around this, I took over the binding logic myself by wrapping the UIKit version of the api which is the showManageSubscriptions(in:subscriptionGroupID:) method.

struct ManageSubscription<Item>: UIViewRepresentable {
  @Binding var item: Item?
  let subscriptionGroupId: String
  
  func makeUIView(context: Context) -> UIView {
    UIView()
  }
  
  func updateUIView(_ uiView: UIView, context: Context) {
    guard
      item != nil,
      let scene = uiView.window?.windowScene
    else { return }
    
    Task {
      // Error handling not illustrated
      try await AppStore.showManageSubscriptions(
        in: scene,
        subscriptionGroupID: subscriptionGroupId
      )
      // Method returns when sheet is dismissed so destination can return to nil
      item = nil
    }
  }
}

extension View {
  func manageSubscriptionsSheet<Item>(
    item: Binding<Item?>,
    subscriptionGroupID groupId: String
  ) -> some View {
    background {
      ManageSubscription(item: item, subscriptionGroupId: groupId)
    }
  }
}

This method avoids the main thread issue and also presents a more TCA-friendly interface that avoids the computed property in State.

.manageSubscriptionsSheet(
  item: $store.scope(
    state: \.destination?.manageSubscriptions,
    action: \.destination.manageSubscriptions
  ),
  subscriptionGroupID: .subscriptionId
)

[mbrandonw]

Hi @seanmrich, thanks for sharing! It seems quite strange for manageSubscriptionsSheet to interact with the binding on a background thread, but glad you found a workaround.

[zachwaugh]

As of Xcode 16/iOS 18.0.1, this is not just a warning but is crashing my app here:

Here's a full repro just for completeness:

@Reducer
struct ManageSubscription {
    @ObservableState
    struct State: Equatable {
        var isPresented: Bool = false
    }

    enum Action: BindableAction {
        case buttonTapped
        case binding(BindingAction<State>)
    }

    var body: some ReducerOf<Self> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            case .buttonTapped:
                state.isPresented = true
                return .none

            case .binding:
                return .none
            }
        }
    }
}

struct ManageSubscriptionView: View {
    @Bindable var store: StoreOf<ManageSubscription>

    var body: some View {
        VStack {
            Button("Manage Subscription") {
                store.send(.buttonTapped)
            }
        }
        .manageSubscriptionsSheet(isPresented: $store.isPresented)
    }
}

Though it certainly seems like a SwiftUI/StoreKit bug, not sure if there is any way to workaround it in TCA?

My simple workaround for now is just to sync a local @State var isPresented with the Store:

struct ManageSubscriptionView: View {
    @Bindable var store: StoreOf<ManageSubscription>
    @State private var isPresented: Bool = false

    var body: some View {
        VStack {
            Button("Manage Subscription") {
                store.send(.buttonTapped)
            }
        }
        .manageSubscriptionsSheet(isPresented: $isPresented)
        .onChange(of: store.isPresented) { _, newValue in
            isPresented = newValue
        }
    }
}

[mbrandonw]

Hi @zachwaugh, thanks for sharing this repro. And unfortunately you are right, this is definitely a StoreKit problem. Here is a vanilla SwiftUI reproduction of the problem:

import StoreKit

@Observable
@MainActor
class Model {
  var isPresented = false {
    didSet { print("Thread.isMainThread", Thread.isMainThread) }
  }
}

struct ManageSubscriptionView: View {
  @Bindable var model = Model()

  var body: some View {
    VStack {
      Button("Manage Subscription") {
        model.isPresented = true
      }
    }
    .manageSubscriptionsSheet(isPresented: $model.isPresented)
  }
}

Even though the Model is marked as @MainActor, the manageSubscriptionsSheet modifier is doing some unsafe stuff under the hood to interact with it on a non-main thread.

We probably could have a tech note that describes how to work around these things in practice. The @State trick works because it is apparently thread safe, whereas observable models (like stores) are not.

[seanmrich]

Note that refundRequestSheet has the same issue. I worked around it by wrapping Transaction.beginRefundRequest(in:) similar to my solution above. The @State dance may be simpler though.

[wshamp]

Looks like doing something like this works as well.

.bind($store.isPresented, to: self.$isPresented)

.manageSubscriptionsSheet(isPresented: $isPresented)