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
                ))
            }
        }

        ...
    }
}