iOS: How to get route path between two coordinates

Question

In my project I\'ve to find out the route path between two locations with the help of latitude and longitude.

I\'m using the following code for it

Answer 1

To draw path between two lat long, you can use below code.

ViewController.h

#import <UIKit/UIKit.h>
#import <MapKit/MapKit.h>

@interface ViewController : UIViewController<MKMapViewDelegate>

@property (strong, nonatomic) IBOutlet MKMapView *myMapView;

@end

ViewController.m

#import "ViewController.h"

@interface ViewController ()

@property (strong, nonatomic) MKPlacemark *destination;
@property (strong,nonatomic) MKPlacemark *source;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.

    [self getDirections];

}

-(void)getDirections {

    CLLocationCoordinate2D sourceCoords = CLLocationCoordinate2DMake(37.773972, -122.431297);

    MKCoordinateRegion region;
    //Set Zoom level using Span
    MKCoordinateSpan span;
    region.center = sourceCoords;

    span.latitudeDelta = 1;
    span.longitudeDelta = 1;
    region.span=span;
    [_myMapView setRegion:region animated:TRUE];

    MKPlacemark *placemark  = [[MKPlacemark alloc] initWithCoordinate:sourceCoords addressDictionary:nil];

    MKPointAnnotation *annotation = [[MKPointAnnotation alloc] init];
    annotation.coordinate = sourceCoords;
    annotation.title = @"San Francisco";
    [self.myMapView addAnnotation:annotation];
    //[self.myMapView addAnnotation:placemark];

     _destination = placemark;

     MKMapItem *mapItem = [[MKMapItem alloc] initWithPlacemark:_destination];

     CLLocationCoordinate2D destCoords = CLLocationCoordinate2DMake(37.615223, -122.389977);
     MKPlacemark *placemark1  = [[MKPlacemark alloc] initWithCoordinate:destCoords addressDictionary:nil];

    MKPointAnnotation *annotation1 = [[MKPointAnnotation alloc] init];
    annotation1.coordinate = destCoords;
    annotation1.title = @"San Francisco University";
    [self.myMapView addAnnotation:annotation1];

    //[self.myMapView addAnnotation:placemark1];

     _source = placemark1;

     MKMapItem *mapItem1 = [[MKMapItem alloc] initWithPlacemark:_source];

     MKDirectionsRequest *request = [[MKDirectionsRequest alloc] init];
     request.source = mapItem1;

     request.destination = mapItem;
     request.requestsAlternateRoutes = NO;

     MKDirections *directions = [[MKDirections alloc] initWithRequest:request];

     [directions calculateDirectionsWithCompletionHandler:
      ^(MKDirectionsResponse *response, NSError *error) {
          if (error) {
              NSLog(@"ERROR");
              NSLog(@"%@",[error localizedDescription]);
          } else {
              [self showRoute:response];
          }
      }];
}

-(void)showRoute:(MKDirectionsResponse *)response
{
    for (MKRoute *route in response.routes)
    {
        [_myMapView
         addOverlay:route.polyline level:MKOverlayLevelAboveRoads];

        for (MKRouteStep *step in route.steps)
        {
            NSLog(@"%@", step.instructions);
        }
    }
}

#pragma mark - MKMapViewDelegate methods

- (MKOverlayRenderer *)mapView:(MKMapView *)mapView rendererForOverlay:(id<MKOverlay>)overlay
{
    MKPolylineRenderer *renderer = [[MKPolylineRenderer alloc] initWithPolyline:overlay];
    renderer.strokeColor = [UIColor colorWithRed:0.0/255.0 green:171.0/255.0 blue:253.0/255.0 alpha:1.0];
    renderer.lineWidth = 10.0;
    return  renderer;
}

UPDATE : Swift 4

import MapKit
import UIKit

class ViewController: UIViewController, MKMapViewDelegate {

    var destination: MKPlacemark?
    var source: MKPlacemark?
    @IBOutlet var myMapView: MKMapView!

    func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        self.myMapView.delegate = self
        getDirections()
    }

    func getDirections() {
        let sourceCoords: CLLocationCoordinate2D = CLLocationCoordinate2DMake(37.773972, -122.431297)
        let region: MKCoordinateRegion
            //Set Zoom level using Span
        let span: MKCoordinateSpan
        region.center = sourceCoords
        span.latitudeDelta = CLLocationDegrees(1)
        span.longitudeDelta = CLLocationDegrees(1)
        region.span = span
        myMapView.setRegion(region, animated: true)
        let placemark = MKPlacemark(coordinate: sourceCoords, addressDictionary: nil)
        let annotation = MKPointAnnotation()
        annotation.coordinate = sourceCoords
        annotation.title = "San Francisco"
        myMapView.addAnnotation(annotation)
        //[self.myMapView addAnnotation:placemark];
        destination = placemark
        var mapItem: MKMapItem? = nil
        if let aDestination = destination {
            mapItem = MKMapItem(placemark: aDestination)
        }
        let destCoords: CLLocationCoordinate2D = CLLocationCoordinate2DMake(37.615223, -122.389977)
        let placemark1 = MKPlacemark(coordinate: destCoords, addressDictionary: nil)
        let annotation1 = MKPointAnnotation()
        annotation1.coordinate = destCoords
        annotation1.title = "San Francisco University"
        myMapView.addAnnotation(annotation1)
        //[self.myMapView addAnnotation:placemark1];
        source = placemark1
        var mapItem1: MKMapItem? = nil
        if let aSource = source {
            mapItem1 = MKMapItem(placemark: aSource)
        }
        let request = MKDirectionsRequest()
        request.source = mapItem1
        request.destination = mapItem
        request.requestsAlternateRoutes = false
        let directions = MKDirections(request: request)
        directions.calculate(completionHandler: {(_ response: MKDirectionsResponse, _ error: Error?) -> Void in
            if error != nil {
                print("ERROR")
                print("\(error?.localizedDescription ?? "")")
            } else {
                self.showRoute(response)
            }
        })
    }

    func showRoute(_ response: MKDirectionsResponse?) {
        for route: MKRoute in response?.routes {
            myMapView.add(route.polyline, level: .aboveRoads)
            for step: MKRouteStep in route.steps {
                print("\(step.instructions)")
            }
        }
    }

    // MARK: - MKMapViewDelegate methods
    func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
        var renderer: MKPolylineRenderer? = nil
        if let anOverlay = overlay as? MKPolyline {
            renderer = MKPolylineRenderer(polyline: anOverlay)
        }
        renderer?.strokeColor = UIColor(red: 0.0 / 255.0, green: 171.0 / 255.0, blue: 253.0 / 255.0, alpha: 1.0)
        renderer?.lineWidth = 10.0
        if let aRenderer = renderer {
            return aRenderer
        }
        return MKOverlayRenderer()
    }
}

Hope it will help you out! Change lat long in above code as per your requirement.