CLGeocoder() 意外返回 nil

Question

我有一个位置列表（大约 30 个元素）：

var locations: [CLLocation] = [
        CLLocation(latitude: 45.471172, longitude: 9.163317),
        ...
]

我的目的是从该列表中获取街道名称，因此我决定使用CLGeocoder()。 我在viewDidLoad() 中调用了一个函数，每个位置都由lookUpCurrentLocation() 处理。

override func viewDidLoad() {
    super.viewDidLoad()       

        for location in locations {
            lookUpCurrentLocation(location: location, completionHandler: { streetName in
            print(streetName)
        })
    }

}

func lookUpCurrentLocation(location: CLLocation, completionHandler: @escaping (String?) -> Void) {
    CLGeocoder().reverseGeocodeLocation(location, completionHandler: { (placemarks, error) in
            let placemark = placemarks?[0]
            completionHandler(placemarks?[0].name)
    })
}

我的问题： 当应用程序启动时，它会打印一个 nil 列表或仅打印前两个 nil 和其他街道名称。

terminal image 1

terminal image 2

我希望看到整个列表在没有任何 nil 的情况下得到处理。 有什么提示吗？

Answer 1

正如 Leo 所说，您不想同时运行请求。正如the documentation 所说：

发起反向地理编码请求后，请勿尝试发起另一个反向或正向地理编码请求。每个应用程序的地理编码请求都有速率限制，因此在短时间内发出过多请求可能会导致某些请求失败。当超过最大速率时，地理编码器会将值为 CLError.Code.network 的错误对象传递给您的完成处理程序。

有几种方法可以使这些异步请求按顺序运行：

1. 简单的解决方案是使方法递归，在前一个的完成处理程序中调用下一个调用：

   func retrievePlacemarks(at index: Int = 0) {
       guard index < locations.count else { return }
   
       lookUpCurrentLocation(location: locations[index]) { name in
           print(name ?? "no  name found")
           DispatchQueue.main.async {
               self.retrievePlacemarks(at: index + 1)
           }
       }
   }
   

   然后，只需调用

   retrievePlacemarks()
   

   FWIW，我在进行地理编码时可能会使用first 而不是[0]：

   func lookUpCurrentLocation(location: CLLocation, completionHandler: @escaping (String?) -> Void) {
       CLGeocoder().reverseGeocodeLocation(location) { placemarks, _ in
           completionHandler(placemarks?.first?.name)
       }
   }
   

   我认为reverseGeocodeLocation 不可能返回一个非nil 的零长度数组（在这种情况下，您的再现会因无效的下标错误而崩溃），但上面的内容完全相同像你一样，但也消除了潜在的错误。

2. 使异步任务按顺序运行的一种优雅方法是将它们包装在异步Operation 子类中（例如在latter part of this answer 中看到的通用AsynchronousOperation）。

   然后你可以定义一个反向地理编码操作：

   class ReverseGeocodeOperation: AsynchronousOperation {
       private static let geocoder = CLGeocoder()
       let location: CLLocation
       private var geocodeCompletionBlock: ((String?) -> Void)?
   
       init(location: CLLocation, geocodeCompletionBlock: @escaping (String?) -> Void) {
           self.location = location
           self.geocodeCompletionBlock = geocodeCompletionBlock
       }
   
       override func main() {
           ReverseGeocodeOperation.geocoder.reverseGeocodeLocation(location) { placemarks, _ in
               self.geocodeCompletionBlock?(placemarks?.first?.name)
               self.geocodeCompletionBlock = nil
               self.finish()
           }
       }
   }
   

   然后您可以创建一个串行操作队列并将您的反向地理编码操作添加到该队列：

   private let geocoderQueue: OperationQueue = {
       let queue = OperationQueue()
       queue.name = Bundle.main.bundleIdentifier! + ".geocoder"
       queue.maxConcurrentOperationCount = 1
       return queue
   }()
   
   func retrievePlacemarks() {
       for location in locations {
           geocoderQueue.addOperation(ReverseGeocodeOperation(location: location) { string in
               print(string ?? "no name found")
           })
       }
   }
   

3. 如果针对 iOS 13 及更高版本，您可以使用Combine，例如为反向地理编码定义发布者：

   extension CLGeocoder {
       func reverseGeocodeLocationPublisher(_ location: CLLocation, preferredLocale locale: Locale? = nil) -> AnyPublisher<CLPlacemark, Error> {
           Future<CLPlacemark, Error> { promise in
               self.reverseGeocodeLocation(location, preferredLocale: locale) { placemarks, error in
                   guard let placemark = placemarks?.first else {
                       return promise(.failure(error ?? CLError(.geocodeFoundNoResult)))
                   }
                   return promise(.success(placemark))
               }
           }.eraseToAnyPublisher()
       }
   }
   

   然后您可以使用发布者序列，在其中指定 maxPublishers 或 .max(1) 以确保它不会同时执行它们：

   private var placemarkStream: AnyCancellable?
   
   func retrievePlacemarks() {
       placemarkStream = Publishers.Sequence(sequence: locations).flatMap(maxPublishers: .max(1)) { location in
           self.geocoder.reverseGeocodeLocationPublisher(location)
       }.sink { completion in
           print("done")
       } receiveValue: { placemark in
           print("placemark:", placemark)
       }
   }
   

无可否认，还有其他方法可以使异步任务按顺序运行（通常涉及使用信号量或调度组调用wait），但我认为这些模式并不可取，因此我已将它们排除在我的列表之外替代品，上面。

Answer 2

这是一个使用 Combine 的实现，带有一个持久缓存。需要更智能的缓存过期逻辑等，但这只是一个起点。欢迎使用补丁。

https://gist.github.com/lhoward/dd6b64fb8f5782c933359e0d54bcb7d3