# Inspect Route Element for iOS v3

In this tutorial we will request a route, list the route parts and render these on a Google Map. A MapsIndoors route is made of one or more legs, each containing one or more steps.

We will start by making the controller that renders the route from the input of a route, a leg index and optionally a step index. Start by creating a `UIViewController` implementation that conforms to `MPDirectionsRendererDelegate`

```
class ShowRouteOnMapController: UIViewController, MPDirectionsRendererDelegate 
```

Setup member variables for `ShowRouteOnMapController`:

* An instance of type `GMSMapView`
* An instance of type `MPMapControl`
* An instance of type `MPRoute` (the route object)
* A leg index
* A step index

```
var map: GMSMapView? = nil
var mapControl: MPMapControl? = nil
var route:MPRoute? = nil
var leg:Int = -1
var step:Int = -1
```

Create an initializer for your input parameters

```
convenience init(_ route:MPRoute, _ leg:Int, _ step:Int) {
    self.init(nibName:nil, bundle:nil)
    self.route = route
    self.leg = leg
    self.step = step
}
```

Setup the Google map and your `MPMapControl` instance

```
self.map = GMSMapView.init(frame: CGRect.zero)
self.view = self.map
self.map?.camera = .camera(withLatitude: 57.057964, longitude: 9.9504112, zoom: 20)
self.mapControl = MPMapControl.init(map: self.map!)
```

Inside `viewDidAppear`, setup a directions renderer and assign the Google map, route object and leg/step indices. Eventually, call the animate method to make it animate from the start to end of the leg/step

```
let renderer = MPDirectionsRenderer.init()
renderer.delegate = self
renderer.fitBounds = true
renderer.map = self.map
renderer.route = route
renderer.routeLegIndex = leg
renderer.routeStepIndex = step
renderer.animate(5)
```

In the `floorDidChange` delegate method change the floor on your `MPMapControl instance`

```
func floorDidChange(_ floor: NSNumber) {
    mapControl?.currentFloor = floor
}
```

[See the sample in ShowRouteOnMapController.swift](https://github.com/MapsIndoors/MapsIndoorsIOS/blob/master/Example/DemoSamples/Show%20Route/ShowRouteOnMapController.swift)

### Create the Controller That Requests the Route, and List the Route in a Table[​](https://docs.mapsindoors.com/inspect-route-element/#create-the-controller-that-requests-the-route-and-list-the-route-in-a-table) <a href="#create-the-controller-that-requests-the-route-and-list-the-route-in-a-table" id="create-the-controller-that-requests-the-route-and-list-the-route-in-a-table"></a>

A MapsIndoors route is made of one or more legs, each containing one or more steps. Start by creating a `UIViewController` implementation

```
class ShowRouteController: UITableViewController {
```

Add a `MPRoute` property to the class

```
var route:MPRoute? = nil
```

Inside `viewDidLoad`, setup a directions service, call the directions service and save the route result to your `MPRoute` property

```
let directions = MPDirectionsService.init()
let origin = MPPoint.init(lat: 57.057917, lon: 9.950361, zValue:0)
let destination = MPPoint.init(lat: 57.058038, lon: 9.950509, zValue:1)
let directionsQuery = MPDirectionsQuery.init(originPoint: origin!, destination: destination!)
directions.routing(with: directionsQuery) { (route, error) in
    self.route = route
    self.tableView.reloadData()
}
```

Override `numberOfRowsInSection` to return the number of steps in the current leg plus the leg itself

```
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    if let leg:MPRouteLeg = route?.legs?[section] as? MPRouteLeg {
        return leg.steps!.count + 1
    }
    return 0
}
```

Override `numberOfSections` to return the number of legs

```
override func numberOfSections(in tableView: UITableView) -> Int {
    if let legs = route?.legs?.count {
        return legs
    }
    return 0
}
```

Override `titleForHeaderInSection` to return the leg index

```
override func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    return "Route Leg \(section)"
}
```

Override `tableView:cellForRowAt` to return leg index and step index if applicable

```
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = UITableViewCell.init()
    if indexPath.row > 0 {
        cell.textLabel?.text = "Show leg \(indexPath.section), step \(indexPath.row - 1)"
    } else {
        cell.textLabel?.text = "Show leg \(indexPath.section), all steps"
    }
    cell.accessibilityIdentifier = cell.textLabel?.text
    return cell
}
```

Override `tableView:didSelectRowAt` to push a new view controller

```
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let vc = ShowRouteOnMapController.init(route!, indexPath.section, indexPath.row - 1)
    navigationController?.pushViewController(vc, animated: true)
}
```

[See the sample in ShowRouteController.swift](https://github.com/MapsIndoors/MapsIndoorsIOS/blob/master/Example/DemoSamples/Show%20Route/ShowRouteController.swift)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mapsindoors.com/legacy-docs/ios-sdk-v3/inspect-route-element-for-ios-v3.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.