RouteManagerExample.swift

Go to the documentation of this file.

import Foundation
 
/**
 * RouteManager usage example for Swift
 * Demonstrates working with route planning, path calculation, and navigation
 */
class RouteManagerExample: NSObject {
    private var sdk: NCNavigineSdk?
    private var locationManager: NCLocationManager?
    private var navigationManager: NCNavigationManager?
    private var routeManager: NCRouteManager?
 
    override init() {
        super.init()
        initializeSdk()
        setupRouteListener()
    }
 
    /**
     * 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_getRouteManager]
            // Get RouteManager for working with routes
            routeManager = sdk?.getRouteManager(locationManager, navigationManager: navigationManager)
            // [swift_NavigineSdk_getRouteManager]
 
            if let locationManager = locationManager,
               let navigationManager = navigationManager,
               let routeManager = routeManager {
                print("LocationManager, NavigationManager and RouteManager successfully initialized")
            }
        } catch {
            print("Error initializing SDK: \‍(error)")
        }
    }
 
    /**
     * Setup route listener
     */
    private func setupRouteListener() {
        // RouteListener is implemented via protocol extension
        // No additional setup needed for Swift
    }
 
    /**
     * Demonstrate RouteManager methods
     */
    func demonstrateRouteManagerMethods() {
        guard let manager = routeManager else {
            print("RouteManager not initialized")
            return
        }
 
        // [swift_RouteManager_addRouteListener]
        // Add route listener
        manager.addRouteListener(self)
        // [swift_RouteManager_addRouteListener]
 
        // [swift_RouteManager_setGraphTag]
        // Set graph tag
        manager.setGraphTag("main")
        // [swift_RouteManager_setGraphTag]
 
        // [swift_RouteManager_getGraphTag]
        // Get current graph tag
        let currentGraphTag = manager.getGraphTag()
        print("Current graph tag: \‍(currentGraphTag)")
        // [swift_RouteManager_getGraphTag]
 
        // [swift_RouteManager_getGraphTags]
        // Get all graph tags
        let graphTags = manager.getGraphTags()
        print("Available graph tags: \‍(graphTags)")
        // [swift_RouteManager_getGraphTags]
 
        // Create test points
        let startPoint = NCPoint(x: 10.0, y: 20.0)
        let endPoint = NCPoint(x: 50.0, y: 60.0)
        let startLocationPoint = NCLocationPoint(point: startPoint, locationId: 12345, sublocationId: 1)
        let endLocationPoint = NCLocationPoint(point: endPoint, locationId: 12345, sublocationId: 1)
 
        // [swift_RouteManager_makeRoute]
        // Make route from point to point
        let routePath = manager.makeRoute(startLocationPoint, to: endLocationPoint)
        print("Route created with length: \‍(routePath.getLength()) meters")
        // [swift_RouteManager_makeRoute]
 
        // [swift_RouteManager_makeRoutes]
        // Make routes to multiple destinations
        let destinations = [
            NCLocationPoint(point: NCPoint(x: 30.0, y: 40.0), locationId: 12345, sublocationId: 1),
            NCLocationPoint(point: NCPoint(x: 70.0, y: 80.0), locationId: 12345, sublocationId: 1)
        ]
        let routePaths = manager.makeRoutes(startLocationPoint, to: destinations)
        print("Created \‍(routePaths.count) routes")
        // [swift_RouteManager_makeRoutes]
 
        // [swift_RouteManager_setTarget]
        // Set target point
        manager.setTarget(endLocationPoint)
        // [swift_RouteManager_setTarget]
 
        // [swift_RouteManager_addTarget]
        // Add additional target point
        let additionalTarget = NCLocationPoint(point: NCPoint(x: 90.0, y: 100.0), locationId: 12345, sublocationId: 1)
        manager.addTarget(additionalTarget)
        // [swift_RouteManager_addTarget]
 
        // [swift_RouteManager_cancelTarget]
        // Cancel current target
        manager.cancelTarget()
        // [swift_RouteManager_cancelTarget]
 
        // [swift_RouteManager_clearTargets]
        // Clear all targets
        manager.clearTargets()
        // [swift_RouteManager_clearTargets]
    }
 
    /**
     * Demonstrate RoutePath class methods
     */
    func demonstrateRoutePathUsage(_ paths: [NCRoutePath]) {
        for (index, path) in paths.enumerated() {
            print("=== Route Path \‍(index + 1) ===")
 
            // [swift_RoutePath_getLength]
            // Get route length
            let length = path.getLength()
            print("Route length: \‍(length) meters")
            // [swift_RoutePath_getLength]
 
            // [swift_RoutePath_getWeight]
            // Get total route weight
            let weight = path.getWeight()
            print("Route weight: \‍(weight)")
            // [swift_RoutePath_getWeight]
 
            // [swift_RoutePath_getNodes]
            // Get route nodes
            let nodes = path.getNodes()
            print("Route has \‍(nodes.count) nodes")
            for node in nodes {
                demonstrateRouteNodeUsage(node)
            }
            // [swift_RoutePath_getNodes]
 
            // [swift_RoutePath_head]
            // Get head of route (first 10 meters)
            if let headPath = path.head(10.0) {
                print("Head path length: \‍(headPath.getLength()) meters")
            }
            // [swift_RoutePath_head]
 
            // [swift_RoutePath_tail]
            // Get tail of route (remaining after 10 meters)
            if let tailPath = path.tail(10.0) {
                print("Tail path length: \‍(tailPath.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()
        print("Node has \‍(events.count) events")
        for event in events {
            demonstrateRouteEventUsage(event)
        }
        // [swift_RouteNode_getEvents]
    }
 
    /**
     * Demonstrate RouteEvent class methods
     */
    func demonstrateRouteEventUsage(_ event: NCRouteEvent) {
        // [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] = [.turnLeft, .turnRight, .transition]
        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]
        print("Available turn types:")
        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 class methods
     */
    func demonstrateLocationPointUsage(_ locationPoint: NCLocationPoint) {
        // [swift_LocationPoint_getPoint]
        // Get point coordinates
        if let point = locationPoint.getPoint() {
            demonstratePointUsage(point)
        }
        // [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 LocationPoint
        let newPoint = NCPoint(x: 15.0, y: 25.0)
        let newLocationPoint = NCLocationPoint(point: newPoint, locationId: locationId, sublocationId: sublocationId)
        print("Created new LocationPoint: \‍(newLocationPoint)")
        // [swift_LocationPoint_constructor]
    }
 
    /**
     * Demonstrate Point class methods
     */
    func demonstratePointUsage(_ point: NCPoint) {
        // [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: x, y: y)
        print("Created new Point: \‍(newPoint)")
        // [swift_Point_constructor]
    }
 
    /**
     * Demonstrate advanced routing features
     */
    func demonstrateAdvancedRoutingFeatures() {
        print("=== Advanced Routing Features ===")
 
        guard let manager = routeManager else {
            return
        }
 
        // Create multiple routes with different graph tags
        let graphTags = ["main", "elevator", "stairs"]
 
        for tag in graphTags {
                    // [swift_RouteManager_setGraphTag_2]
        // Set different graph tag for routing
        manager.setGraphTag(tag)
        // [swift_RouteManager_setGraphTag_2]
 
            print("Routing with graph tag: \‍(tag)")
 
            // Create test route
            let startPoint = NCPoint(x: 0.0, y: 0.0)
            let endPoint = NCPoint(x: 100.0, y: 100.0)
            let startLocationPoint = NCLocationPoint(point: startPoint, locationId: 12345, sublocationId: 1)
            let endLocationPoint = NCLocationPoint(point: endPoint, locationId: 12345, sublocationId: 1)
 
                    // [swift_RouteManager_makeRoute_2]
        // Make route with specific graph tag
        let routePath = manager.makeRoute(startLocationPoint, to: endLocationPoint)
        // [swift_RouteManager_makeRoute_2]
 
            print("Route with tag '\‍(tag)' has length: \‍(routePath.getLength()) meters")
        }
    }
 
    /**
     * Demonstrate route planning simulation
     */
    func demonstrateRoutePlanningSimulation() {
        print("=== Route Planning Simulation ===")
 
        guard let manager = routeManager else {
            return
        }
 
        // Create multiple target points
        let targets = [
            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)
        ]
 
        // [swift_RouteManager_setTarget_2]
        // Set first target
        manager.setTarget(targets[0])
        // [swift_RouteManager_setTarget_2]
 
        print("Set target 1: \‍(targets[0])")
        Thread.sleep(forTimeInterval: 1.0)
 
        // [swift_RouteManager_addTarget_2]
        // Add additional targets
        for (index, target) in targets.dropFirst().enumerated() {
            manager.addTarget(target)
            print("Added target \‍(index + 2): \‍(target)")
            Thread.sleep(forTimeInterval: 1.0)
        }
        // [swift_RouteManager_addTarget_2]
 
        // [swift_RouteManager_cancelTarget_2]
        // Cancel current target
        manager.cancelTarget()
        print("Cancelled current target")
        // [swift_RouteManager_cancelTarget_2]
 
        Thread.sleep(forTimeInterval: 1.0)
 
        // [swift_RouteManager_clearTargets_2]
        // Clear all targets
        manager.clearTargets()
        print("Cleared all targets")
        // [swift_RouteManager_clearTargets_2]
    }
 
    /**
     * Clean up resources
     */
    func cleanup() {
        if let manager = routeManager {
            // [swift_RouteManager_removeRouteListener]
            // Remove route listener
            manager.removeRouteListener(self)
            // [swift_RouteManager_removeRouteListener]
        }
    }
 
    /**
     * Main demonstration method
     */
    func runExample() {
        print("=== RouteManager Example ===")
 
        demonstrateRouteManagerMethods()
        demonstrateRouteEventTypes()
        demonstrateTurnTypes()
        demonstrateAdvancedRoutingFeatures()
        demonstrateRoutePlanningSimulation()
 
        // Wait a bit for route updates
        Thread.sleep(forTimeInterval: 3.0)
 
        cleanup()
        print("=== Example completed ===")
    }
}
 
// MARK: - NCRouteListener
 
extension RouteManagerExample: NCRouteListener {
    // [swift_RouteListener_onPathsUpdated]
    func onPathsUpdated(_ paths: [NCRoutePath]) {
        print("Routes updated successfully")
        demonstrateRoutePathUsage(paths)
    }
    // [swift_RouteListener_onPathsUpdated]
}
 
/**
 * Function to run the example
 */
func main() {
    let example = RouteManagerExample()
    example.runExample()
}
 
// Run the example
main()