Invoking MapView method with multiple parameters

[josephktcheung]

Hi,

Referring to the example MapView, I'd like to ask how can we support setting a map region with animated parameter not default to true https://github.com/pointfreeco/composable-core-location/blob/main/Examples/LocationManager/Common/MapView.swift#L55.

Why I ask this is recently we face an issue of interoperating UIKit view and SwiftUI view. We want the SwiftUI view to be able to call UIKit view method e.g. setRegion with multiple parameters. One school of thought is to add a setRegionAnimated variable to MapView like this:

public struct MapView: ViewRepresentable {
  let pointsOfInterest: [PointOfInterest]
  @Binding var region: CoordinateRegion?
  var setRegionAnimated: Bool

  public init(
    pointsOfInterest: [PointOfInterest],
    region: Binding<CoordinateRegion?>,
    setRegionAnimated: Bool
  ) {
    self.pointsOfInterest = pointsOfInterest
    self._region = region
    self.setRegionAnimated = setRegionAnimated
  }
  ...
  private func updateView(mapView: MKMapView, delegate: MKMapViewDelegate) {
    mapView.delegate = delegate

    if let region = self.region {
      mapView.setRegion(region.asMKCoordinateRegion, animated: setRegionAnimated)
  }
  ...
}

Then in LocationManagerView:

  var body: some View {
    WithViewStore(self.store) { viewStore in
      ZStack {
        MapView(
          pointsOfInterest: viewStore.pointsOfInterest,
          region: viewStore.binding(get: { $0.region }, send: AppAction.updateRegion),
          setRegionAnimated: viewStore.setRegionAnimated
        )
    ...

However this would make the view to be flooded with variables and we may forget to update the state (let's say we turned off animation temporarily but forget to turn it back on). Also one would argue that animated parameter is a transient state which should not be stored as binding / persisted state / variable like region.

An alternative is to create a PassthroughSubject to communicate parameter changes between SwiftUI and UIKit view:

public struct MapView: ViewRepresentable {
  let pointsOfInterest: [PointOfInterest]
  var setRegion: PassthroughSubject<(CoordinateRegion, Bool), Never>
  @State var cancellable: AnyCancellable? = nil

  public init(
    pointsOfInterest: [PointOfInterest],
    setRegion: PassthroughSubject<(CoordinateRegion, Bool), Never>
  ) {
    self.pointsOfInterest = pointsOfInterest
    self.setRegion = setRegion
  }
  ...
  private func makeView(context: Context) -> MKMapView {
    let mapView = MKMapView(frame: .zero)
    mapView.showsUserLocation = true
    // subscribe to passthrough subject event
    DispatchQueue.main.async {
      self.cancellable = setRegion.sink { (region, animated) in
        mapView.setRegion(region.asMKCoordinateRegion, animated)
      }
    }
    return mapView
  }

  private func updateView(mapView: MKMapView, delegate: MKMapViewDelegate) {
    mapView.delegate = delegate
  ...
  public func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
    // self.mapView.region = CoordinateRegion(coordinateRegion: mapView.region)
   self.mapView.setRegion(CoordinateRegion(coordinateRegion: mapView.region), animated)
  }
}

Then in LocationManagerView:

struct LocationManagerView: View {
  @Environment(\.colorScheme) var colorScheme
  let store: Store<AppState, AppAction>
  private var setRegion = PassthroughSubject<(CoordinateRegion, Bool), Never>()

  var body: some View {
    WithViewStore(self.store) { viewStore in
      ZStack {
        MapView(
          pointsOfInterest: viewStore.pointsOfInterest,
          setRegion: setRegion
        )
        .edgesIgnoringSafeArea([.all])
        ...
        Button("Change region") {
           setRegion.send(viewStore.region, true)
        }

However this approach doesn't utilise viewStore's binding and feels like an alien to TCA.

I think this question is common when integrating a UIKit view into SwiftUI. How would one design a bridging view API interface so that it can be consumed easily using TCA when we want to allow library users to invoke UIKit view methods that take multiple parameters (some may better be binding / persisted state e.g. region, while some are just one-off e.g. animated).

Thanks,
Joseph