Wrapping UIViewControllers in SwiftUI Views - Example

[jefflewis]

This was an old (3 years!) discussion on the swift forums that I came across wanting to make an address picker in my app. I posted my reply there with my solution, but thought it'd be useful here as well, since many 1st part APIs are still built with delegate callbacks and their own pickers.

Here's my "Contact Picker" that allows for selection of a single address for a contact and links back to a parent reducer with a binding of the value. My parent reducer hooks into the binding action for this property and applies the selected value into form fields I have available. The picker could be easily changed to select multiple properties or one or more contacts. The last registered delegate callback is the one this API uses as the method to use. Hope this helps someone else!

import ComposableArchitecture
import Contacts
import ContactsUI
import SwiftUI
import Dependencies
#if canImport(UIKit)
import UIKit
#endif

public enum ContactPickerError: Error {
  case cancelled
}

public struct ContactPicker: ReducerProtocol {
  public enum ContactResult: Equatable {
    case contact(CNContact)
    case contacts([CNContact])
    case property(CNContactProperty)
    case properties([CNContactProperty])
  }
  
  public struct State: Equatable {
    public init(
      result: Result<ContactPicker.ContactResult, ContactPickerError>? = nil
    ) {
      self.result = result
    }
    
    @BindableState var result: Result<ContactResult, ContactPickerError>? = nil
  }
  
  public enum Action: Equatable, BindableAction {
    case binding(BindingAction<State>)
  }
  
  public var body: some ReducerProtocol<State, Action> {
    BindingReducer()
  }
}

struct ContactPickerView: UIViewControllerRepresentable {
  @Environment(\.presentationMode) private var presentationMode

  func makeCoordinator() -> Coordinator {
    .init(
      presentation: presentationMode,
      result: viewStore.binding(\.$result)
    )
  }
  
  let store: StoreOf<ContactPicker>
  let viewStore: ViewStoreOf<ContactPicker>
  
  init(store: StoreOf<ContactPicker>) {
    self.store = store
    self.viewStore = ViewStore(store)
  }
  
  func makeUIViewController(
    context: Context
  ) -> CNContactPickerViewController {
    let cvc = CNContactPickerViewController()
    cvc.displayedPropertyKeys = [CNContactPostalAddressesKey]
    cvc.predicateForSelectionOfContact = NSPredicate(
      format: "postalAddresses.@count <= 1"
    )
    cvc.modalPresentationStyle = .currentContext
    cvc.delegate = context.coordinator
    return cvc
  }
    
  func updateUIViewController(
    _ uiViewController: CNContactPickerViewController,
    context: Context)
  {}
  
  class Coordinator: NSObject, CNContactPickerDelegate {
    var presentation: Binding<PresentationMode>
    var result: Binding<Result<ContactPicker.ContactResult, ContactPickerError>?>
    
    init(
      presentation: Binding<PresentationMode>,
      result: Binding<Result<ContactPicker.ContactResult, ContactPickerError>?>)
    {
      self.presentation = presentation
      self.result = result
    }
    
//    func contactPicker(
//      _ picker: CNContactPickerViewController,
//      didSelectContactProperties contactProperties: [CNContactProperty]
//    ) {
//      self.result.wrappedValue = .success(.properties(contactProperties))
//    }
    
//    func contactPicker(
//      _ picker: CNContactPickerViewController,
//      didSelect contact: CNContact
//    ) {
//      self.result.wrappedValue = .success(.contact(contact))
//    }

    func contactPicker(
      _ picker: CNContactPickerViewController,
      didSelect contactProperty: CNContactProperty
    ) {
      self.result.wrappedValue = .success(.property(contactProperty))
    }

//    func contactPicker(
//      _ picker: CNContactPickerViewController,
//      didSelect contacts: [CNContact]
//    ) {
//      self.result.wrappedValue = .success(.contacts(contacts))
//    }

    func contactPickerDidCancel(_ picker: CNContactPickerViewController) {
      self.result.wrappedValue = .failure(.cancelled)
    }
  }
}

[fsterg]

Thanks for this example!

I have a very complicated UIViewController and currently trying to use a TCA "shell" around it (sample repo here).

I can't understand if it's possible to call one of the UIViewController's functions from a TCA action, and what's even worse, use a dependency inside that function's callback.

For example, my view controller has a function like this:

func startDragging(_ string: String, shouldDrop: @escaping (Int) -> Bool) {
    // The actual code passes a CGPoint instead of a random location
    let randomLocation = Int.random(in: 0...10)
    if shouldDrop(randomLocation) {
        label.text = "dropped"
    } else {
        label.text = "can't drop"
    }
}

and on the SwiftUI side I'd like to do something like this:

uiViewController.startDragging(viewStore.string) { location in
    return client.canDrop(viewStore.string, location) < - - - - - - - - - - client is a @Dependency
}

From which part of the SwiftUI code should I be calling startDragging with some piece of state? (in the example I'm doing this within func updateUIViewController but that seems wrong).

And more importantly, how could I use a dependency's result in that callback?