RouteManagerExample.kt

Go to the documentation of this file.

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
 
/**
 * RouteManager usage example for Kotlin
 * Demonstrates working with route planning, path calculation, and navigation
 */
class RouteManagerExample {
    private var sdk: NavigineSdk? = null
    private var locationManager: LocationManager? = null
    private var navigationManager: NavigationManager? = null
    private var routeManager: RouteManager? = null
    private var routeListener: RouteListener? = null
 
    init {
        initializeSdk()
        setupRouteListener()
    }
 
    /**
     * Initialize SDK and get managers
     */
    private fun initializeSdk() {
        try {
            // [kotlin_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance()
            // [kotlin_NavigineSdk_getInstance]
 
            // [kotlin_NavigineSdk_setUserHash]
            // Set user hash
            sdk?.setUserHash("USER-HASH-HERE")
            // [kotlin_NavigineSdk_setUserHash]
 
            // [kotlin_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk?.setServer("https://custom.navigine.com")
            // [kotlin_NavigineSdk_setServer]
 
            // [kotlin_NavigineSdk_getLocationManager]
            // Get LocationManager for working with locations
            locationManager = sdk?.getLocationManager()
            // [kotlin_NavigineSdk_getLocationManager]
 
            // [kotlin_NavigineSdk_getNavigationManager]
            // Get NavigationManager for working with navigation
            navigationManager = sdk?.getNavigationManager(locationManager)
            // [kotlin_NavigineSdk_getNavigationManager]
 
            // [kotlin_NavigineSdk_getRouteManager]
            // Get RouteManager for working with routes
            routeManager = sdk?.getRouteManager(locationManager, navigationManager)
            // [kotlin_NavigineSdk_getRouteManager]
 
            if (locationManager != null && navigationManager != null && routeManager != null) {
                println("LocationManager, NavigationManager and RouteManager successfully initialized")
            }
        } catch (e: Exception) {
            System.err.println("Error initializing SDK: ${e.message}")
        }
    }
 
    /**
     * Setup route listener
     */
    private fun setupRouteListener() {
        routeListener = object : RouteListener() {
            // [kotlin_RouteListener_onPathsUpdated]
            override fun onPathsUpdated(paths: List<RoutePath>) {
                println("Routes updated successfully")
                demonstrateRoutePathUsage(paths)
            }
            // [kotlin_RouteListener_onPathsUpdated]
        }
    }
 
    /**
     * Demonstrate RouteManager methods
     */
    fun demonstrateRouteManagerMethods() {
        val manager = routeManager ?: run {
            System.err.println("RouteManager not initialized")
            return
        }
 
        val listener = routeListener ?: return
 
        // [kotlin_RouteManager_addRouteListener]
        // Add route listener
        manager.addRouteListener(listener)
        // [kotlin_RouteManager_addRouteListener]
 
        // [kotlin_RouteManager_setGraphTag]
        // Set graph tag
        manager.setGraphTag("main")
        // [kotlin_RouteManager_setGraphTag]
 
        // [kotlin_RouteManager_getGraphTag]
        // Get current graph tag
        val currentGraphTag = manager.getGraphTag()
        println("Current graph tag: $currentGraphTag")
        // [kotlin_RouteManager_getGraphTag]
 
        // [kotlin_RouteManager_getGraphTags]
        // Get all graph tags
        val graphTags = manager.getGraphTags()
        println("Available graph tags: $graphTags")
        // [kotlin_RouteManager_getGraphTags]
 
        // Create test points
        val startPoint = Point(10.0, 20.0)
        val endPoint = Point(50.0, 60.0)
        val startLocationPoint = LocationPoint(startPoint, 12345, 1)
        val endLocationPoint = LocationPoint(endPoint, 12345, 1)
 
        // [kotlin_RouteManager_makeRoute]
        // Make route from point to point
        val routePath = manager.makeRoute(startLocationPoint, endLocationPoint)
        println("Route created with length: ${routePath.length} meters")
        // [kotlin_RouteManager_makeRoute]
 
        // [kotlin_RouteManager_makeRoutes]
        // Make routes to multiple destinations
        val destinations = listOf(
            LocationPoint(Point(30.0, 40.0), 12345, 1),
            LocationPoint(Point(70.0, 80.0), 12345, 1)
        )
        val routePaths = manager.makeRoutes(startLocationPoint, destinations)
        println("Created ${routePaths.size} routes")
        // [kotlin_RouteManager_makeRoutes]
 
        // [kotlin_RouteManager_setTarget]
        // Set target point
        manager.setTarget(endLocationPoint)
        // [kotlin_RouteManager_setTarget]
 
        // [kotlin_RouteManager_addTarget]
        // Add additional target point
        val additionalTarget = LocationPoint(Point(90.0, 100.0), 12345, 1)
        manager.addTarget(additionalTarget)
        // [kotlin_RouteManager_addTarget]
 
        // [kotlin_RouteManager_cancelTarget]
        // Cancel current target
        manager.cancelTarget()
        // [kotlin_RouteManager_cancelTarget]
 
        // [kotlin_RouteManager_clearTargets]
        // Clear all targets
        manager.clearTargets()
        // [kotlin_RouteManager_clearTargets]
    }
 
    /**
     * Demonstrate RoutePath class methods
     */
    fun demonstrateRoutePathUsage(paths: List<RoutePath>) {
        paths.forEachIndexed { index, path ->
            println("=== Route Path ${index + 1} ===")
 
            // [kotlin_RoutePath_getLength]
            // Get route length
            val length = path.length
            println("Route length: $length meters")
            // [kotlin_RoutePath_getLength]
 
            // [kotlin_RoutePath_getWeight]
            // Get total route weight
            val weight = path.weight
            println("Route weight: $weight")
            // [kotlin_RoutePath_getWeight]
 
            // [kotlin_RoutePath_getNodes]
            // Get route nodes
            val nodes = path.nodes
            println("Route has ${nodes.size} nodes")
            nodes.forEach { node ->
                demonstrateRouteNodeUsage(node)
            }
            // [kotlin_RoutePath_getNodes]
 
            // [kotlin_RoutePath_head]
            // Get head of route (first 10 meters)
            val headPath = path.head(10.0)
            headPath?.let {
                println("Head path length: ${it.length} meters")
            }
            // [kotlin_RoutePath_head]
 
            // [kotlin_RoutePath_tail]
            // Get tail of route (remaining after 10 meters)
            val tailPath = path.tail(10.0)
            tailPath?.let {
                println("Tail path length: ${it.length} meters")
            }
            // [kotlin_RoutePath_tail]
        }
    }
 
    /**
     * Demonstrate RouteNode class methods
     */
    fun demonstrateRouteNodeUsage(node: RouteNode) {
        // [kotlin_RouteNode_getPoint]
        val point = node.point
        demonstrateLocationPointUsage(point)
        // [kotlin_RouteNode_getPoint]
 
        // [kotlin_RouteNode_getWeight]
        val weight = node.weight
        println("Node weight: $weight")
        // [kotlin_RouteNode_getWeight]
 
        // [kotlin_RouteNode_getDistance]
        val distance = node.distance
        println("Node distance: $distance meters")
        // [kotlin_RouteNode_getDistance]
 
        // [kotlin_RouteNode_getEvents]
        val events = node.events
        println("Node has ${events.size} events")
        events.forEach { event ->
            demonstrateRouteEventUsage(event)
        }
        // [kotlin_RouteNode_getEvents]
    }
 
    /**
     * Demonstrate RouteEvent class methods
     */
    fun demonstrateRouteEventUsage(event: RouteEvent) {
        // [kotlin_RouteEvent_getType]
        // Get event type
        val type = event.type
        println("Event type: $type")
        // [kotlin_RouteEvent_getType]
 
        // [kotlin_RouteEvent_getTurnEvent]
        val turnEvent = event.turnEvent
        turnEvent?.let { demonstrateTurnEventUsage(it) }
        // [kotlin_RouteEvent_getTurnEvent]
 
        // [kotlin_RouteEvent_getTransitionEntryEvent]
        val entryEvent = event.transitionEntryEvent
        entryEvent?.let { demonstrateTransitionEntryEventUsage(it) }
        // [kotlin_RouteEvent_getTransitionEntryEvent]
 
        // [kotlin_RouteEvent_getTransitionExitEvent]
        val exitEvent = event.transitionExitEvent
        exitEvent?.let { demonstrateTransitionExitEventUsage(it) }
        // [kotlin_RouteEvent_getTransitionExitEvent]
 
        // [kotlin_RouteEvent_getTargetReachedEvent]
        val reachedEvent = event.targetReachedEvent
        reachedEvent?.let { demonstrateTargetReachedEventUsage(it) }
        // [kotlin_RouteEvent_getTargetReachedEvent]
    }
 
    /**
     * Demonstrate RouteEventType enum values
     */
    fun demonstrateRouteEventTypes() {
        // [kotlin_RouteEventType_values]
        // Get all route event type values
        val types = RouteEventType.values()
        println("Available route event types:")
        types.forEach { type ->
            println("  - $type")
        }
        // [kotlin_RouteEventType_values]
    }
 
    /**
     * Demonstrate TurnType enum values
     */
    fun demonstrateTurnTypes() {
        // [kotlin_TurnType_values]
        val types = TurnType.values()
        println("Available turn types:")
        types.forEach { type ->
            println("  - $type")
        }
        // [kotlin_TurnType_values]
    }
 
    fun demonstrateTurnEventUsage(turnEvent: TurnEvent) {
        // [kotlin_TurnEvent_getType]
        val type = turnEvent.type
        println("Turn type: $type")
        // [kotlin_TurnEvent_getType]
 
        // [kotlin_TurnEvent_getAngle]
        val angle = turnEvent.angle
        println("Turn angle: $angle")
        // [kotlin_TurnEvent_getAngle]
    }
 
    fun demonstrateTransitionEntryEventUsage(event: TransitionEntryEvent) {
        // [kotlin_TransitionEntryEvent_getFrom]
        val from = event.from
        println("Transition entry from: $from")
        // [kotlin_TransitionEntryEvent_getFrom]
 
        // [kotlin_TransitionEntryEvent_getTo]
        val to = event.to
        println("Transition entry to: $to")
        // [kotlin_TransitionEntryEvent_getTo]
    }
 
    fun demonstrateTransitionExitEventUsage(event: TransitionExitEvent) {
        // [kotlin_TransitionExitEvent_getFrom]
        val from = event.from
        println("Transition exit from: $from")
        // [kotlin_TransitionExitEvent_getFrom]
 
        // [kotlin_TransitionExitEvent_getTo]
        val to = event.to
        println("Transition exit to: $to")
        // [kotlin_TransitionExitEvent_getTo]
    }
 
    fun demonstrateTargetReachedEventUsage(event: TargetReachedEvent) {
        // [kotlin_TargetReachedEvent_getIndex]
        val index = event.index
        println("Reached target index: $index")
        // [kotlin_TargetReachedEvent_getIndex]
 
        // [kotlin_TargetReachedEvent_getPoint]
        val point = event.point
        demonstrateLocationPointUsage(point)
        // [kotlin_TargetReachedEvent_getPoint]
    }
 
    /**
     * Demonstrate LocationPoint class methods
     */
    fun demonstrateLocationPointUsage(locationPoint: LocationPoint) {
        // [kotlin_LocationPoint_getPoint]
        // Get point coordinates
        val point = locationPoint.point
        point?.let { demonstratePointUsage(it) }
        // [kotlin_LocationPoint_getPoint]
 
        // [kotlin_LocationPoint_getLocationId]
        // Get location ID
        val locationId = locationPoint.locationId
        println("Location ID: $locationId")
        // [kotlin_LocationPoint_getLocationId]
 
        // [kotlin_LocationPoint_getSublocationId]
        // Get sublocation ID
        val sublocationId = locationPoint.sublocationId
        println("Sublocation ID: $sublocationId")
        // [kotlin_LocationPoint_getSublocationId]
 
        // [kotlin_LocationPoint_constructor]
        // Create new LocationPoint
        val newPoint = Point(15.0, 25.0)
        val newLocationPoint = LocationPoint(newPoint, locationId, sublocationId)
        println("Created new LocationPoint: $newLocationPoint")
        // [kotlin_LocationPoint_constructor]
    }
 
    /**
     * Demonstrate Point class methods
     */
    fun demonstratePointUsage(point: Point) {
        // [kotlin_Point_getX]
        // Get X coordinate
        val x = point.x
        println("Point X: $x")
        // [kotlin_Point_getX]
 
        // [kotlin_Point_getY]
        // Get Y coordinate
        val y = point.y
        println("Point Y: $y")
        // [kotlin_Point_getY]
 
        // [kotlin_Point_constructor]
        // Create new Point
        val newPoint = Point(x, y)
        println("Created new Point: $newPoint")
        // [kotlin_Point_constructor]
    }
 
    /**
     * Demonstrate advanced routing features
     */
    fun demonstrateAdvancedRoutingFeatures() {
        println("=== Advanced Routing Features ===")
 
        val manager = routeManager ?: return
 
        // Create multiple routes with different graph tags
        val graphTags = listOf("main", "elevator", "stairs")
 
        graphTags.forEach { tag ->
            // [kotlin_RouteManager_setGraphTag_2]
            // Set different graph tag for routing
            manager.setGraphTag(tag)
            // [kotlin_RouteManager_setGraphTag_2]
 
            println("Routing with graph tag: $tag")
 
            // Create test route
            val startPoint = Point(0.0, 0.0)
            val endPoint = Point(100.0, 100.0)
            val startLocationPoint = LocationPoint(startPoint, 12345, 1)
            val endLocationPoint = LocationPoint(endPoint, 12345, 1)
 
            // [kotlin_RouteManager_makeRoute_2]
            // Make route with specific graph tag
            val routePath = manager.makeRoute(startLocationPoint, endLocationPoint)
            // [kotlin_RouteManager_makeRoute_2]
 
            println("Route with tag '$tag' has length: ${routePath.length} meters")
        }
    }
 
    /**
     * Demonstrate route planning simulation
     */
    suspend fun demonstrateRoutePlanningSimulation() {
        println("=== Route Planning Simulation ===")
 
        val manager = routeManager ?: return
 
        // Create multiple target points
        val targets = listOf(
            LocationPoint(Point(50.0, 50.0), 12345, 1),
            LocationPoint(Point(100.0, 100.0), 12345, 1),
            LocationPoint(Point(150.0, 150.0), 12345, 1)
        )
 
        // [kotlin_RouteManager_setTarget_2]
        // Set first target
        manager.setTarget(targets[0])
        // [kotlin_RouteManager_setTarget_2]
 
        println("Set target 1: ${targets[0]}")
        delay(1000)
 
        // [kotlin_RouteManager_addTarget_2]
        // Add additional targets
        targets.drop(1).forEachIndexed { index, target ->
            manager.addTarget(target)
            println("Added target ${index + 2}: $target")
            delay(1000)
        }
        // [kotlin_RouteManager_addTarget_2]
 
        // [kotlin_RouteManager_cancelTarget_2]
        // Cancel current target
        manager.cancelTarget()
        println("Cancelled current target")
        // [kotlin_RouteManager_cancelTarget_2]
 
        delay(1000)
 
        // [kotlin_RouteManager_clearTargets_2]
        // Clear all targets
        manager.clearTargets()
        println("Cleared all targets")
        // [kotlin_RouteManager_clearTargets_2]
    }
 
    /**
     * Clean up resources
     */
    fun cleanup() {
        val manager = routeManager
        val listener = routeListener
        if (manager != null && listener != null) {
            // [kotlin_RouteManager_removeRouteListener]
            // Remove route listener
            manager.removeRouteListener(listener)
            // [kotlin_RouteManager_removeRouteListener]
        }
    }
 
    /**
     * Main demonstration method
     */
    suspend fun runExample() {
        println("=== RouteManager Example ===")
 
        demonstrateRouteManagerMethods()
        demonstrateRouteEventTypes()
        demonstrateTurnTypes()
        demonstrateAdvancedRoutingFeatures()
        demonstrateRoutePlanningSimulation()
 
        // Wait a bit for route updates
        delay(3000)
 
        cleanup()
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() = runBlocking {
    val example = RouteManagerExample()
    example.runExample()
}