### Install UI Component Dependencies

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Install recommended UI components for the getting started guide, including Bottomsheet and Navigation libraries.

```bash
# Bottomsheet
npm install @gorhom/bottom-sheet@^4

# Navigation
npm install @react-navigation/native @react-navigation/native-stack
npm install react-native-screens react-native-safe-area-context
```

--------------------------------

### Quick Start: Initialize CleaningModule

Source: https://docs.mapsindoors.com/academy/use-case-guides/route-optimization-for-cleaning-operations.md

Quick start example showing how to initialize MapsIndoors, create a CleaningModule with required dependencies, load room data, and initialize the UI.

```js
import { CleaningModule } from './js/cleaningModule.js';
import { roomStore } from './js/roomStore.js';
import { CONFIG } from './js/utils.js';

// Initialize MapsIndoors (see SDK docs)
const mapsIndoorsInstance = new mapsindoors.MapsIndoors({ mapView });
const mapboxInstance = mapView.getMap();
const directionsService = new mapsindoors.services.DirectionsService();
const directionsRenderer = new mapsindoors.directions.DirectionsRenderer({
  mapsIndoors: mapsIndoorsInstance
});

// Create the cleaning module
const cleaningModule = new CleaningModule({
  mapsIndoors: mapsIndoorsInstance,
  mapbox: mapboxInstance,
  directionsService,
  directionsRenderer,
  roomStore,
  config: CONFIG
});

// Load room data
roomStore.setRooms(roomsData);

// Initialize UI
cleaningModule.updateRoomDisplayRules();
cleaningModule.renderRoomList();
cleaningModule.populateSelectedRooms();
```

--------------------------------

### Setup RobotVacuumLocationSource

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/displaying-objects/location-data-sources.md

Creates a RobotVacuumLocationSource, adds it via MapsIndoors.addLocationSources, calls setup(), and starts updating positions.

```kotlin
private fun setupLocationSource() {
    if (mLocations == null) {
        generateLocations()
    }
    val locationSource = RobotVacuumLocationSource(mLocations!!)
    MapsIndoors.addLocationSources(Collections.singletonList(locationSource) as List<MPLocationSource>) {
    }
    locationSource.setup()
    startUpdatingPositions()
}
```

--------------------------------

### Start PositionProvider

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/user-positioning/show-users-location-aka.-blue-dot.md

Starts the PositionProvider instance so it begins producing positioning results.

```kotlin
mPositionProvider?.start()
```

--------------------------------

### Install dependencies and build with Lerna

Source: https://docs.mapsindoors.com/products/fast-track-maptemplate/getting-started.md

Installs all dependencies and builds the project using Lerna. Run this from the project folder root.

```bash
npm install && npx lerna run build
```

--------------------------------

### Install UI Component Dependencies

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Install required dependencies for the UI components.

```bash
# Dependencies
npm install react-native-reanimated react-native-gesture-handler
```

--------------------------------

### Install CocoaPods via npx

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Alternatively, use the pod-install package to run installation from the project root.

```bash
npx pod-install
```

--------------------------------

### Initialize View Controller

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Calls the setup methods within the viewDidLoad lifecycle method.

```swift
override func viewDidLoad() {
    super.viewDidLoad()
    Task {
        await setupMap()
        setupSearchButton()
        setupRouteNav()
        setupRenderer()
        setupConstraints()
        setOriginLocation()
    }
}
```

--------------------------------

### Setup search button

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Creates a blueprint button that triggers the selectDestination method.

```swift
fileprivate func setupSearchButton() {
    searchButton = UIButton.init()
    searchButton.setTitle("Search Destination", for: .normal)
    searchButton.addTarget(self, action: #selector(selectDestination), for: .touchUpInside)
    searchButton.backgroundColor = .blue
    view.addSubview(searchButton)
}
```

--------------------------------

### Example of Creating a Search Query with LocationsService.getLocations

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/search/searching.md

JavaScript example showing how to call mapsindoors.services.LocationsService.getLocations with a search parameters object. The example uses the 'q' parameter to search for 'Office', 'near' with a coordinate (Blue Room, The White House), and 'take' to limit results to 1. The returned locations are logged to the console.

```javascript
const searchParameters = {
  q: 'Office',
  near: { lat: 38.897579747054046, lng: -77.03658652944773 }, // // Blue Room, The White House
  take: 1
}

mapsindoors.services.LocationsService.getLocations(searchParameters).then(locations => {
  console.log(locations);
});
```

--------------------------------

### Implement Start and Stop Methods

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/user-positioning/show-users-location-aka.-blue-dot.md

Define start and stop methods to manage the timer that periodically triggers position updates.

```kotlin
fun start(){
    mPositionProducer = Timer(true)
    mPositionProducer?.scheduleAtFixedRate(object: TimerTask() {
        override fun run() {

        }
    }, 0, 1000L)
}

fun stop(){
    mPositionProducer?.cancel()
}
```

--------------------------------

### Run the Map Template app

Source: https://docs.mapsindoors.com/products/fast-track-maptemplate/getting-started.md

Starts the app from the packages/map-template directory. The app will be served at http://localhost:3000/.

```bash
npm run start
```

--------------------------------

### PositioningFragment: Attach IndoorAtlasPositionProvider and start positioning

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/user-positioning/using-indoor-atlas.md

Shows how to integrate the IndoorAtlasPositionProvider in a Fragment. It loads MapsIndoors with an API key, creates the provider using the solution's indoorAtlasConfig, and sets it as the position provider. A button click starts positioning, with a comment to handle provider-specific permissions.

```kotlin
class myFragment: Fragment(), OnMapReadyCallback {
    private var mPositionProvider: IndoorAtlasPositionProvider? = null

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?,): View {
        ...
        MapsIndoors.load(requireActivity().applicationContext, "myapikey") {
            // Attach the position provider to the SDK
            mPositionProvider = IndoorAtlasPositionProvider(requireActivity(), MapsIndoors.getSolution()!!.indoorAtlasConfig!!)
            MapsIndoors.setPositionProvider(mPositionProvider)
        }

        //Have a buttton or other logic to start positioning:
        binding.startPositioningButton.setOnClickListener {
            //Remember to handle permissions specific to the Position provider you are using
            mPositionProvider?.startPositioning()
        }
        ...
    }
}
```

--------------------------------

### Start Updating Positions

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/displaying-objects/location-data-sources.md

Starts a timer to trigger location updates at a fixed rate.

```kotlin
private fun startUpdatingPositions() {
    mUpdateTimer?.cancel()
    mUpdateTimer = Timer()
    mUpdateTimer?.scheduleAtFixedRate(object: TimerTask() {
        override fun run() {
            updateLocations();
        }
    }, 2000, 500)
}
```

--------------------------------

### Cisco Positioning Service Usage Example

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/other-guides/user-positioning/using-cisco-dna-spaces.md

Demonstrates how to initialize the CiscoPositioningService using solution configuration and watch for position updates on the map.

```javascript
const map = mapView.getMap();
let watchId;

mapsindoors.services.SolutionsService.getSolution('57e4e4992e74800ef8b69718').then(solution => {
    if (solution.positionProviderConfigs && solution.positionProviderConfigs.ciscodna) {
        const tenantId = solution.positionProviderConfigs.ciscodna.ciscoDnaSpaceTenantId;
        const region = solution.positionProviderConfigs.ciscodna.ciscoDnaSpaceTenantRegion || 'usa';
        const clientIp = '10.0.0.134';
        const cps = new CiscoPositioningService({ clientIp, tenantId, region });

        watchId = cps.watchPosition(function (data) {
            console.log(data);
            map.setCenter({ lat: data.latitude, lng: data.longitude });
        }, function (err) {
            console.log(err);
        })
    }
});

const floorSelector = document.createElement('div');
new mapsindoors.FloorSelector(floorSelector, mi);
map.controls[google.maps.ControlPosition.RIGHT_TOP].push(floorSelector);
```

--------------------------------

### Setup MapsIndoors with Mapbox (Swift)

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/switching-solutions.md

Initializes MapsIndoors with a Mapbox map view. Sets the camera to a specific coordinate, creates an MPMapConfig with the Mapbox MapView, loads MapsIndoors with the provided API key, and creates a map control. Use this as the initial setup to enable smooth switching between Solutions later.

```swift
func setupMapsIndoors(mapsIndoorsAPIKey: String, mapboxAccessToken: String) async throws {
    // Set up the Mapbox map view
    let mapInitOptions = MapInitOptions(resourceOptions: ResourceOptions(accessToken: mapboxAccessToken))
    self.mapView = MapView(frame: self.view.bounds, mapInitOptions: mapInitOptions)
    self.view = self.mapView

    // Orient your map to where you need data to be shown.
    // This can e.g. be done by pointing the camera to a specific location (shown below)
    // or getting the default venue after MapsIndoors is loaded and panning the camera there.
    let centerCoordinate = CLLocationCoordinate2D(latitude: 57.057964, longitude: 9.9504112, zoom: 20)
    self.mapView.mapboxMap.setCamera(to: CameraOptions(center: centerCoordinate, zoom: 20))

    // Initialize the MPMapConfig with the Mapbox MapView
    self.mapConfig = MPMapConfig(mapBoxView: mapView, accessToken: mapboxAccessToken)

    try await MPMapsIndoors.shared.load(apiKey: mapsIndoorsAPIKey)

    self.mapControl = MPMapsIndoors.createMapControl(mapConfig: mapConfig)
}
```

--------------------------------

### Install CocoaPods Dependencies

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Run pod install from the ios folder to link native dependencies.

```bash
pod install
```

--------------------------------

### Configure Contextual Info Settings

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/directions-renderer.md

Example of initializing and applying settings to show Location information of type 'Entry' within a 20-meter radius.

```swift
let contextualSettings = DirectionsRendererContextualInfoSettings()
contextualSettings.types = ["Entry"]
contextualSettings.maxDistance = 20
myDirectionsRenderer.contextualInfoSettings = contextualSettings
```

--------------------------------

### Setup route navigation

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Instantiates RouteSegmentsController, adds it as a child view controller, and sets the delegate.

```swift
fileprivate func setupRouteNav() {
    routeVC = RouteSegmentsController.init()
    self.addChildViewController(routeVC!)
    view.addSubview(routeVC.view)
    routeVC.didMove(toParentViewController: self)
    routeVC.delegate = self as RouteSegmentsControllerDelegate
}
```

--------------------------------

### Install MapsIndoors Google Maps Provider

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Install the MapsIndoors Google Maps binding package.

```bash
npm install @mapsindoors/react-native-maps-indoors-google-maps
```

--------------------------------

### Custom Storage Adapter Implementation

Source: https://docs.mapsindoors.com/academy/use-case-guides/parking-spot-mark-and-navigate-back.md

Create a custom storage adapter by implementing the required get, set, and remove methods.

```javascript
class MyCustomAdapter {
  get(key) {
    // Return parsed data or null
  }

  set(key, value) {
    // Store data, return true on success
  }

  remove(key) {
    // Remove data, return true on success
  }
}

const parking = new ParkingManager({
  storageAdapter: new MyCustomAdapter()
});
```

--------------------------------

### Getting Directions with MPDirectionsService and RouteInstructions Component

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/getting-directions.md

The first snippet shows how to create a directions service, set travel mode to walking, get a route, render it with MPDirectionsRenderer, and listen for leg selection. The second snippet defines a RouteInstructions component that displays the current leg and provides next/previous buttons, using a useEffect to update the leg when goToPage changes.

```tsx
  const [mproute, setMPRoute] = useState<MPRoute>();
  const [directionsRenderer, setDirectionsRenderer] = useState<MPDirectionsRenderer|undefined>(undefined);
  const [routeLeg, setRouteLeg] = useState<number>();

  const getRoute = async () => {
    if (!fromLocation || !toLocation) {
      return
    }

    // Query route
    console.debug('Querying Route');
    
    //Creating the directions service, if it has not been created before.
    const directionsService = await MPDirectionsService.create();
    //Setting the travel mode to walking, to ensure instructions are for walking.
    await directionsService.setTravelMode('walking');

    let from = fromLocation.position
    let to = toLocation.position;
    console.debug({from}, {to})

    //Querying the route through the directionsService after 
    const route = await directionsService.getRoute(from, to);
    console.debug({route});
    setMPRoute(route);

    //Creating the directions renderer
    const directionsRenderer = new MPDirectionsRenderer(NativeEventEmitter);
    //Setting the route on the directions renderer, causing it to be rendered onto the map.
    await directionsRenderer.setRoute(route);

    setDirectionsRenderer(directionsRenderer);

    //Listen for leg changes
    directionsRenderer.setOnLegSelectedListener((leg) => {
      setRouteLeg(leg);
    });
  }
```

```tsx
export default function RouteInstructions({route, goToPage, onPrevious, onNext}: {route: MPRoute|undefined, goToPage: number|undefined, onPrevious: (()=>void)|undefined, onNext: (()=>void)|undefined}) {

  const [leg, setLeg] = useState<MPRouteLeg|undefined>(route?.legs![0]);

  useEffect(() => {
    if (goToPage !== undefined) {
      setLeg(route?.legs![goToPage]);
    }
  }, [goToPage])

  return <View style={{padding: 5, flexDirection: 'column', height: '60%'}}>
    <Text style={{color: Colors.dark}}>legs: {route?.legs?.length}</Text>
    <View style={{flexDirection: 'column', flex: 1}}>
      <RouteInstructionLeg leg={leg}/>
    </View>
    <View>
      <Button title="next" onPress={onNext}/>
      <Button title="previous" onPress={onPrevious}/>
    </View>
  </View>
}
```

--------------------------------

### Setup label views in viewDidLoad

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/displaying-objects/location-details.md

Configure the map control delegate and set background colors for the labels.

```swift
mapControl?.delegate = self
nameLabel.backgroundColor = UIColor.white
descrLabel.backgroundColor = UIColor.white
```

--------------------------------

### Initialize Directions Service

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/directions/wayfinding-instructions/see-route-element-details.md

Setup the directions service and save the route result to the adapter's route property.

```kotlin
init {
    val origin = MPPoint(57.057917, 9.950361, 0.0)
    val destination = MPPoint(57.058038, 9.950509, 1.0)
    val service = MPDirectionsService()
    service.setRouteResultListener { route, error ->
        route?.let {
            this.route = it
            notifyDataSetChanged()
        }
        error?.let {
            Log.e("RouteListAdapter", it.toString())
        }
    }
    service.query(origin, destination)
}
```

--------------------------------

### Load MapsIndoors and setup location source

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/displaying-objects/location-data-sources.md

Loads MapsIndoors with an API key and, on success, stores the main display rule and calls setupLocationSource().

```kotlin
MapsIndoors.load(requireActivity().applicationContext, "MY_API_KEY") { error ->
    if (error == null) {
        baseDisplayRule = WeakReference(MapsIndoors.getMainDisplayRule())
        setupLocationSource()
    }
}
```

--------------------------------

### SessionStorage Adapter Example

Source: https://docs.mapsindoors.com/academy/use-case-guides/parking-spot-mark-and-navigate-back.md

An implementation of a storage adapter using the browser's sessionStorage API.

```javascript
class SessionStorageAdapter {
  get(key) {
    try {
      const value = sessionStorage.getItem(key);
      return value ? JSON.parse(value) : null;
    } catch (e) {
      return null;
    }
  }

  set(key, value) {
    try {
      sessionStorage.setItem(key, JSON.stringify(value));
      return true;
    } catch (e) {
      return false;
    }
  }

  remove(key) {
    try {
      sessionStorage.removeItem(key);
      return true;
    } catch (e) {
      return false;
    }
  }
}
```

--------------------------------

### Setup Cisco DNA Position Provider

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/show-users-location-aka.-blue-dot/using-cisco-dna-spaces.md

Initialize the PureCiscoDNAProvider, set the tenant ID, and assign it to the MapsIndoors shared instance.

```swift
let dnaPositionProvider = PureCiscoDNAProvider()
dnaPositionProvider.tenantId = "my-cisco-dna-spaces-tenant-id"
MPMapsIndoors.shared.positionProvider = dnaPositionProvider
dnaPositionProvider.startPositioning(nil)
```

--------------------------------

### Initialize CustomFloorSelector with MapsIndoors instance

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/other-guides/custom-floor-selector.md

Creates a CustomFloorSelector instance using the mapsIndoorsInstance and appends its element to the document body. This code assumes previous setup from the Getting Started Guide.

```javascript
//Previous code from Getting Started Guide

// Initialize CustomFloorSelector
const customFloorSelector = new CustomFloorSelector(mapsIndoorsInstance);
document.body.appendChild(customFloorSelector.element);
```

--------------------------------

### Set up the main app and add the Map widget

Source: https://docs.mapsindoors.com/sdks-and-frameworks/flutter/getting-started/show-a-map.md

Sets up the main app widget and then adds the Map widget as the home screen, passing the MapsIndoors API key 'gettingstarted'.

```dart
import 'package:mapsindoors_mapbox/mapsindoors.dart';
import 'package:flutter/material.dart';

void main() {
  runApp(const MapsIndoorsDemoApp());
}

class MapsIndoorsDemoApp extends StatelessWidget {
  const MapsIndoorsDemoApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter MapsIndoors Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
    );
  }
}
```

```dart
class MapsIndoorsDemoApp extends StatelessWidget {
  const MapsIndoorsDemoApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter MapsIndoors Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const Map(
        apiKey: 'gettingstarted',
      ), 
    );
  }
}
```

--------------------------------

### Setup map with MapsIndoors

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Asynchronous method to load MapsIndoors with an API key and create a map control. Throws error if load fails.

```swift
fileprivate func setupMap() async {
    do {
        try await MPMapsIndoors.shared.load(apiKey: #INSERT_YOUR_API_KEY)
        mapControl = MPMapsIndoors.createMapControl(mapConfig: #INSERT_YOUR_MAPCONFIG)
    } catch {
        print("failed to load MapsIndoors")
    }
    self.map = #INSERT_SELECTED_MAP
    view.addSubview(self.map!)
    }
```

--------------------------------

### Setup layout constraints

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Sets up constraints for map, search button, and route view. Height constraint for route view controlled by directionsVisible.

```swift
fileprivate func setupConstraints() {

    map.translatesAutoresizingMaskIntoConstraints = false
    map.widthAnchor.constraint(equalTo:view.widthAnchor).isActive = true
    map.topAnchor.constraint(equalTo:view.topAnchor).isActive = true

    searchButton.translatesAutoresizingMaskIntoConstraints = false
    searchButton.heightAnchor.constraint(equalToConstant: 68).isActive = true
    searchButton.widthAnchor.constraint(equalTo:view.widthAnchor).isActive = true
    searchButton.topAnchor.constraint(equalTo: map.bottomAnchor).isActive = true

    routeVC.view.translatesAutoresizingMaskIntoConstraints = false
    routeVC.view.widthAnchor.constraint(equalTo:view.widthAnchor).isActive = true
    routeVC.view.bottomAnchor.constraint(equalTo:view.bottomAnchor).isActive = true
    routeVC.view.topAnchor.constraint(equalTo:searchButton.bottomAnchor).isActive = true

    heightConstraintForRouteView = routeVC.view.heightAnchor.constraint(equalToConstant:0)
    heightConstraintForRouteView.isActive = true
}
```

--------------------------------

### Get list of active secrets - response

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/integration-api-access/client-credentials-flow.md

Example JSON response listing active secrets. Secrets themselves are not included because they are not stored.

```json
[
    {
        "id": "abcdbe9e8084022af463000",
        "description": "MyNewKey",
        "client_id": "xxx",
        "createdAt": "2024-05-27T13:46:31.843Z"
    }
]
```

--------------------------------

### Basic Setup with Event Listeners

Source: https://docs.mapsindoors.com/academy/use-case-guides/route-optimization-for-cleaning-operations.md

Initializes the MapsIndoors cleaning module with event listeners for route calculation, navigation, and room selection. Requires a mapView and a roomStore with setRooms, and assumes fetchRoomsFromAPI is defined elsewhere.

```javascript
import { CleaningModule } from './js/cleaningModule.js';
import { roomStore } from './js/roomStore.js';
import { CONFIG } from './js/utils.js';

async function initializeApp() {
    // Setup MapsIndoors...
    const mapsIndoors = new mapsindoors.MapsIndoors({ mapView });
    const mapbox = mapView.getMap();
    const directionsService = new mapsindoors.services.DirectionsService();
    const directionsRenderer = new mapsindoors.directions.DirectionsRenderer({
        mapsIndoors: mapsIndoors,
        fitBounds: true
    });

    // Create module
    const cleaning = new CleaningModule({
        mapsIndoors,
        mapbox,
        directionsService,
        directionsRenderer,
        roomStore,
        config: CONFIG
    });

    // Load data
    const rooms = await fetchRoomsFromAPI();
    roomStore.setRooms(rooms);

    // Initialize UI
    cleaning.updateRoomDisplayRules();
    cleaning.renderRoomList();
    cleaning.populateSelectedRooms();

    // Setup event listeners
    document.getElementById('calculate-route').addEventListener('click', () => {
        cleaning.calculateRoute();
    });

    document.getElementById('next-stop').addEventListener('click', () => {
        cleaning.nextStop();
    });

    document.getElementById('previous-stop').addEventListener('click', () => {
        cleaning.previousStop();
    });

    document.getElementById('cancel-route').addEventListener('click', () => {
        cleaning.clearRoute();
    });

    document.getElementById('info-card-close').addEventListener('click', () => {
        cleaning.closeSelection();
    });

    // Map click handler
    mapsIndoors.addListener('click', (event) => {
        if (event?.id && roomStore.has(event.id)) {
            cleaning.selectRoom(event.id);
        }
    });
}
```

--------------------------------

### Retrieving a LocationEditor on Click

Source: https://docs.mapsindoors.com/sdks-and-frameworks/built-in-map-edits/getting-started.md

Use this snippet to retrieve a LocationEditor instance when a MapsIndoors location is clicked. It sets up a click event listener on mapsIndoorsInstance and calls solutionManager.getLocation(e.id) to get the editor. This example assumes a working MapsIndoors Web SDK integration and is a continuation of the example found in Method 2: Connecting to an Existing SDK Instance (connect).

```js
let locationEditor = null;

// Get LocationEditor when a MapsIndoors location is clicked
mapsIndoorsInstance.on('click', async (e) => {
    if (!e?.id) {
        locationEditor = null;
        return;
    }

    try {
        locationEditor = await solutionManager.getLocation(e.id);
        console.log(`LocationEditor retrieved for ID: ${e.id}`);
    } catch (error) {
        console.error(`Failed to get LocationEditor for ID ${e.id}:`, error);
        locationEditor = null;
    }
});
```

--------------------------------

### Get directions from user's current position

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/directions-renderer/users-location-as-point-of-origin.md

Use the PositionProvider's latest position coordinate to create an MPPoint and use it as the origin in an MPDirectionsQuery. The example shows how to set a destination and retrieve a route using the directions service.

```swift
if let userPosition = mapControl?.positionProvider?.latestPosition?.coordinate {
    let userPositionToMPPoint = MPPoint(latitude: userPosition.latitude, longitude: userPosition.longitude)
    let destination = MPPoint(latitude: 57.05803, longitude: 9.950509, z: 0.00)
    let directionsQuery = MPDirectionsQuery(originPoint: userPositionToMPPoint, destinationPoint: destination)
    let directionsService = MPMapsIndoors.shared.directionsService
    let route = try? await directionsService.routingWith(query: directionsQuery)
    let rendere = mapControl?.newDirectionsRenderer()
    rendere?.route = route
}
```

--------------------------------

### Attach position provider to MPMapControl

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/getting-started/migrating-from-v3-to-v4.md

Set the provider on your MPMapControl instance and enable showUserPosition, then start the simulation by calling simulate().

```swift
let positionProvider = MockPositionProvider()
mapControl.showUserPosition = true
mapControl.positionProvider = positionProvider

positionProvider.simulate()
```

--------------------------------

### MapsIndoors Caching and Offline Data Management (Java)

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/caching-and-offline-data.md

Java examples for MapsIndoors caching and offline data management. Includes manual synchronization, changing cache scope, listing managed datasets, adding/removing datasets, getting cache sizes, and synchronizing datasets with MPDataSetCacheManager.

```java
MapsIndoors.synchronizeContent((e) -> {
    ...
});
```

```java
MPDataSetCache dataSet = MPDataSetCacheManager.getInstance().getDataSetByID("API KEY");
dataSet.setScope(mContext, MPDataSetCacheScope.DETAILED);
MPDataSetCacheManager.getInstance().synchronizeDataSets(Collections.singletonList(dataSet));
```

```java
for (MPDataSetCache dataSet : MPDataSetCacheManager.getInstance().getManagedDataSets()) {
    Log.i("dataset", dataSet.getSolutionId() + ": size " + dataSet.getCacheItem().getSyncSize());
}
```

```java
MPDataSetCacheManager.getInstance().addDataSetWithCachingScope("API KEY", MPDataSetCacheScope.BASIC);
```

```java
MPDataSetCacheManager.getInstance().removeDataSetCache(MPDataSetCache);
```

```java
MPDataSetCache dataSet = MPDataSetCacheManager.getInstance().getDataSetByID("API KEY");
dataSet.setScope(mContext, MPDataSetCacheScope.DETAILED);
MPDataSetCacheManager.getInstance().synchronizeDataSets(Collections.singletonList(dataSet));
```

```java
dataSet.getCacheItem().getCacheSize(mContext);
dataSet.getCacheItem().getSyncSize();
```

```java
MPDataSetCacheManager.getInstance().getSyncSizesForDataSetCaches(Collections.singletonList(dataSet), this);
```

```java
MPDataSetCacheManager dataSetCacheManager = MPDataSetCacheManager.getInstance();

// sync all managed datasets
dataSetCacheManager.synchronizeDataSets();

// sync specific datasets
dataSetCacheManager.synchronizeDataSets(dataSets);
```

--------------------------------

### Using the Built-in RoomStore

Source: https://docs.mapsindoors.com/academy/use-case-guides/route-optimization-for-cleaning-operations.md

Shows how to use the built-in RoomStore: either the singleton instance or a new instance, both with setRooms.

```js
import { roomStore, RoomStore } from './js/roomStore.js';

// Use the singleton instance
roomStore.setRooms(myRoomsArray);

// Or create a new instance
const customStore = new RoomStore();
customStore.setRooms(myRoomsArray);
```

--------------------------------

### PUT /{apiKey}/api/routing/routeelements request body

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api.md

Example request body for updating route elements via the Integration API. Use with PUT /{apiKey}/api/routing/routeelements to set restrictions to "locked" for routes with too many people. The IDs and other information can be obtained from a prior GET call.

```json
[
  {
    "id": "string",
    "datasetId": "string",
    "externalId": "string",
    "geometry": {
      "type": 0
    },
    "restrictions": [
      "locked"
    ],
    "onewayDirection": 0,
    "waitTime": 0
  }
]
```

--------------------------------

### Setup direction-related member variables

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Declares properties for route view controller, constraints, navigation buttons, and location data.

```swift
var routeVC: RouteSegmentsController! = nil
var heightConstraintForRouteView:NSLayoutConstraint! = nil
var directionsVisible:Bool! {
    didSet {
        heightConstraintForRouteView.constant = directionsVisible ? 240 : 0
        UIView.animate(withDuration: 0.3) {
            self.view.layoutIfNeeded()
        }
    }
}
var searchButton:UIButton! = nil
let directions = MPMapsIndoors.shared.directionsService
var destinationLocation:MPLocation? {
    didSet {
        updateDirections()
        searchButton.setTitle(destinationLocation?.name, for: .normal)
    }
}
var originLocation:MPLocation?
```

--------------------------------

### Get default instructions

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/wayfinding-instructions.md

Returns the default route step instructions, decoding HTML-encoded text from `html_instructions` using the `String(htmlEncodedString:)` initializer.

```swift
fileprivate func getDefaultInstructions(_ currentStep: MPRouteStep) -> String? {
    return String(htmlEncodedString: currentStep.html_instructions)
}
```

--------------------------------

### Quick Start: Save, Load, and Clear Parking

Source: https://docs.mapsindoors.com/academy/use-case-guides/parking-spot-mark-and-navigate-back.md

Shows the basic usage of ParkingManager: create an instance (using localStorage by default), save a MapsIndoors location, check if parking exists, load the saved parking data, and clear it. The example logs the saved parking name to the console.

```javascript
import { ParkingManager } from './parking.js';

// Create a ParkingManager instance (uses localStorage by default)
const parking = new ParkingManager();

// Save a MapsIndoors location as parking
parking.saveParkingSpot(mapsIndoorsLocation);

// Check if parking exists
if (parking.hasSavedParking()) {
  // Load the saved parking data
  const savedParking = parking.loadParkingSpot();
  console.log('Parked at:', savedParking.name);
}

// Clear saved parking
parking.clearParkingSpot();
```

--------------------------------

### Import ParkingManager and Adapters

Source: https://docs.mapsindoors.com/academy/use-case-guides/parking-spot-mark-and-navigate-back.md

Import the ParkingManager class and the storage adapters (LocalStorageAdapter and CookieStorageAdapter) from the parking.js module. This is the second step of the installation process.

```javascript
import { ParkingManager, LocalStorageAdapter, CookieStorageAdapter } from './parking.js';
```

--------------------------------

### Get dataset cache size with cacheItem.getCacheSize and syncSize

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/caching-and-offline-data.md

Retrieves the estimated and cached size of a dataset. The first line gets the estimated size, the second gets the synchronized size.

```kotlin
dataSet?.cacheItem?.getCacheSize(mContext)
dataSet?.cacheItem?.syncSize
```

--------------------------------

### MainActivity.kt implementation for dynamic map provider switching

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/using-multiple-map-providers.md

This example shows how to define a buildConfig method to swap between Google and Mapbox map fragments and initialize MapControl with the selected provider.

```kotlin
import android.os.Build
import android.os.Bundle
import androidx.annotation.RequiresApi
import androidx.fragment.app.FragmentActivity
import com.mapsindoors.core.MPDebugLog
import com.mapsindoors.core.MapControl
import com.mapsindoors.core.MapsIndoors
import com.mapsindoors.core.OnMapsIndoorsReadyListener
import com.mapsindoors.core.OnResultReadyListener
import com.mapsindoors.core.errors.MIError
import com.mapsindoors.core.models.MPCameraPosition
import com.mapsindoors.testapp.Provider.Google
import com.mapsindoors.testapp.Provider.Mapbox
import com.mapsindoors.testapp.providers.GoogleMapFragment
import com.mapsindoors.testapp.providers.MIMap
import com.mapsindoors.testapp.providers.MapFragment
import com.mapsindoors.testapp.providers.MapboxMapFragment

class MainActivity : FragmentActivity(), OnResultReadyListener {
  private var mMapControl: MapControl? = null
  private lateinit var mFragment: MapFragment
  private lateinit var mMIMap: MIMap

  @RequiresApi(api = Build.VERSION_CODES.M)
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    buildConfig(Mapbox, "mapspeople3d") { e: MIError? -> }
  }

  override fun onResultReady(error: MIError?) {
    mMIMap = mFragment.getMap()
    initMapControl()
  }

  private fun initMapControl() {
    val mapConfig = mFragment.getMapConfigBuilder().setShowUserPosition(true).build()
    MapControl.create(mapConfig) { mapControl: MapControl?, miError: MIError? ->
      if (miError == null) {
        mMapControl = mapControl
        val venue = (MapsIndoors.getVenues() ?: return@create).defaultVenue
        runOnUiThread {
          if (venue != null) {
            mMapControl?.selectFloor(venue.defaultFloor)
            mMIMap.animateCamera(MPCameraPosition.Builder().setTarget(venue.bounds?.center).setZoom(17f).build())
          }
        }
      }
    }
  }

  private fun buildConfig(provider: Provider, apiKey: String, listener: OnMapsIndoorsReadyListener) {
    mFragment = when (provider) {
      Google -> GoogleMapFragment()
      Mapbox -> MapboxMapFragment()
    }
    supportFragmentManager.beginTransaction().add(R.id.map_fragment, mFragment).commit()
    MapsIndoors.load(application, apiKey, listener)
    mFragment.isReady(this)
  }

  override fun onDestroy() {
    super.onDestroy()
    mFragment.onDestroy()
  }
}

enum class Provider {
  Mapbox, Google,
}
```

--------------------------------

### Build the application with a base path

Source: https://docs.mapsindoors.com/products/fast-track-maptemplate/deploying-map-template-to-a-cloud-storage-provider.md

Use this command to build the application with the bucket name prepended to all links, ensuring correct asset resolution when deployed to a storage bucket.

```bash
vite build --base=/YOUR_BUCKET_NAME
```

--------------------------------

### Filter locations by categories using getLocations

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/search/searching.md

Example from the parameters table showing how to filter locations by categories using the 'categories' parameter. The 'lr' parameter is set to 'en'.

```javascript
mapsindoors.services.LocationsService.getLocations({ categories: categoryKey, lr: 'en' }).then(locations => { ... });
```

--------------------------------

### Filter locations by types using getLocations

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/search/searching.md

Example from the parameters table showing how to filter locations by types, e.g., 'meetingroom', using the 'types' parameter. The 'lr' parameter is set to 'en'.

```javascript
mapsindoors.services.LocationsService.getLocations({ lr: 'en', types: ['meetingroom'] }).then(locations => { ... });
```

--------------------------------

### Set up WayfindingFragment onCreateView

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/directions/wayfinding-instructions.md

Sets up the WayfindingFragment's view: inflates the binding, loads MapsIndoors with the API key "gettingstarted", attaches a RouteCollectionAdapter to a ViewPager2, and initializes the map fragment. The onPageSelected callback is currently empty but can be used to react to page changes.

```kotlin
override fun onCreateView(view: View, @Nullable savedInstanceState: Bundle?) {
    _binding = FragmentWayfindingBinding.inflate(inflater, container, false)

    MapsIndoors.load(requireActivity().applicationContext, "gettingstarted", null)

    val routeLegAdapter = RouteCollectionAdapter(this)
    val viewPager = binding.stepViewPager
    viewPager.adapter = routeLegAdapter
    viewPager.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
        override fun onPageSelected(position: Int) {
            super.onPageSelected(position)
        }
    })

    val root: View = binding.root
    val supportMapFragment = childFragmentManager.findFragmentById(R.id.map) as SupportMapFragment
    mMapView = supportMapFragment.view
    supportMapFragment.getMapAsync(this)
    return root
}
```

--------------------------------

### Setup member variables

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/searching/creating-a-search-experience.md

Creates the required properties for the search controller: location service, query, results array, delegate, table view, and search bar.

```swift
let locationService = MPLocationService.sharedInstance()
let query = MPQuery()
var locations:[MPLocation] = []
var delegate:MySearchControllerDelegate? = nil
let tableView = UITableView()
let searchBar = UISearchBar()
```

--------------------------------

### Install MapsIndoors Map Template via NPM

Source: https://docs.mapsindoors.com/products/fast-track-maptemplate/getting-started/react-component.md

Install the stable version of the MapsIndoors map template package.

```bash
npm install @mapsindoors/map-template@stable
```

--------------------------------

### Initialize React Native Project

Source: https://docs.mapsindoors.com/sdks-and-frameworks/react-native/getting-started/project-setup.md

Create a new React Native project using the latest version.

```shell
npx react-native@latest init GettingStartedProject
```

--------------------------------

### Setup and execute a directions query with MPDirectionsQuery

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/directions/directions-service.md

Sets up a route request with origin and destination points, executes it, and renders the route on the map with fit bounds and animation. Requires a valid API key and map configuration.

```swift
try await MPMapsIndoors.shared.load(apiKey: #INSERT_API_KEY)
          
mapControl = MPMapsIndoors.createMapControl(mapConfig: #INSERT_YOUR_MAPCONFIG)
          
let origin = MPPoint(latitude:57.059884140172585, longitude: 9.939936105948238, z: 0)
let destination = MPPoint(latitude: 57.05718292988392, longitude: 9.930720035736968, z: 0)
let directionsQuery = MPDirectionsQuery(originPoint: origin, destinationPoint: destination)
let route = try? await directionsService.routingWith(query: directionsQuery)

let renderer = mapControl?.newDirectionsRenderer()
renderer?.fitBounds = true
renderer?.route = route
renderer?.animate(duration: 5)
```

--------------------------------

### Dataset JSON example

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/data-description.md

Example of a dataset object showing available languages, base language, and root objects.

```json
{
  "id": "550c26a864617400a40f0000",
  "name": "RTX",
  "availableLanguages": [
    "en",
    "da"
  ],
  "baseLanguage": "en",
  "rootObjects": [
    "550c286964617400a4100000"
  ]
}
```

--------------------------------

### Attach position provider in fragment

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/user-positioning/using-google-fused-location-provider.md

Shows how to instantiate the GPSPositionProvider, load MapsIndoors with an API key, set the position provider, and start positioning from a button click. Remember to handle permissions for the position provider.

```kotlin
class MyFragment: Fragment(), OnMapReadyCallback {
    private var mPositionProvider: GPSPositionProvider? = null

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?,): View {
        ...
            mPositionProvider = GPSPositionProvider(requireActivity())
            MapsIndoors.load(requireActivity().applicationContext, "myapikey") {
                // Attach the position provider to the SDK
                MapsIndoors.setPositionProvider(mPositionProvider)
            }

            //Have a buttton or other logic to start positioning:
            binding.startPositioningButton.setOnClickListener {
                //Remember to handle permissions specific to the Position provider you are using
                mPositionProvider?.startPositioning()
            }
        ...
    }
}
```

--------------------------------

### GET /{apiKey}/api/routing/routeelements

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/openapi-specification.md

This endpoint is part of the MapsIndoors Integration API. It is documented in the OpenAPI specification and is called with a GET request.

```APIDOC
## GET /{apiKey}/api/routing/routeelements

### Description
This endpoint is part of the MapsIndoors Integration API. It is documented in the OpenAPI specification and is called with a GET request.

### Method
GET

### Endpoint
/{apiKey}/api/routing/routeelements

### Parameters
#### Path Parameters
- **apiKey** - Required - The API key for the MapsIndoors integration.
```

--------------------------------

### GET /{apiKey}/api/routing/graphs

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/openapi-specification.md

This endpoint is part of the MapsIndoors Integration API. It is documented in the OpenAPI specification and is called with a GET request.

```APIDOC
## GET /{apiKey}/api/routing/graphs

### Description
This endpoint is part of the MapsIndoors Integration API. It is documented in the OpenAPI specification and is called with a GET request.

### Method
GET

### Endpoint
/{apiKey}/api/routing/graphs

### Parameters
#### Path Parameters
- **apiKey** - Required - The API key for the MapsIndoors integration.
```

--------------------------------

### Provide Google API key

Source: https://docs.mapsindoors.com/sdks-and-frameworks/ios/getting-started/create-a-new-project.md

Insert into application(_:didFinishLaunchingWithOptions:) method. Replace YOUR_GOOGLE_API_KEY with your Google API key.

```swift
GMSServices.provideAPIKey("YOUR_GOOGLE_API_KEY")
```

--------------------------------

### Initialize MapsControl with Google Maps (MPMapConfig, MapControl.create)

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/getting-started/show-a-map.md

Creates a MapControl instance using MPMapConfig with a GoogleMap. On success, enables live data, gets the current venue, and animates the camera to fit the venue bounds. Requires a Google Maps key and a map view.

```kotlin
private fun initMapControl(view: View) {
    MPMapConfig mapConfig = new MPMapConfig.Builder(this, mMap, getString(R.string.google_maps_key), view, true).build();
    //Creates a new instance of MapControl
    MapControl.create(config) { mapControl, miError ->
        if (miError == null) {
            mMapControl = mapControl!!
            //Enable live data on the map
            enableLiveData()
            //No errors so getting the first venue (in the white house solution the only one)
            val venue = MapsIndoors.getVenues()?.currentVenue
            venue?.bounds?.let {
                runOnUiThread {
                    //Animates the camera to fit the new venue
                    mMap.animateCamera(CameraUpdateFactory.newLatLngBounds(LatLngBoundsConverter.toLatLngBounds(it), 19))
                }
            }
        }
    }
}
```

--------------------------------

### Category JSON example

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/data-description.md

Example of a Category object with id, key, name, and properties. The name is translatable and properties include language-specific descriptions.

```json
{
  "id": "5823246d07215b23a02e3cdd",
  "key": "entrance",
  "name": {
    "en": "Entrance",
    "da": "Indgang"
  },
  "properties": {
    "description@en": "The entrance closest to the parking lot",
    "description@da": "Indgangen tættest på parkeringspladsen"
  }
}
```

--------------------------------

### Get sync sizes for dataset caches with MPDataSetCacheManager

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/caching-and-offline-data.md

Refreshes or gets the size of a synced dataset asynchronously. Requires a MPDataSetCacheManagerSizeListener to receive progress and results.

```kotlin
MPDataSetCacheManager.getInstance().getSyncSizesForDataSetCaches(listOf(dataSet), this)
```

--------------------------------

### Install @mapsindoors/built-in-map-edits with npm or yarn

Source: https://docs.mapsindoors.com/sdks-and-frameworks/built-in-map-edits/getting-started.md

Install the @mapsindoors/built-in-map-edits package using either npm or yarn. Both commands are equivalent alternatives for adding the package to your project.

```shell
npm install @mapsindoors/built-in-map-edits
```

```shell
yarn add @mapsindoors/built-in-map-edits
```

--------------------------------

### Initialize CiscoDNAPositionProvider Class

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/user-positioning/using-cisco-dna-spaces.md

Create the CiscoDNAPositionProvider class implementing the MPPositionProvider interface with a constructor requiring Context and MPCiscoDNAConfig.

```kotlin
class CiscoDNAPositionProvider (private val context: Context, private val config: MPCiscoDNAConfig): MPPositionProvider {
    private var mLatestPosition: MPPositionResultInterface? = null
    private val positionUpdateListeners = ArrayList<OnPositionUpdateListener>()
    //If you do not have CiscoDNA set up through MapsIndoors you can write your tenantId here instead of using one from the config
    private val tenantId: String? = config.tenantId
}
```

--------------------------------

### Example POI Geodata JSON

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/data-description.md

A JSON example of a MapsIndoors POI (coat hanger) showing the structure of a Geodata object, including id, parentId, baseType, geometry, and properties.

```json
{
  "id": "13889288f79d4abfb7021ad7",
  "parentId": "f43b931f09314f3f9dd796f9",
  "datasetId": "550c26a864617400a40f0000",
  "baseType": "poi",
  "baseTypeProperties": {
    "class": null,
    "imageurl": null,
    "activefrom": null,
    "activeto": null,
    "administrativeid": "RTX"
  },
  "displayTypeId": "d7558711f7c64534972cc65f",
  "geometry": {
    "coordinates": [
      9.956830884329975,
      57.085763732415764
    ],
    "type": "Point"
  },
  "aliases": [],
  "categories": [],
  "status": 3,
  "properties": {
    "name@en": "Coat stand (RT)",
    "name@da": "Jakkeholder (RT)",
    "description@en": "Just a regular coat stand",
    "description@da": "En almindelig jakkeholder"
  }
}
```

--------------------------------

### Opening Hours Additional Detail JSON Example

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/data-description.md

Example JSON defining an additional detail of type 'openinghours'. When detailType is 'openinghours', the 'value' field is not used, and the 'openingHours' property holds daily schedules. The 'startTime' and 'endTime' values must be valid time formats and must not be equal. This example shows every weekday with a closed Sunday.

```json
{
  "key": "openinghours-1",
  "detailType": "openinghours",
  "active": false,
  "icon": "https://www.example.com/openinghoursicon.png",
  "displayText": {
    "en": "Opening hours",
    "da": "Åbningstider"
  },
  "openingHours": {
    "standardOpeningHours": {
      "monday": {
        "closedAllDay": false,
        "startTime": "15:00",
        "endTime": "21:00"
      },
      "tuesday": {
        "closedAllDay": false,
        "startTime": "15:00",
        "endTime": "21:00"
      },
      "wednesday": {
        "closedAllDay": false,
        "startTime": "15:00",
        "endTime": "21:00"
      },
      "thursday": {
        "closedAllDay": false,
        "startTime": "15:00",
        "endTime": "21:00"
      },
      "friday": {
        "closedAllDay": false,
        "startTime": "15:00",
        "endTime": "22:00"
      },
      "saturday": {
        "closedAllDay": false,
        "startTime": "12:00",
        "endTime": "22:00"
      },
      "sunday": {
        "closedAllDay": true
      }
    }
  }
}
```

--------------------------------

### GET /

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/openapi-specification.md

Retrieves the root endpoint information.

```APIDOC
## GET /

### Description
Retrieves the root endpoint information.

### Method
GET

### Endpoint
https://integration.mapsindoors.com/

### Response
#### Success Response (200)
Returns root endpoint information.

```

--------------------------------

### Initialize MapsControl with Mapbox (MPMapConfig, MapControl.create)

Source: https://docs.mapsindoors.com/sdks-and-frameworks/android/getting-started/show-a-map.md

Creates a MapControl instance using MPMapConfig with a Mapbox map. On success, enables live data, gets the current venue, and flies the camera to fit the venue bounds. Requires a Mapbox access token.

```kotlin
private fun initMapControl() {
    //Creates a new instance of MapControl
    val config = MPMapConfig.Builder(this, mMap, mapView, getString(R.string.mapbox_access_token),true).build()
    MapControl.create(config) { mapControl, miError ->
        if (miError == null) {
            mMapControl = mapControl!!
            //Enable live data on the map
            enableLiveData()
            //No errors so getting the first venue (in the white house solution the only one)
            val venue = MapsIndoors.getVenues()?.currentVenue
            venue?.bounds?.let {
                runOnUiThread {
                    //Animates the camera to fit the new venue
                    mMap.flyTo(mMap.cameraForCoordinateBounds(CoordinateBoundsConverter.toCoordinateBounds(it)))
                }
            }
        }
    }
}
```

--------------------------------

### GET /api/dataset/customer

Source: https://docs.mapsindoors.com/sdks-and-frameworks/integration-api/openapi-specification.md

Retrieves customer dataset information.

```APIDOC
## GET /api/dataset/customer

### Description
Retrieves customer dataset information.

### Method
GET

### Endpoint
https://integration.mapsindoors.com/api/dataset/customer

### Response
#### Success Response (200)
Returns customer dataset information.

```

--------------------------------

### Initialize DirectionsService with GoogleMapsProvider

Source: https://docs.mapsindoors.com/sdks-and-frameworks/web/directions-and-routing/directions-service.md

Instantiate the DirectionsService using the GoogleMapsProvider.

```javascript
const externalDirectionsProvider = new mapsindoors.directions.GoogleMapsProvider();
const miDirectionsServiceInstance = new mapsindoors.services.DirectionsService(externalDirectionsProvider);
```

--------------------------------

### Build components for Map Template

Source: https://docs.mapsindoors.com/products/fast-track-maptemplate/customization.md

Run this command from the root folder to ensure changes in the components package are reflected in the map-template package.

```bash
npx lerna run build
```