AsyncRouteManagerExample.swift

Go to the documentation of this file.

import Foundation
 
/**
 * AsyncRouteManager usage example for Swift
 * Demonstrates working with async route planning, session management, and navigation
 */
class AsyncRouteManagerExample: NSObject {
    private var sdk: NCNavigineSdk?
    private var locationManager: NCLocationManager?
    private var navigationManager: NCNavigationManager?
    private var asyncRouteManager: NCAsyncRouteManager?
    private var currentSession: NCRouteSession?
 
    override init() {
        super.init()
        initializeSdk()
        setupAsyncRouteListener()
    }
 
    /**
     * Initialize SDK and get managers
     */
    private func initializeSdk() {
        do {
            // [swift_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NCNavigineSdk.getInstance()
            // [swift_NavigineSdk_getInstance]
 
            // [swift_NavigineSdk_setUserHash]
            // Set user hash
            sdk?.setUserHash("USER-HASH-HERE")
            // [swift_NavigineSdk_setUserHash]
 
            // [swift_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk?.setServer("https://custom.navigine.com")
            // [swift_NavigineSdk_setServer]
 
            // [swift_NavigineSdk_getLocationManager]
            // Get LocationManager for working with locations
            locationManager = sdk?.getLocationManager()
            // [swift_NavigineSdk_getLocationManager]
 
            // [swift_NavigineSdk_getNavigationManager]
            // Get NavigationManager for working with navigation
            navigationManager = sdk?.getNavigationManager(locationManager)
            // [swift_NavigineSdk_getNavigationManager]
 
            // [swift_NavigineSdk_getAsyncRouteManager]
            // Get AsyncRouteManager for working with async routes
            asyncRouteManager = sdk?.getAsyncRouteManager(locationManager, navigationManager: navigationManager)
            // [swift_NavigineSdk_getAsyncRouteManager]
 
            if let locationManager = locationManager,
               let navigationManager = navigationManager,
               let asyncRouteManager = asyncRouteManager {
                print("LocationManager, NavigationManager and AsyncRouteManager successfully initialized")
            }
        } catch {
            print("Error initializing SDK: \‍(error)")
        }
    }
 
    /**
     * Setup async route listener
     */
    private func setupAsyncRouteListener() {
        // AsyncRouteListener is implemented via protocol extension
        // No additional setup needed for Swift
    }
 
    /**
     * Demonstrate AsyncRouteManager methods
     */
    func demonstrateAsyncRouteManagerMethods() {
        guard let manager = asyncRouteManager else {
            print("AsyncRouteManager not initialized")
            return
        }
 
        // Create test destination point
        let destinationPoint = NCPoint(x: 100.0, y: 100.0)
        let destinationLocationPoint = NCLocationPoint(point: destinationPoint, locationId: 12345, sublocationId: 1)
 
        // Create route options
        let routeOptions = NCRouteOptions(smoothRadius: 2.0, maxProjectionDistance: 5.0, maxAdvance: 2.0)
 
        // [swift_AsyncRouteManager_createRouteSession]
        // Create route session with default graph tag
        let session = manager.createRouteSession(destinationLocationPoint, routeOptions: routeOptions)
        print("Created route session with default graph tag")
        // [swift_AsyncRouteManager_createRouteSession]
 
        // [swift_AsyncRouteManager_createRouteSessionWithTag]
        // Create route session with specific graph tag
        let sessionWithTag = manager.createRouteSession(withTag: destinationLocationPoint, routeOptions: routeOptions, tag: "main")
        print("Created route session with 'main' graph tag")
        // [swift_AsyncRouteManager_createRouteSessionWithTag]
 
        // Store session for later use
        currentSession = session
 
        // Add listener to session
        // [swift_RouteSession_addRouteListener]
        // Add route listener to session
        session?.addRouteListener(self)
        // [swift_RouteSession_addRouteListener]
    }
 
    /**
     * Demonstrate RoutePath usage
     */
    func demonstrateRoutePathUsage(_ routePath: NCRoutePath) {
        guard let routePath = routePath else {
            print("RoutePath is null")
            return
        }
 
        // [swift_RoutePath_getLength]
        // Get route length
        let length = routePath.getLength()
        print("Route length: \‍(length) meters")
        // [swift_RoutePath_getLength]
 
        // [swift_RoutePath_getPoints]
        // Get route points
        let points = routePath.getPoints()
        print("Number of route points: \‍(points.count)")
        for (index, point) in points.prefix(3).enumerated() {
            print("Point \‍(index + 1): \‍(point)")
        }
        // [swift_RoutePath_getPoints]
 
        // [swift_RoutePath_getEvents]
        // Get route events
        let events = routePath.getEvents()
        print("Number of route events: \‍(events.count)")
        for event in events.prefix(3) {
            demonstrateRouteEventUsage(event)
        }
        // [swift_RoutePath_getEvents]
 
        // [swift_RoutePath_head]
        // Get route head (first 10 meters)
        if let head = routePath.head(10.0) {
            print("Route head length: \‍(head.getLength()) meters")
        }
        // [swift_RoutePath_head]
 
        // [swift_RoutePath_tail]
        // Get route tail (remaining after 10 meters)
        if let tail = routePath.tail(10.0) {
            print("Route tail length: \‍(tail.getLength()) meters")
        }
        // [swift_RoutePath_tail]
    }
 
    /**
     * Demonstrate RouteEvent usage
     */
    func demonstrateRouteEventUsage(_ event: NCRouteEvent) {
        guard let event = event else {
            print("RouteEvent is null")
            return
        }
 
        // [swift_RouteEvent_getType]
        // Get event type
        let type = event.getType()
        print("Event type: \‍(type)")
        // [swift_RouteEvent_getType]
 
        // [swift_RouteEvent_getValue]
        // Get event value
        let value = event.getValue()
        print("Event value: \‍(value)")
        // [swift_RouteEvent_getValue]
 
        // [swift_RouteEvent_getDistance]
        // Get event distance
        let distance = event.getDistance()
        print("Event distance: \‍(distance) meters")
        // [swift_RouteEvent_getDistance]
 
        // [swift_RouteEvent_constructor]
        // Create new route event
        let newEvent = NCRouteEvent(type: .turnLeft, value: 90, distance: 50.0)
        print("Created new route event: \‍(newEvent.getType()) at \‍(newEvent.getDistance()) meters")
        // [swift_RouteEvent_constructor]
    }
 
    /**
     * Demonstrate RouteEventType enum values
     */
    func demonstrateRouteEventTypes() {
        // [swift_RouteEventType_values]
        // Get all route event type values
        let types: [NCRouteEventType] = [.turnLeft, .turnRight, .transition]
        print("Available route event types:")
        for type in types {
            print("  - \‍(type)")
        }
        // [swift_RouteEventType_values]
    }
 
    /**
     * Demonstrate LocationPoint usage
     */
    func demonstrateLocationPointUsage(_ locationPoint: NCLocationPoint) {
        guard let locationPoint = locationPoint else {
            print("LocationPoint is null")
            return
        }
 
        // [swift_LocationPoint_getPoint]
        // Get point coordinates
        let point = locationPoint.getPoint()
        print("Location point: (\‍(point.getX()), \‍(point.getY()))")
        // [swift_LocationPoint_getPoint]
 
        // [swift_LocationPoint_getLocationId]
        // Get location ID
        let locationId = locationPoint.getLocationId()
        print("Location ID: \‍(locationId)")
        // [swift_LocationPoint_getLocationId]
 
        // [swift_LocationPoint_getSublocationId]
        // Get sublocation ID
        let sublocationId = locationPoint.getSublocationId()
        print("Sublocation ID: \‍(sublocationId)")
        // [swift_LocationPoint_getSublocationId]
 
        // [swift_LocationPoint_constructor]
        // Create new location point
        let newPoint = NCPoint(x: 25.0, y: 35.0)
        let newLocationPoint = NCLocationPoint(point: newPoint, locationId: 12345, sublocationId: 2)
        print("Created new location point: \‍(newLocationPoint.getPoint().getX()), \‍(newLocationPoint.getPoint().getY())")
        // [swift_LocationPoint_constructor]
    }
 
    /**
     * Demonstrate Point usage
     */
    func demonstratePointUsage(_ point: NCPoint) {
        guard let point = point else {
            print("Point is null")
            return
        }
 
        // [swift_Point_getX]
        // Get X coordinate
        let x = point.getX()
        print("Point X: \‍(x)")
        // [swift_Point_getX]
 
        // [swift_Point_getY]
        // Get Y coordinate
        let y = point.getY()
        print("Point Y: \‍(y)")
        // [swift_Point_getY]
 
        // [swift_Point_constructor]
        // Create new point
        let newPoint = NCPoint(x: 15.0, y: 25.0)
        print("Created new point: (\‍(newPoint.getX()), \‍(newPoint.getY()))")
        // [swift_Point_constructor]
    }
 
    /**
     * Demonstrate RouteOptions usage
     */
    func demonstrateRouteOptions() {
        print("=== Route Options ===")
 
        // [swift_RouteOptions_constructor]
        // Create route options with custom parameters
        let routeOptions = NCRouteOptions(smoothRadius: 3.0, maxProjectionDistance: 7.0, maxAdvance: 2.5)
        print("Created route options with smoothRadius: \‍(routeOptions.getSmoothRadius()), maxProjectionDistance: \‍(routeOptions.getMaxProjectionDistance()), maxAdvance: \‍(routeOptions.getMaxAdvance())")
        // [swift_RouteOptions_constructor]
 
        // Demonstrate different route options configurations
        let optionsList = [
            NCRouteOptions(smoothRadius: 0.0, maxProjectionDistance: 5.0, maxAdvance: 2.0),    // No smoothing
            NCRouteOptions(smoothRadius: 2.0, maxProjectionDistance: 10.0, maxAdvance: 1.0),   // High smoothing, high projection distance
            NCRouteOptions(smoothRadius: 1.0, maxProjectionDistance: 3.0, maxAdvance: 3.0),    // Low smoothing, low projection distance
        ]
 
        for (index, options) in optionsList.enumerated() {
            print("Options \‍(index + 1): smoothRadius=\‍(options.getSmoothRadius()), maxProjectionDistance=\‍(options.getMaxProjectionDistance()), maxAdvance=\‍(options.getMaxAdvance())")
        }
    }
 
    /**
     * Demonstrate advanced async routing features
     */
    func demonstrateAdvancedAsyncRoutingFeatures() {
        print("=== Advanced Async Routing Features ===")
 
        guard let manager = asyncRouteManager else {
            return
        }
 
        // Create multiple destination points
        let destinations = [
            NCLocationPoint(point: NCPoint(x: 50.0, y: 50.0), locationId: 12345, sublocationId: 1),
            NCLocationPoint(point: NCPoint(x: 100.0, y: 100.0), locationId: 12345, sublocationId: 1),
            NCLocationPoint(point: NCPoint(x: 150.0, y: 150.0), locationId: 12345, sublocationId: 1)
        ]
 
        // Create different route options for each destination
        let optionsList = [
            NCRouteOptions(smoothRadius: 2.0, maxProjectionDistance: 5.0, maxAdvance: 2.0),
            NCRouteOptions(smoothRadius: 3.0, maxProjectionDistance: 7.0, maxAdvance: 1.5),
            NCRouteOptions(smoothRadius: 1.0, maxProjectionDistance: 3.0, maxAdvance: 2.5),
        ]
 
        // Create sessions for each destination
        var sessions: [NCRouteSession] = []
        for (index, destination) in destinations.enumerated() {
            let session = manager.createRouteSession(destination, routeOptions: optionsList[index])
            sessions.append(session!)
            print("Created session \‍(index + 1) for destination: \‍(destination.getPoint().getX()), \‍(destination.getPoint().getY())")
 
            session?.addRouteListener(self)
 
            Thread.sleep(forTimeInterval: 1.0)
        }
 
        // Wait for route updates
        Thread.sleep(forTimeInterval: 3.0)
 
        // Cancel all sessions
        for (index, session) in sessions.enumerated() {
            // [swift_AsyncRouteManager_cancelRouteSession]
            // Cancel route session
            manager.cancelRouteSession(session)
            print("Cancelled session \‍(index + 1)")
            // [swift_AsyncRouteManager_cancelRouteSession]
 
            Thread.sleep(forTimeInterval: 1.0)
        }
    }
 
    /**
     * Demonstrate RouteStatus enum usage
     */
    func demonstrateRouteStatusUsage() {
        print("=== RouteStatus Enum Usage ===")
 
        // [swift_RouteStatus_values]
        // Demonstrate all RouteStatus values
        print("Available RouteStatus values:")
        let allStatuses: [NCRouteStatus] = [.missingGraph, .missingPosition, .missingRoute, .missingProjection, .newRoute]
        for status in allStatuses {
            print("  - \‍(status): \‍(status.rawValue)")
        }
 
        // Demonstrate status checking
        let testStatus: NCRouteStatus = .newRoute
        switch testStatus {
        case .newRoute:
            print("Router is ready for navigation")
        case .missingGraph:
            print("Router is missing the route graph")
        case .missingPosition:
            print("Router is missing the current position")
        case .missingProjection:
            print("Current position is off the route graph")
        case .missingRoute:
            print("Router unable to find the route to the destination point")
        }
        // [swift_RouteStatus_values]
    }
 
    /**
     * Demonstrate route session management
     */
    func demonstrateRouteSessionManagement() {
        print("=== Route Session Management ===")
 
        guard let manager = asyncRouteManager else {
            return
        }
 
        // Create test destination
        let destinationPoint = NCPoint(x: 75.0, y: 75.0)
        let destinationLocationPoint = NCLocationPoint(point: destinationPoint, locationId: 12345, sublocationId: 1)
        let routeOptions = NCRouteOptions(smoothRadius: 2.0, maxProjectionDistance: 5.0, maxAdvance: 2.0)
 
        // Create session with default tag
        let defaultSession = manager.createRouteSession(destinationLocationPoint, routeOptions: routeOptions)
        print("Created session with default tag")
 
        // Create session with specific tag
        let taggedSession = manager.createRouteSession(withTag: destinationLocationPoint, routeOptions: routeOptions, tag: "elevator")
        print("Created session with 'elevator' tag")
 
        // Add listeners to both sessions
        defaultSession?.addRouteListener(self)
        taggedSession?.addRouteListener(self)
 
        // Simulate some time passing
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            // Remove listeners
            // [swift_RouteSession_removeRouteListener]
            // Remove route listener from session
            defaultSession?.removeRouteListener(self)
            taggedSession?.removeRouteListener(self)
            print("Removed listeners from sessions")
            // [swift_RouteSession_removeRouteListener]
 
            // Cancel sessions
            manager.cancelRouteSession(defaultSession)
            manager.cancelRouteSession(taggedSession)
            print("Cancelled both sessions")
        }
    }
 
    /**
     * Clean up resources
     */
    func cleanup() {
        if let session = currentSession {
            // [swift_RouteSession_removeRouteListener]
            // Remove route listener
            session.removeRouteListener(self)
            // [swift_RouteSession_removeRouteListener]
        }
 
        if let manager = asyncRouteManager, let session = currentSession {
            // [swift_AsyncRouteManager_cancelRouteSession_1]
            // Cancel route session
            manager.cancelRouteSession(session)
            // [swift_AsyncRouteManager_cancelRouteSession_1]
        }
    }
 
    /**
     * Main demonstration method
     */
    func runExample() {
        print("=== AsyncRouteManager Example ===")
 
        demonstrateAsyncRouteManagerMethods()
        demonstrateRouteEventTypes()
        demonstrateRouteOptions()
        demonstrateRouteStatusUsage()
        demonstrateRouteSessionManagement()
        demonstrateAdvancedAsyncRoutingFeatures()
 
        // Wait a bit for route updates
        Thread.sleep(forTimeInterval: 3.0)
 
        cleanup()
        print("=== Example completed ===")
    }
}
 
// MARK: - NCAsyncRouteListener
 
extension AsyncRouteManagerExample: NCAsyncRouteListener {
    // [swift_AsyncRouteListener_onRouteChanged]
    func onRouteChanged(_ status: NCRouteStatus, currentPath: NCRoutePath) {
        print("Route changed with status: \‍(status)")
        if status == .newRoute && currentPath != nil {
            demonstrateRoutePathUsage(currentPath)
        } else {
            print("Route not ready, status: \‍(status)")
        }
    }
    // [swift_AsyncRouteListener_onRouteChanged]
 
    // [swift_AsyncRouteListener_onRouteAdvanced]
    func onRouteAdvanced(_ distance: Float, point: NCLocationPoint) {
        print("Route advanced: \‍(distance) meters")
        demonstrateLocationPointUsage(point)
    }
    // [swift_AsyncRouteListener_onRouteAdvanced]
}
 
/**
 * Function to run the example
 */
func main() {
    let example = AsyncRouteManagerExample()
    example.runExample()
}
 
// Run the example
main()