SDK for Indoor Navigation and Beyond

USER LOCALIZATION

Add the Locator library

Add the locator library as embedded content to your project. It should look like the following image.

For swift projects you have to import the Locator header in your bridging header file as follows.

//
//  Use this file to import your target's public headers that you would like to expose to Swift.
//

#import <InfsoftLocatorLib/InfsoftLocator.h>

Info.plist##

Since the position of the user is determined via Bluetooth, the NSBluetoothAlwaysUsageDescription and NSBluetoothPeripheralUsageDescription key must be additionally added to your Info.plist.
The Locator library also requires NSMotionUsageDescription as a key in your Info.plist file. The library pauses the location updates if no device motion is detected. In this way the battery consumption is reduced.

UserLocalizationViewController

To display the user’s position via BLE, the map’s default location manager must be overwritten.

import UIKit
import Mapbox

class UserLocalizationViewController: UIViewController {
    // Sample UI controls. This can be extended as desired
    @IBOutlet private weak var userTrackingModeButton: UIButton!
    @IBOutlet private weak var mapLevelButton: UIButton!

    let styleHost = "tilesservices.webservices.infsoft.com"
    let stylePath = "/api/mapstyle/style/"
    let apiKey = "316cf74a-290b-4c4f-91c0-43989cdb15d3"
    let initial3D = "false"
    
    let numberOfMapLevels = 4
    var mapLevel = 0
    weak var mapView: MGLMapView?

    override func viewDidLoad() {
        super.viewDidLoad()

        var components = URLComponents()
        components.scheme = "https"
        components.host = styleHost
        components.path = stylePath + apiKey
        let queryItemConfig = URLQueryItem(name: "config", value: "3d:\(initial3D)")
        components.queryItems = [queryItemConfig]

        let mapView = MGLMapView(frame: view.bounds, styleURL: components.url)
        self.mapView = mapView
        mapView.delegate = self
        mapView.userTrackingMode = .follow
        mapView.locationManager = CustomLocationManager()
        mapView.showsUserLocation = true
        mapView.showsUserHeadingIndicator = true
        mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        mapView.setCenter(CLLocationCoordinate2D(latitude: 50.99319673751623,
                                                 longitude: 11.012463569641115),
                          zoomLevel: 16,
                          animated: false)
        view.insertSubview(mapView, at: 0)
        
        // Disable telemetry and hide button
        UserDefaults.standard.set(false, forKey: "MGLMapboxMetricsEnabled")
        mapView.attributionButton.isHidden = true
        mapView.logoView.isHidden = true
    }

    // MARK: - Example action outlets
  
    /**
     Example action outlet for switching the user tracking mode.
     If you want to use this feature just connect an UIButton to this outlet
     */
    @IBAction private func switchUserTrackingMode(_ sender: Any) {
        guard let mapView = mapView else {
            return
        }

        switch mapView.userTrackingMode {
        case .follow:
            mapView.userTrackingMode = .none
        default:
            mapView.userTrackingMode = .follow
        }
    }

    /**
     Example action outlet for switching the map level.
     If you want to use this feature just connect an UIButton to this outlet
     */
    @IBAction private func switchLevel(_ sender: Any) {
        let newLevel = (mapLevel + 1) % numberOfMapLevels
        guard let mapView = mapView else {
            return
        }
        mapView.userTrackingMode = .none
        setMapLevel(in: mapView, level: newLevel)

        if let userLocation = mapView.userLocation {
            updateUserAnnotation(userLocation, in: mapView)
        }
    }

    /**
     Optional method for updating the UI in case the tracking mode
     changes
     */
    func updateUserTrackingControl(for mode: MGLUserTrackingMode) {
        userTrackingModeButton.isSelected = mode == .follow
    }

    /**
      Optional method for updating the UI in case the map level
      changes
     */
    func updateMapLevelControl(for level: Int) {
        mapLevelButton.setTitle("\(level)", for: .normal)
    }

    // MARK: - Map level handling

    /**
     This method syncs the map level to the user level if the corresponding mode is selected
     */
    func syncMapLevel() {
        guard let mapView = mapView else {
            return
        }
        switch mapView.userTrackingMode {
        case .follow, .followWithHeading:
            guard let userLevel = (mapView.userLocation?.location as? CLLocation3D)?.level else {
                break
            }
            self.setMapLevel(in: mapView, level: userLevel)
        default:
            break
        }
    }

    func setMapLevel(in mapView: MGLMapView, level: Int) {
        guard let style = mapView.style, level != mapLevel else {
            return
        }
        let filterLayers: [MGLVectorStyleLayer] = style.layers.compactMap {
            $0 as? MGLVectorStyleLayer
        }.filter {
            $0.identifier.contains("locls")
        }

        for layer in filterLayers {
            if let predicate = layer.predicate {
                guard let rawData = predicate.mgl_jsonExpressionObject as? [Any] else {
                    return
                }
                let newPredicate = NSPredicate(mglJSONObject: setFilter(filter: rawData, level: level))
                layer.predicate = newPredicate
            }
        }

        mapLevel = level
        updateMapLevelControl(for: level)
    }

    func setFilter(filter: Any, level: Int) -> Any {
        guard var predicates = filter as? [Any] else {
            return filter
        }

        for (index, element) in predicates.enumerated() {
            if element as? [Any] != nil {
                predicates[index] = self.setFilter(filter: element, level: level)
                continue
            }

            if index == 0 {
                continue
            }

            guard let prev = predicates[index - 1] as? String else {
                continue
            }

            if predicates[index] as? Int == nil {
                continue
            }

            if prev != "level" {
                continue
            }

            predicates[index] = level
        }
        return predicates
    }
}

// MARK: - Mapbox mapView delegate

extension UserLocalizationViewController: MGLMapViewDelegate {
    func mapView(_ mapView: MGLMapView, didUpdate userLocation: MGLUserLocation?) {
        guard let userLocation = mapView.userLocation else {
            return
        }
        syncMapLevel()
        updateUserAnnotation(userLocation, in: mapView)
    }

    func mapView(_ mapView: MGLMapView, didChange mode: MGLUserTrackingMode, animated: Bool) {
        syncMapLevel()
        updateUserTrackingControl(for: mode)
    }

    /**
     Hide the annotation view if the wrong level is selected. If the default view is used,
     this is achieved by setting a large offset. If you implement the annotation view by yourself,
     you can do this explicitly using the update() method
     */
    func updateUserAnnotation(_ userLocation: MGLUserLocation, in mapView: MGLMapView) {
        guard let location3DCoordinate = userLocation.location as? CLLocation3D else {
            return
        }
        let view = mapView.view(for: userLocation)
        if location3DCoordinate.level != mapLevel {
             view?.centerOffset = CGVector(dx: 0, dy: Int.max)
         } else {
             view?.centerOffset = CGVector(dx: 0, dy: 0)
         }
         mapView.updateUserLocationAnnotationView()
    }
}

CustomLocationManager

import UIKit
import Mapbox

class CustomLocationManager: NSObject, MGLLocationManager {
    weak var delegate: MGLLocationManagerDelegate?
    let apiKey = "8c97d7c6-0c3a-41de-b67a-fb7628efba79"

    /// CLLocationManager is used for requesting the user heading
    lazy var clLocationManger: CLLocationManager = {
        let locationManager = CLLocationManager()
        locationManager.delegate = self
        return locationManager
    }()

    /// ILLocationManager is used for requesting the user position
    lazy var ilLocationManger: ILLocationManager = {
        let iLLocationServiceManager = ILLocationServiceManager.getInstance(ILLocationServiceManager_UseAll)
        iLLocationServiceManager?.apiKey = apiKey
        return ILLocationManager()
    }()

    var authorizationStatus: CLAuthorizationStatus {
        CLLocationManager.authorizationStatus()
    }

    var headingOrientation: CLDeviceOrientation {
        get {
            clLocationManger.headingOrientation
        }
        set {
            clLocationManger.headingOrientation = newValue
        }
    }

    func requestAlwaysAuthorization() {
        clLocationManger.requestAlwaysAuthorization()
    }

    func requestWhenInUseAuthorization() {
        clLocationManger.requestWhenInUseAuthorization()
    }

    func startUpdatingLocation() {
        ilLocationManger.requestLocationUpdates(self, minTime: 0, minDistance: 0)
    }

    func stopUpdatingLocation() {
        clLocationManger.stopUpdatingLocation()
    }

    func startUpdatingHeading() {
        clLocationManger.startUpdatingHeading()
    }

    func stopUpdatingHeading() {
        clLocationManger.stopUpdatingHeading()
    }

    func dismissHeadingCalibrationDisplay() {
        clLocationManger.dismissHeadingCalibrationDisplay()
    }
}

// MARK: - CLLocationManagerDelegate

extension CustomLocationManager: CLLocationManagerDelegate {
    /// This method should do nothing. Use ILLocationManager instead
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
    }

    func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
        delegate?.locationManager(self, didUpdate: newHeading)
    }

    func locationManagerShouldDisplayHeadingCalibration(_ manager: CLLocationManager) -> Bool {
        delegate?.locationManagerShouldDisplayHeadingCalibration(self) ?? false
    }

    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        delegate?.locationManager(self, didFailWithError: error)
    }
}

// MARK: - ILLocation

extension CustomLocationManager: ILLocationListener {
    func onLocationChanged(_ location: ILLocation!) {
        let clLocation3D = CLLocation3D(latitude: location.latitude, longitude: location.longitude)
        clLocation3D.level = Int(location.level)
        delegate?.locationManager(self, didUpdate: [clLocation3D])
    }
}

/// Extension of the class so that the user level can also be specified
class CLLocation3D: CLLocation {
    var level: Int?
}