AsyncRouteManagerExample.kt

Go to the documentation of this file.

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
 
/**
 * AsyncRouteManager usage example for Kotlin
 * Demonstrates working with async route planning, session management, and navigation
 */
class AsyncRouteManagerExample {
    private var sdk: NavigineSdk? = null
    private var locationManager: LocationManager? = null
    private var navigationManager: NavigationManager? = null
    private var asyncRouteManager: AsyncRouteManager? = null
    private var asyncRouteListener: AsyncRouteListener? = null
    private var currentSession: RouteSession? = null
 
    init {
        initializeSdk()
        setupAsyncRouteListener()
    }
 
    /**
     * 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_getAsyncRouteManager]
            // Get AsyncRouteManager for working with async routes
            asyncRouteManager = sdk?.getAsyncRouteManager(locationManager, navigationManager)
            // [kotlin_NavigineSdk_getAsyncRouteManager]
 
            if (locationManager != null && navigationManager != null && asyncRouteManager != null) {
                println("LocationManager, NavigationManager and AsyncRouteManager successfully initialized")
            }
        } catch (e: Exception) {
            System.err.println("Error initializing SDK: ${e.message}")
        }
    }
 
    /**
     * Setup async route listener
     */
    private fun setupAsyncRouteListener() {
        asyncRouteListener = object : AsyncRouteListener() {
            // [kotlin_AsyncRouteListener_onRouteChanged]
            override fun onRouteChanged(status: RouteStatus, currentPath: RoutePath) {
                println("Route changed with status: $status")
                if (status == RouteStatus.NEW_ROUTE && currentPath != null) {
                    demonstrateRoutePathUsage(currentPath)
                } else {
                    println("Route not ready, status: $status")
                }
            }
            // [kotlin_AsyncRouteListener_onRouteChanged]
 
            // [kotlin_AsyncRouteListener_onRouteAdvanced]
            override fun onRouteAdvanced(distance: Float, point: LocationPoint) {
                println("Route advanced: $distance meters")
                demonstrateLocationPointUsage(point)
            }
            // [kotlin_AsyncRouteListener_onRouteAdvanced]
        }
    }
 
    /**
     * Demonstrate AsyncRouteManager methods
     */
    fun demonstrateAsyncRouteManagerMethods() {
        val manager = asyncRouteManager ?: run {
            System.err.println("AsyncRouteManager not initialized")
            return
        }
 
        // Create test destination point
        val destinationPoint = Point(100.0, 100.0)
        val destinationLocationPoint = LocationPoint(destinationPoint, 12345, 1)
 
        // Create route options
        val routeOptions = RouteOptions(2.0, 5.0, 2.0)
 
        // [kotlin_AsyncRouteManager_createRouteSession]
        // Create route session with default graph tag
        val session = manager.createRouteSession(destinationLocationPoint, routeOptions)
        println("Created route session with default graph tag")
        // [kotlin_AsyncRouteManager_createRouteSession]
 
        // [kotlin_AsyncRouteManager_createRouteSessionWithTag]
        // Create route session with specific graph tag
        val sessionWithTag = manager.createRouteSessionWithTag(destinationLocationPoint, routeOptions, "main")
        println("Created route session with 'main' graph tag")
        // [kotlin_AsyncRouteManager_createRouteSessionWithTag]
 
        // Store session for later use
        currentSession = session
 
        // Add listener to session
        val listener = asyncRouteListener ?: return
        // [kotlin_RouteSession_addRouteListener]
        // Add route listener to session
        session.addRouteListener(listener)
        // [kotlin_RouteSession_addRouteListener]
    }
 
    /**
     * Demonstrate RoutePath usage
     */
    fun demonstrateRoutePathUsage(routePath: RoutePath) {
        if (routePath == null) {
            System.err.println("RoutePath is null")
            return
        }
 
        // [kotlin_RoutePath_getLength]
        // Get route length
        val length = routePath.length
        println("Route length: $length meters")
        // [kotlin_RoutePath_getLength]
 
        // [kotlin_RoutePath_getPoints]
        // Get route points
        val points = routePath.points
        println("Number of route points: ${points.size}")
        points.take(3).forEachIndexed { index, point ->
            println("Point ${index + 1}: $point")
        }
        // [kotlin_RoutePath_getPoints]
 
        // [kotlin_RoutePath_getEvents]
        // Get route events
        val events = routePath.events
        println("Number of route events: ${events.size}")
        events.take(3).forEach { event ->
            demonstrateRouteEventUsage(event)
        }
        // [kotlin_RoutePath_getEvents]
 
        // [kotlin_RoutePath_head]
        // Get route head (first 10 meters)
        val head = routePath.head(10.0)
        head?.let {
            println("Route head length: ${it.length} meters")
        }
        // [kotlin_RoutePath_head]
 
        // [kotlin_RoutePath_tail]
        // Get route tail (remaining after 10 meters)
        val tail = routePath.tail(10.0)
        tail?.let {
            println("Route tail length: ${it.length} meters")
        }
        // [kotlin_RoutePath_tail]
    }
 
    /**
     * Demonstrate RouteEvent usage
     */
    fun demonstrateRouteEventUsage(event: RouteEvent) {
        if (event == null) {
            System.err.println("RouteEvent is null")
            return
        }
 
        // [kotlin_RouteEvent_getType]
        // Get event type
        val type = event.type
        println("Event type: $type")
        // [kotlin_RouteEvent_getType]
 
        // [kotlin_RouteEvent_getValue]
        // Get event value
        val value = event.value
        println("Event value: $value")
        // [kotlin_RouteEvent_getValue]
 
        // [kotlin_RouteEvent_getDistance]
        // Get event distance
        val distance = event.distance
        println("Event distance: $distance meters")
        // [kotlin_RouteEvent_getDistance]
 
        // [kotlin_RouteEvent_constructor]
        // Create new route event
        val newEvent = RouteEvent(RouteEventType.TURN_LEFT, 90, 50.0)
        println("Created new route event: ${newEvent.type} at ${newEvent.distance} meters")
        // [kotlin_RouteEvent_constructor]
    }
 
    /**
     * 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 LocationPoint usage
     */
    fun demonstrateLocationPointUsage(locationPoint: LocationPoint) {
        if (locationPoint == null) {
            System.err.println("LocationPoint is null")
            return
        }
 
        // [kotlin_LocationPoint_getPoint]
        // Get point coordinates
        val point = locationPoint.point
        println("Location point: (${point.x}, ${point.y})")
        // [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 location point
        val newPoint = Point(25.0, 35.0)
        val newLocationPoint = LocationPoint(newPoint, 12345, 2)
        println("Created new location point: ${newLocationPoint.point.x}, ${newLocationPoint.point.y}")
        // [kotlin_LocationPoint_constructor]
    }
 
    /**
     * Demonstrate Point usage
     */
    fun demonstratePointUsage(point: Point) {
        if (point == null) {
            System.err.println("Point is null")
            return
        }
 
        // [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(15.0, 25.0)
        println("Created new point: (${newPoint.x}, ${newPoint.y})")
        // [kotlin_Point_constructor]
    }
 
    /**
     * Demonstrate RouteOptions usage
     */
    fun demonstrateRouteOptions() {
        println("=== Route Options ===")
 
        // [kotlin_RouteOptions_constructor]
        // Create route options with custom parameters
        val routeOptions = RouteOptions(3.0, 7.0, 2.5)
        println("Created route options with smoothRadius: ${routeOptions.smoothRadius}, maxProjectionDistance: ${routeOptions.maxProjectionDistance}, maxAdvance: ${routeOptions.maxAdvance}")
        // [kotlin_RouteOptions_constructor]
 
        // Demonstrate different route options configurations
        val optionsList = listOf(
            RouteOptions(0.0, 5.0, 2.0),    // No smoothing
            RouteOptions(2.0, 10.0, 1.0),   // High smoothing, high projection distance
            RouteOptions(1.0, 3.0, 3.0),    // Low smoothing, low projection distance
        )
 
        optionsList.forEachIndexed { index, options ->
            println("Options ${index + 1}: smoothRadius=${options.smoothRadius}, maxProjectionDistance=${options.maxProjectionDistance}, maxAdvance=${options.maxAdvance}")
        }
    }
 
    /**
     * Demonstrate advanced async routing features
     */
    suspend fun demonstrateAdvancedAsyncRoutingFeatures() {
        println("=== Advanced Async Routing Features ===")
 
        val manager = asyncRouteManager ?: return
 
        // Create multiple destination points
        val destinations = 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)
        )
 
        // Create different route options for each destination
        val optionsList = listOf(
            RouteOptions(2.0, 5.0, 2.0),
            RouteOptions(3.0, 7.0, 1.5),
            RouteOptions(1.0, 3.0, 2.5),
        )
 
        // Create sessions for each destination
        val sessions = mutableListOf<RouteSession>()
        destinations.forEachIndexed { index, destination ->
            val session = manager.createRouteSession(destination, optionsList[index])
            sessions.add(session)
            println("Created session ${index + 1} for destination: ${destination.point.x}, ${destination.point.y}")
 
            asyncRouteListener?.let { listener ->
                session.addRouteListener(listener)
            }
 
            delay(1000)
        }
 
        // Wait for route updates
        delay(3000)
 
        // Cancel all sessions
        sessions.forEachIndexed { index, session ->
            // [kotlin_AsyncRouteManager_cancelRouteSession]
            // Cancel route session
            manager.cancelRouteSession(session)
            println("Cancelled session ${index + 1}")
            // [kotlin_AsyncRouteManager_cancelRouteSession]
 
            delay(1000)
        }
    }
 
    /**
     * Demonstrate RouteStatus enum usage
     */
    fun demonstrateRouteStatusUsage() {
        println("=== RouteStatus Enum Usage ===")
 
        // [kotlin_RouteStatus_values]
        // Demonstrate all RouteStatus values
        println("Available RouteStatus values:")
        RouteStatus.values().forEach { status ->
            println("  - ${status.name}: $status")
        }
 
        // Demonstrate status checking
        val testStatus = RouteStatus.NEW_ROUTE
        when (testStatus) {
            RouteStatus.NEW_ROUTE -> println("Router is ready for navigation")
            RouteStatus.MISSING_GRAPH -> println("Router is missing the route graph")
            RouteStatus.MISSING_POSITION -> println("Router is missing the current position")
            RouteStatus.MISSING_PROJECTION -> println("Current position is off the route graph")
            RouteStatus.MISSING_ROUTE -> println("Router unable to find the route to the destination point")
        }
        // [kotlin_RouteStatus_values]
    }
 
    /**
     * Demonstrate route session management
     */
    fun demonstrateRouteSessionManagement() {
        println("=== Route Session Management ===")
 
        val manager = asyncRouteManager
        val listener = asyncRouteListener
        if (manager == null || listener == null) {
            return
        }
 
        // Create test destination
        val destinationPoint = Point(75.0, 75.0)
        val destinationLocationPoint = LocationPoint(destinationPoint, 12345, 1)
        val routeOptions = RouteOptions(2.0, 5.0, 2.0)
 
        // Create session with default tag
        val defaultSession = manager.createRouteSession(destinationLocationPoint, routeOptions)
        println("Created session with default tag")
 
        // Create session with specific tag
        val taggedSession = manager.createRouteSessionWithTag(destinationLocationPoint, routeOptions, "elevator")
        println("Created session with 'elevator' tag")
 
        // Add listeners to both sessions
        defaultSession.addRouteListener(listener)
        taggedSession.addRouteListener(listener)
 
        // Simulate some time passing
        GlobalScope.launch {
            delay(2000)
 
            // Remove listeners
            // [kotlin_RouteSession_removeRouteListener]
            // Remove route listener from session
            defaultSession.removeRouteListener(listener)
            taggedSession.removeRouteListener(listener)
            println("Removed listeners from sessions")
            // [kotlin_RouteSession_removeRouteListener]
 
            // Cancel sessions
            manager.cancelRouteSession(defaultSession)
            manager.cancelRouteSession(taggedSession)
            println("Cancelled both sessions")
        }
    }
 
    /**
     * Clean up resources
     */
    fun cleanup() {
        val session = currentSession
        val listener = asyncRouteListener
        if (session != null && listener != null) {
            // [kotlin_RouteSession_removeRouteListener]
            // Remove route listener
            session.removeRouteListener(listener)
            // [kotlin_RouteSession_removeRouteListener]
        }
 
        val manager = asyncRouteManager
        if (manager != null && session != null) {
            // [kotlin_AsyncRouteManager_cancelRouteSession_1]
            // Cancel route session
            manager.cancelRouteSession(session)
            // [kotlin_AsyncRouteManager_cancelRouteSession_1]
        }
    }
 
    /**
     * Main demonstration method
     */
    suspend fun runExample() {
        println("=== AsyncRouteManager Example ===")
 
        demonstrateAsyncRouteManagerMethods()
        demonstrateRouteEventTypes()
        demonstrateRouteOptions()
        demonstrateRouteStatusUsage()
        demonstrateRouteSessionManagement()
        demonstrateAdvancedAsyncRoutingFeatures()
 
        // Wait a bit for route updates
        delay(3000)
 
        cleanup()
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() = runBlocking {
    val example = AsyncRouteManagerExample()
    example.runExample()
}