Introduction

In iOS 6-era code, opening the Maps app was commonly done with Apple Maps URLs. That URL approach still exists, but modern iOS code often prefers MKMapItem because it is more structured and easier to maintain. If you are maintaining legacy behavior, it helps to understand both the old URL-based handoff and the newer MapKit approach.

The Legacy URL Approach

The traditional solution is to build an Apple Maps URL and ask the system to open it.

1import UIKit
2
3func openMapsURL(latitude: Double, longitude: Double, label: String) {
4    let encoded = label.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? "Destination"
5    let urlString = "http://maps.apple.com/?ll=\(latitude),\(longitude)&q=\(encoded)"
6
7    guard let url = URL(string: urlString) else { return }
8    UIApplication.shared.open(url, options: [:], completionHandler: nil)
9}

This launches Apple Maps centered on the given location and labeled with the text in the query.

The key detail is that the label must be percent-encoded correctly. If you skip that step, names with spaces or punctuation can produce malformed URLs.

Open Directions Instead of Just a Pin

If the user needs navigation rather than a plain map location, use a destination parameter.

1import UIKit
2
3func openDrivingDirections(toLat: Double, toLon: Double) {
4    let destination = "\(toLat),\(toLon)"
5    let urlString = "http://maps.apple.com/?daddr=\(destination)&dirflg=d"
6
7    guard let url = URL(string: urlString) else { return }
8    UIApplication.shared.open(url)
9}

That asks Maps to open a driving route to the specified coordinates.

In old codebases this URL pattern was often the entire integration point, because it was lightweight and required no extra framework design.

The Modern MKMapItem Alternative

For newer code, MapKit usually gives a cleaner and more explicit API.

1import MapKit
2
3func openInMaps(lat: Double, lon: Double, name: String) {
4    let coordinate = CLLocationCoordinate2D(latitude: lat, longitude: lon)
5    let placemark = MKPlacemark(coordinate: coordinate)
6    let item = MKMapItem(placemark: placemark)
7    item.name = name
8
9    let options = [MKLaunchOptionsDirectionsModeKey: MKLaunchOptionsDirectionsModeDriving]
10    item.openInMaps(launchOptions: options)
11}

This avoids manual URL formatting and keeps the intent clearer in the code.

If you are migrating an old project, a good pattern is to isolate map launching in one helper so the rest of the app does not care whether the implementation uses URLs or MKMapItem.

Validate Coordinates Before Launching

Bad location data is a much more common cause of failure than the open call itself. Validate the coordinates before constructing the request.

func isValidCoordinate(lat: Double, lon: Double) -> Bool {
    (-90.0...90.0).contains(lat) && (-180.0...180.0).contains(lon)
}

If the values are invalid, fail early and show feedback rather than silently attempting a broken handoff.

Treat Maps Launch as a User-Flow Event

Opening Maps is an app switch. That means it should be treated as part of user flow design, not just as an API detail.

Good practice includes:

• making the button intent clear, such as "Open in Maps"
• preserving the current app state before the handoff
• providing a fallback if the launch fails

In a delivery or booking flow, the user should understand why they are leaving the app and what destination is about to open.

Common Pitfalls

The most common mistake is building the URL without percent-encoding the label. Another is launching with invalid coordinates and then debugging the wrong layer.

Teams also often mix URL-based launch code and MKMapItem code in several places instead of centralizing one map-launch helper.

Finally, simulator behavior is not always a perfect proxy for app-switch behavior on a real device. Test the handoff on actual hardware if the feature matters.

Summary

• Legacy iOS code commonly opened Apple Maps with a maps.apple.com URL.
• Modern code often prefers MKMapItem for better structure and readability.
• Encode labels and validate coordinates before launching.
• Treat the map handoff as part of the user flow, not just a technical call.
• Keep map-launch logic centralized so old and new integration styles do not drift across the codebase.