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_getWeight]
        // Get total route weight
        let weight = routePath.getWeight()
        print("Route weight: \‍(weight)")
        // [swift_RoutePath_getWeight]
 
        // [swift_RoutePath_getNodes]
        // Get route nodes
        let nodes = routePath.getNodes()
        print("Number of route nodes: \‍(nodes.count)")
        for node in nodes.prefix(3) {
            demonstrateRouteNodeUsage(node)
        }
        // [swift_RoutePath_getNodes]
 
        // [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]
    }
 
    func demonstrateRouteNodeUsage(_ node: NCRouteNode) {
        // [swift_RouteNode_getPoint]
        let point = node.getPoint()
        demonstrateLocationPointUsage(point)
        // [swift_RouteNode_getPoint]
 
        // [swift_RouteNode_getWeight]
        let weight = node.getWeight()
        print("Node weight: \‍(weight)")
        // [swift_RouteNode_getWeight]
 
        // [swift_RouteNode_getDistance]
        let distance = node.getDistance()
        print("Node distance: \‍(distance) meters")
        // [swift_RouteNode_getDistance]
 
        // [swift_RouteNode_getEvents]
        let events = node.getEvents()
        for event in events {
            demonstrateRouteEventUsage(event)
        }
        // [swift_RouteNode_getEvents]
    }
 
    /**
     * 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_getTurnEvent]
        if let turnEvent = event.getTurnEvent() {
            demonstrateTurnEventUsage(turnEvent)
        }
        // [swift_RouteEvent_getTurnEvent]
 
        // [swift_RouteEvent_getTransitionEntryEvent]
        if let entryEvent = event.getTransitionEntryEvent() {
            demonstrateTransitionEntryEventUsage(entryEvent)
        }
        // [swift_RouteEvent_getTransitionEntryEvent]
 
        // [swift_RouteEvent_getTransitionExitEvent]
        if let exitEvent = event.getTransitionExitEvent() {
            demonstrateTransitionExitEventUsage(exitEvent)
        }
        // [swift_RouteEvent_getTransitionExitEvent]
 
        // [swift_RouteEvent_getTargetReachedEvent]
        if let targetEvent = event.getTargetReachedEvent() {
            demonstrateTargetReachedEventUsage(targetEvent)
        }
        // [swift_RouteEvent_getTargetReachedEvent]
    }
 
    /**
     * Demonstrate RouteEventType enum values
     */
    func demonstrateRouteEventTypes() {
        // [swift_RouteEventType_values]
        // Get all route event type values
        let types: [NCRouteEventType] = [.turnEvent, .transitionEntryEvent, .transitionExitEvent, .targetReachedEvent]
        print("Available route event types:")
        for type in types {
            print("  - \‍(type)")
        }
        // [swift_RouteEventType_values]
    }
 
    func demonstrateTurnTypes() {
        // [swift_TurnType_values]
        let types: [NCTurnType] = [.leftSlight, .leftNormal, .leftSharp, .rightSlight, .rightNormal, .rightSharp, .complete]
        for type in types {
            print("  - \‍(type)")
        }
        // [swift_TurnType_values]
    }
 
    func demonstrateTurnEventUsage(_ event: NCTurnEvent) {
        // [swift_TurnEvent_getType]
        let type = event.getType()
        print("Turn type: \‍(type)")
        // [swift_TurnEvent_getType]
 
        // [swift_TurnEvent_getAngle]
        let angle = event.getAngle()
        print("Turn angle: \‍(angle)")
        // [swift_TurnEvent_getAngle]
    }
 
    func demonstrateTransitionEntryEventUsage(_ event: NCTransitionEntryEvent) {
        // [swift_TransitionEntryEvent_getFrom]
        let from = event.getFrom()
        print("Transition entry from: \‍(from)")
        // [swift_TransitionEntryEvent_getFrom]
 
        // [swift_TransitionEntryEvent_getTo]
        let to = event.getTo()
        print("Transition entry to: \‍(to)")
        // [swift_TransitionEntryEvent_getTo]
    }
 
    func demonstrateTransitionExitEventUsage(_ event: NCTransitionExitEvent) {
        // [swift_TransitionExitEvent_getFrom]
        let from = event.getFrom()
        print("Transition exit from: \‍(from)")
        // [swift_TransitionExitEvent_getFrom]
 
        // [swift_TransitionExitEvent_getTo]
        let to = event.getTo()
        print("Transition exit to: \‍(to)")
        // [swift_TransitionExitEvent_getTo]
    }
 
    func demonstrateTargetReachedEventUsage(_ event: NCTargetReachedEvent) {
        // [swift_TargetReachedEvent_getIndex]
        let index = event.getIndex()
        print("Reached target index: \‍(index)")
        // [swift_TargetReachedEvent_getIndex]
 
        // [swift_TargetReachedEvent_getPoint]
        let point = event.getPoint()
        demonstrateLocationPointUsage(point)
        // [swift_TargetReachedEvent_getPoint]
    }
 
    /**
     * 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_removeRouteListener1]
            // Remove route listener from session
            defaultSession?.removeRouteListener(self)
            taggedSession?.removeRouteListener(self)
            print("Removed listeners from sessions")
            // [swift_RouteSession_removeRouteListener1]
 
            // 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()
        demonstrateTurnTypes()
        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()