CLLocationManagerDelegate is never called

[naldal]

hello
I am facing an issue where I am not returning the changed CLAuthorisationStatus after the user has made a selection for location permissions.

I'm not sure if this is a problem caused by using TCA incorrectly, but it's very strange that the Delegate is not called logically.

This is where the reducer is first called

struct ContentView: View {
  
  // MARK: - private property
  
  // MARK: - internal property
  
  @Perception.Bindable var store: StoreOf<MapReducer>
  
  var body: some View {
    KakaoMapView(
      draw: $store.isMapDraw,
      userLocation: Binding(
        get: { store.userLocation },
        set: { newValue in
          store.send(.setUserLocation(newValue.map { CLLocationCoordinate2D(latitude: $0.latitude, longitude: $0.longitude) }!))
        }
      )
    )
    .onAppear(perform: {
      self.store.send(.setDrawMap(true))
    })
    .onDisappear(perform: {
      self.store.send(.setDrawMap(false))
    })
    .task {
      self.store.send(.checkUserAuthorization) <--------- here!
    }
}

And let me show you the Reducer code.

import Combine
import Foundation
import CoreLocation
import AppFoundation
import ComposableArchitecture

@Reducer
public struct MapReducer {
  
  @ObservableState
  public struct State: Equatable {
    public static func == (lhs: MapReducer.State, rhs: MapReducer.State) -> Bool {
      return lhs.userLocation?.latitude == rhs.userLocation?.latitude &&
      lhs.userLocation?.longitude == rhs.userLocation?.longitude
    }
    public var error: MercuryError?
    public var userLocation: CLLocationCoordinate2D?
    public var isShowAlert: Bool = false
    public var isMapDraw: Bool = true
    
    public init() { }
  }
  
  public enum Action: BindableAction {
    case binding(BindingAction<State>)
    case setError(MercuryError)
    case setDrawMap(Bool)
    case checkUserAuthorization
    case setAuthenticationStatus(CLAuthorizationStatus)
    case locationAuthorizationChanged(CLAuthorizationStatus)
    case requestLocationAuthentication
    case showAlert
    case setUserLocation(CLLocationCoordinate2D)
    case locationUpdated(CLLocation)
    
  }
  
  // MARK: - private property
  
  @Dependency(\.userLocationUsecase) private var userLocationUsecase
  
  
  // MARK: - life cycle
  
  public init() {
    
  }
  
  public var body: some ReducerOf<Self> {
    BindingReducer()
    Reduce { state, action in
      switch action {
      case .binding(_):
        return .none
      case .setError(let error):
        state.error = error
        return .none
      case .setDrawMap(let isDraw):
        state.isMapDraw = isDraw
        return .none
      case .checkUserAuthorization:
        return .run { send in
          let status = await self.userLocationUsecase.userAuthorization()
          await send(.setAuthenticationStatus(status))
        }
      case .setAuthenticationStatus(let status):
        switch status {
        case .notDetermined, .restricted:
          return .send(.requestLocationAuthentication)
        case .denied:
          return .send(.showAlert)
        case .authorizedAlways, .authorizedWhenInUse:
          let userLocation = self.userLocationUsecase.userCurrentLocation()
          guard let coordinate = userLocation?.coordinate else {
            return .send(.setError(.init(from: .ownModule(.map), .failToGetUserLocationCoordinate)))
          }
          return .send(.setUserLocation(coordinate))
        @unknown default:
          return .send(.setError(.init(from: .ownModule(.map), .unknownLocationAuthenticationStatus)))
        }
      case .requestLocationAuthentication:
        return .run { @MainActor send in
          let status = await self.userLocationUsecase.requestUserAuthorization()
          send(.locationAuthorizationChanged(status))
        }
      case .locationAuthorizationChanged(let status):
        return .run { send in
          switch status {
          case .authorizedAlways, .authorizedWhenInUse:
            do {
              let location = try await self.userLocationUsecase.startUpdatingLocation()
              await send(.locationUpdated(location))
            } catch {
              await send(.setError((error as? MercuryError) ?? .init(from: .ownModule(.map), .unknown)))
            }
          default:
            break
          }
        }
      case .showAlert:
        state.isShowAlert = true
        return .none
      case .setUserLocation(let location):
        state.userLocation = location
        return .none
      case .locationUpdated(let location):
        state.userLocation = location.coordinate
        return .none
      }
    }
  }
  
}

To show you the internals of @dependency(.userLocationUsecase) private var userLocationUsecase in this code,

import Foundation
import ComposableArchitecture
import DomainInterface
import Domain

private enum UserLocationUsecaseKey: @preconcurrency DependencyKey {
  @MainActor static let liveValue: UserLocationUsecase = UserLocationUsecaseImplement()
}

extension DependencyValues {
  var userLocationUsecase: UserLocationUsecase {
    get { self[UserLocationUsecaseKey.self] }
    set { self[UserLocationUsecaseKey.self] = newValue }
  }
}

Finally, the code for the UserLocationUsecaseImplement

import AppFoundation
import Foundation
import CoreLocation
import DomainInterface

@MainActor
public final class UserLocationUsecaseImplement: NSObject, @preconcurrency UserLocationUsecase {
  
  // MARK: - private property

  private var authStatusContinuation: CheckedContinuation<CLAuthorizationStatus, Never>?
  private var updatedLocationContinuation: CheckedContinuation<CLLocation, Error>?
  
  
  // MARK: - public property
  
  @MainActor
  public var locationManager: CLLocationManager = CLLocationManager()
  
  
  // MARK: - life cycle
  
  @MainActor
  public override init() {
    super.init()
    self.locationManager.delegate = self
    self.locationManager.desiredAccuracy = kCLLocationAccuracyBest
  }
   
  deinit {
    print("\(self) is deinited.")
  }
  
  // MARK: - public method

  public func userAuthorization() -> CLAuthorizationStatus {
    return self.locationManager.authorizationStatus
  }

  public func userCurrentLocation() -> CLLocation? {
    return self.locationManager.location
  }
  
  public func requestUserAuthorization() async -> CLAuthorizationStatus {
    let currentStatus = locationManager.authorizationStatus
    if currentStatus != .notDetermined {
      return currentStatus
    }
    return await withCheckedContinuation { continuation in
      self.authStatusContinuation = continuation
      locationManager.requestWhenInUseAuthorization()
    }
  }
}

@MainActor
extension UserLocationUsecaseImplement: @preconcurrency CLLocationManagerDelegate {
  
  public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { <------ never called !! :o 
    let status = manager.authorizationStatus
    print("Authorization status changed to: \(status)")
    
    if let continuation = self.authStatusContinuation {
      continuation.resume(returning: status)
      self.authStatusContinuation = nil
    }
  }
  
  public func startUpdatingLocation() async throws -> CLLocation {
    self.locationManager.startUpdatingLocation()
    let location = try await withCheckedThrowingContinuation({ continuation in
      updatedLocationContinuation = continuation
    })
    return location
  }
  
  public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
    if let location = locations.last {
      updatedLocationContinuation?.resume(returning: location)
      updatedLocationContinuation = nil
    }
  }
  
  @nonobjc public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
    updatedLocationContinuation?.resume(throwing: MercuryError(from: .ownModule(.map), .unknown))
    updatedLocationContinuation = nil
  }
}

I put in a lot of MainActors because earlier discussions(#1743) indicated that the creation of the CLLocationManager should happen in the MainThread.

What did I miss? I'd love to hear your thoughts
Thank you!

[naldal]

I found what the problem was: I had marked public override init() in the main actor annotation, but it wasn't actually running on the main thread. So I initialised the CLLocationManager in a lazy var and annotated the lazy var with the MainActor annotation.