How to implement delegate methods that returns value?

[wynioux]

Let's say we want to use CoreLocation, we need to wrap CLLocationManager and register it as a dependency, as written in the dependency documentation.

In this case how can we implement CLLocationManagerDelegate.locationManagerShouldDisplayHeadingCalibration(_ manager: CLLocationManager) -> Bool and get return value from reducer?

Note: ComposableCoreLocation did not implement this method, and does not provide any examples.

Interface:

@DependencyClient
public struct LocationManagerClient {
    var delegate: @Sendable () -> AsyncStream<Action> = { AsyncStream { _ in } }
    ...

    @CasePathable
    public enum Action {
        ...
        case didUpdateLocations(locations: [Location])
        case shouldDisplayHeadingCalibration <---
        case didDetermineState(state: CLRegionState, for: CLRegion)
        ...
    }
}

Live:

extension LocationManagerClient: DependencyKey {
    public static var liveValue: LocationManagerClient {
        let actor = LocationManagerActor.shared
        let delegate = LocationManagerDelegate.shared
        let manager = CLLocationManager()
        manager.delegate = delegate

        return LocationManagerClient(
            delegate: {
                AsyncStream<Action> { continuation in
                    Task { @LocationManagerActor in
                        await actor.add(continuation)
                    }
                }
            },
            ...
        )
    }
}

Actor:

extension LocationManagerClient {
    @globalActor final actor LocationManagerActor {
        static let shared = LocationManagerActor()
        private var continuations: [UUID: AsyncStream<Action>.Continuation] = [:]

        private init() {}

        private func remove(identifier: UUID) {
            continuations.removeValue(forKey: identifier)
        }

        func add(_ continuation: AsyncStream<Action>.Continuation) {
            let identifier = UUID()
            continuations[identifier] = continuation

            continuation.onTermination = { [weak self] _ in
                Task { await self?.remove(identifier: identifier) }
            }
        }

        func yield(_ action: Action) {
            continuations.values.forEach { $0.yield(action) }
        }
    }
}

Delegate:

extension LocationManagerClient {
    final class LocationManagerDelegate: NSObject, CLLocationManagerDelegate {
        static let shared = LocationManagerDelegate()
        private let actor: LocationManagerActor

        init(actor: LocationManagerActor = .shared) {
            self.actor = actor
            super.init()
        }

        ...

        func locationManager(
            _ manager: CLLocationManager,
            didUpdateHeading newHeading: CLHeading
        ) {
            Task { @LocationManagerActor in
                await actor.yield(.didUpdateHeading(newHeading: newHeading))
            }
        }

        func locationManagerShouldDisplayHeadingCalibration(_ manager: CLLocationManager) -> Bool {
            Task { @LocationManagerActor in
                await actor.yield(.shouldDisplayHeadingCalibration) <---
            }

            return true <---
        }

        func locationManager(
            _ manager: CLLocationManager,
            didDetermineState state: CLRegionState,
            for region: CLRegion
        ) {
            Task { @LocationManagerActor in
                await actor.yield(.didDetermineState(
                    state: state,
                    for: region
                ))
            }
        }

        ...
    }
}

[lukeredpath]

If you need the return value for this delegate method to be dynamic, then your client needs to provide an API for callers to set what this value should be. This could be, for example:

var shouldDisplayHeadingCalibration: (Bool) -> Void

Your live implementation could pass in a closure that stores the parameter in a locally accessible value that can be read by the delegate class - e.g. a LockIsolated reference.

Alternatively, you could introduce a dependency value and read that from within your live implementation. It depends what makes most sense for your use case.

[wynioux]

Can you provide small example?

[lukeredpath]

I'll try my best. Lets assume your live delegate class has a property:

final class LocationDelegate {
  var shouldDisplayHeadingCalibration = false

  func locationManagerShouldDisplayHeadingCalibration(_ manager: CLLocationManager) -> Bool {
        return shouldDisplayHeadingCalibration
  }
}

Your client might have a closure that can update this value, for example:

extension LocationManagerClient: DependencyKey {
    public static var liveValue: LocationManagerClient {
        let actor = LocationManagerActor.shared
        let delegate = LocationManagerDelegate.shared
        let manager = CLLocationManager()
        manager.delegate = delegate

        return LocationManagerClient(
            delegate: {
                AsyncStream<Action> { continuation in
                    Task { @LocationManagerActor in
                        await actor.add(continuation)
                    }
                },
                shouldDisplayHeadingCalibration: { delegate.shouldDisplayHeadingCalibration = $0 }
            },
            ...
        )
    }
}

[wynioux]

Thank you for the example!