MKLocalSearch only yields US results, how to expand search?

Question

I am using MKLocalSearch to allow users to search for their city. However, when I try the code I only receive results in the US. Also I receive a lot of results that include stores etc. I added the filters in func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) to get rid of results that are not cities. This works but I feel like this may fail for certain places. I tried adding the code below but that didn't work. I'd appreciate any help.

let worldRegion = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 0, longitude: 0),
                                       span: MKCoordinateSpan(latitudeDelta: 180, longitudeDelta: 360))
self.searchCompleter.region = worldRegion

import Foundation
import Combine
import MapKit

class LocationService: NSObject, ObservableObject {

    enum LocationStatus: Equatable {
        case idle
        case noResults
        case isSearching
        case error(String)
        case result
    }

    @Published var queryFragment: String = ""
    @Published private(set) var status: LocationStatus = .idle
    @Published private(set) var searchResults: [MKLocalSearchCompletion] = []

    private var queryCancellable: AnyCancellable?
    private let searchCompleter: MKLocalSearchCompleter!

    init(searchCompleter: MKLocalSearchCompleter = MKLocalSearchCompleter()) {
        self.searchCompleter = searchCompleter
        super.init()
        self.searchCompleter.delegate = self
        
        queryCancellable = $queryFragment
            .receive(on: DispatchQueue.main)
            .debounce(for: .milliseconds(250), scheduler: RunLoop.main, options: nil)
            .sink(receiveValue: { fragment in
                self.status = .isSearching
                if !fragment.isEmpty {
                    self.searchCompleter.queryFragment = fragment
                } else {
                    self.status = .idle
                    self.searchResults = []
                }
        })
    }
}

extension LocationService: MKLocalSearchCompleterDelegate {
    func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) {
        self.searchResults = completer.results.filter { result in
            if !result.title.contains(",") {
                return false
            }
            if result.title.rangeOfCharacter(from: CharacterSet.decimalDigits) != nil {
                return false
            }
            if result.subtitle.rangeOfCharacter(from: CharacterSet.decimalDigits) != nil {
                return false
            }
            return true
        }
        self.status = completer.results.isEmpty ? .noResults : .result
    }

    func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) {
        self.status = .error(error.localizedDescription)
    }
}

import SwiftUI
import MapKit

struct locView: View {
    @StateObject var locationService = LocationService()
    var body: some View {
        VStack {
            Form {
                Section(header: Text("Location Search")) {
                    ZStack(alignment: .trailing) {
                        TextField("Search", text: $locationService.queryFragment)
                        if locationService.status == .isSearching {
                            Image(systemName: "clock")
                                .foregroundColor(Color.gray)
                        }
                    }
                }
                Section(header: Text("Results")) {
                    List {
                        Group { () -> AnyView in
                            switch locationService.status {
                            case .noResults: return AnyView(Text("No Results"))
                            case .error(let description): return AnyView(Text("Error: \(description)"))
                            default: return AnyView(EmptyView())
                            }
                        }.foregroundColor(Color.gray)

                        ForEach(locationService.searchResults, id: \.self) { completionResult in
                            Text(completionResult.title)
                        }
                    }
                }
            }
        }
    }
}

Answer 1

A few observations:

1. To exclude searching points of interests, from things like stores, you can specify that the completer should only search addresses (e.g. a resultTypes of .address):

   searchCompleter.resultTypes = .address
   

   Alternatively, you can explicitly exclude points of interest with a pointsOfInterestFilter of .excludingAll:

   searchCompleter.pointOfInterestFilter = .excludingAll
   

2. Your completerDidUpdateResults(_:) implementation is filtering results (perhaps an adaptation of Search for Place Names (City/Town) Using MKLocalSearchCompleter, which assumes the title for a city must include a comma). E.g., search for “munich” and you will return two results “Munich, ND”/“United States” and “Munich”/“Bavaria, Germany”. Because you are looking for a comma in the title, the latter result will subsequently be filtered out.

   This illustrates how brittle it can be to attempt to look at string characteristics to determine whether a title/subtitle combination represents a city or not.

3. You can contemplate using MKLocalSearch or CLGeocoder, but while those both return arrays of results, I find that their results are more narrow than MKLocalSearchCompleter. In the “munich” search example, both of these only return the city in Germany.

Bottom line, MapKit and CoreLocation do not appear to offer a simple city search capability. I understand that Google Maps API does (but apparently also requires that if you are showing the results on an actual map, you only show it on a Google map, not MapKit’s).