NavigationManagerExample.kt

Go to the documentation of this file.

package com.navigine.examples
 
import com.navigine.idl.java.*
 
/**
 * NavigationManager usage example for Kotlin
 * Demonstrates working with navigation, positioning, and location tracking
 */
class NavigationManagerExample {
    private var sdk: NavigineSdk? = null
    private var locationManager: LocationManager? = null
    private var navigationManager: NavigationManager? = null
    private var positionListener: PositionListener? = null
 
    init {
        initializeSdk()
        setupPositionListener()
    }
 
    /**
     * 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]
 
            if (locationManager != null && navigationManager != null) {
                println("LocationManager and NavigationManager successfully initialized")
            }
        } catch (e: Exception) {
            System.err.println("Error initializing SDK: ${e.message}")
        }
    }
 
    /**
     * Setup position listener
     */
    private fun setupPositionListener() {
        positionListener = object : PositionListener() {
            // [kotlin_PositionListener_onPositionUpdated]
            override fun onPositionUpdated(position: Position) {
                println("Position updated successfully")
                demonstratePositionUsage(position)
            }
            // [kotlin_PositionListener_onPositionUpdated]
 
            // [kotlin_PositionListener_onPositionError]
            override fun onPositionError(error: Error) {
                System.err.println("Position error: ${error.message}")
            }
            // [kotlin_PositionListener_onPositionError]
        }
    }
 
    /**
     * Demonstrate NavigationManager methods
     */
    fun demonstrateNavigationManagerMethods() {
        val manager = navigationManager ?: run {
            System.err.println("NavigationManager not initialized")
            return
        }
 
        val listener = positionListener ?: return
 
        // [kotlin_NavigationManager_addPositionListener]
        // Add position listener
        manager.addPositionListener(listener)
        // [kotlin_NavigationManager_addPositionListener]
 
        // [kotlin_NavigationManager_startLogRecording]
        // Start log recording
        manager.startLogRecording()
        // [kotlin_NavigationManager_startLogRecording]
 
        // [kotlin_NavigationManager_addCheckPoint]
        // Add check point
        val point = Point(10.0, 20.0)
        val locationPoint = LocationPoint(point, 12345, 1)
        manager.addCheckPoint(locationPoint)
        // [kotlin_NavigationManager_addCheckPoint]
 
        // [kotlin_NavigationManager_addLocationMeasurement]
        // Add location measurement
        val globalPoint = GlobalPoint(55.7558, 37.6176) // Moscow coordinates
        manager.addLocationMeasurement(globalPoint, 5.0f, "gps")
        // [kotlin_NavigationManager_addLocationMeasurement]
 
        // [kotlin_NavigationManager_stopLogRecording]
        // Stop log recording
        manager.stopLogRecording()
        // [kotlin_NavigationManager_stopLogRecording]
    }
 
    /**
     * Demonstrate Position class methods
     */
    fun demonstratePositionUsage(position: Position) {
        // [kotlin_Position_getPoint]
        // Get global point (WGS84 coordinates)
        val globalPoint = position.point
        globalPoint?.let { demonstrateGlobalPointUsage(it) }
        // [kotlin_Position_getPoint]
 
        // [kotlin_Position_getAccuracy]
        // Get position accuracy
        val accuracy = position.accuracy
        println("Position accuracy: $accuracy meters")
        // [kotlin_Position_getAccuracy]
 
        // [kotlin_Position_getHeading]
        // Get heading (angle of rotation about the -Z axis in radians)
        val heading = position.heading
        heading?.let { println("Heading: $it radians") }
        // [kotlin_Position_getHeading]
 
        // [kotlin_Position_getHeadingAccuracy]
        // Get heading accuracy
        val headingAccuracy = position.headingAccuracy
        headingAccuracy?.let { println("Heading accuracy: $it radians") }
        // [kotlin_Position_getHeadingAccuracy]
 
        // [kotlin_Position_getLocationPoint]
        // Get location point (metrics coordinates)
        val locationPoint = position.locationPoint
        locationPoint?.let { demonstrateLocationPointUsage(it) }
        // [kotlin_Position_getLocationPoint]
 
        // [kotlin_Position_getLocationHeading]
        // Get location heading (with respect to sublocation north)
        val locationHeading = position.locationHeading
        locationHeading?.let { println("Location heading: $it radians") }
        // [kotlin_Position_getLocationHeading]
    }
 
    /**
     * Demonstrate GlobalPoint class methods
     */
    fun demonstrateGlobalPointUsage(globalPoint: GlobalPoint) {
        // [kotlin_GlobalPoint_getLatitude]
        // Get latitude
        val latitude = globalPoint.latitude
        println("Latitude: $latitude")
        // [kotlin_GlobalPoint_getLatitude]
 
        // [kotlin_GlobalPoint_getLongitude]
        // Get longitude
        val longitude = globalPoint.longitude
        println("Longitude: $longitude")
        // [kotlin_GlobalPoint_getLongitude]
 
        // [kotlin_GlobalPoint_constructor]
        // Create new GlobalPoint
        val newPoint = GlobalPoint(latitude, longitude)
        println("Created new GlobalPoint: $newPoint")
        // [kotlin_GlobalPoint_constructor]
    }
 
    /**
     * 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 LocationManager integration
     */
    fun demonstrateLocationManagerIntegration() {
        val manager = locationManager ?: run {
            System.err.println("LocationManager not initialized")
            return
        }
 
        // [kotlin_LocationManager_addLocationListener]
        // Add location listener for navigation integration
        val locationListener = object : LocationListener() {
            // [kotlin_LocationListener_onLocationLoaded]
            override fun onLocationLoaded(location: Location?) {
                println("Location loaded for navigation")
                location?.let {
                    // [kotlin_LocationManager_setLocationId]
                    // Set location ID for navigation
                    manager.setLocationId(it.id)
                    // [kotlin_LocationManager_setLocationId]
                }
            }
            // [kotlin_LocationListener_onLocationLoaded]
 
            // [kotlin_LocationListener_onLocationUploaded]
            override fun onLocationUploaded(locationId: Int) {
                println("Location uploaded: $locationId")
            }
            // [kotlin_LocationListener_onLocationUploaded]
 
            // [kotlin_LocationListener_onLocationFailed]
            override fun onLocationFailed(locationId: Int, error: Error) {
                System.err.println("Failed to load location $locationId: ${error.message}")
            }
            // [kotlin_LocationListener_onLocationFailed]
        }
        manager.addLocationListener(locationListener)
        // [kotlin_LocationManager_addLocationListener]
 
        // [kotlin_LocationManager_setLocationId]
        // Set location ID to load
        manager.setLocationId(12345)
        // [kotlin_LocationManager_setLocationId]
 
        // [kotlin_LocationManager_getLocationId]
        // Get current location ID
        val currentLocationId = manager.getLocationId()
        println("Current location ID: $currentLocationId")
        // [kotlin_LocationManager_getLocationId]
 
        // [kotlin_LocationManager_setLocationUpdateInterval]
        // Set location update interval
        manager.setLocationUpdateInterval(300) // 5 minutes
        // [kotlin_LocationManager_setLocationUpdateInterval]
 
        // [kotlin_LocationManager_commitChanges]
        // Commit changes
        manager.commitChanges()
        // [kotlin_LocationManager_commitChanges]
    }
 
    /**
     * Demonstrate advanced navigation features
     */
    fun demonstrateAdvancedNavigationFeatures() {
        println("=== Advanced Navigation Features ===")
 
        val manager = navigationManager ?: return
 
        // Create multiple check points for path tracking
        val checkPoints = arrayOf(
            Point(0.0, 0.0),
            Point(10.0, 10.0),
            Point(20.0, 20.0),
            Point(30.0, 30.0)
        )
 
        checkPoints.forEachIndexed { index, point ->
            val locationPoint = LocationPoint(point, 12345, 1)
            // [kotlin_NavigationManager_addCheckPoint]
            // Add check point for path tracking
            manager.addCheckPoint(locationPoint)
            // [kotlin_NavigationManager_addCheckPoint]
            println("Added check point ${index + 1}: $locationPoint")
        }
 
        // Add location measurements with different providers
        val measurements = arrayOf(
            GlobalPoint(55.7558, 37.6176), // Moscow
            GlobalPoint(40.7128, -74.0060), // New York
            GlobalPoint(51.5074, -0.1278)  // London
        )
 
        val providers = arrayOf("gps", "network", "fused")
 
        measurements.forEachIndexed { index, globalPoint ->
            // [kotlin_NavigationManager_addLocationMeasurement]
            // Add location measurement with different providers
            manager.addLocationMeasurement(globalPoint, 3.0f + index, providers[index % providers.size])
            // [kotlin_NavigationManager_addLocationMeasurement]
            println("Added measurement ${index + 1} with provider: ${providers[index % providers.size]}")
        }
    }
 
    /**
     * Demonstrate position tracking simulation
     */
    fun demonstratePositionTrackingSimulation() {
        println("=== Position Tracking Simulation ===")
 
        val manager = navigationManager ?: return
 
        // [kotlin_NavigationManager_startLogRecording]
        // Start log recording for position tracking
        manager.startLogRecording()
        // [kotlin_NavigationManager_startLogRecording]
 
        // Simulate position updates
        repeat(5) { i ->
            val lat = 55.7558 + (i * 0.001) // Move north
            val lon = 37.6176 + (i * 0.001) // Move east
            
            val globalPoint = GlobalPoint(lat, lon)
            // [kotlin_NavigationManager_addLocationMeasurement]
            // Add simulated location measurement
            manager.addLocationMeasurement(globalPoint, 2.0f, "simulated")
            // [kotlin_NavigationManager_addLocationMeasurement]
            
            println("Simulated position ${i + 1}: $globalPoint")
            
            Thread.sleep(1000) // Wait 1 second between updates
        }
 
        // [kotlin_NavigationManager_stopLogRecording]
        // Stop log recording
        manager.stopLogRecording()
        // [kotlin_NavigationManager_stopLogRecording]
    }
 
    /**
     * Clean up resources
     */
    fun cleanup() {
        navigationManager?.let { manager ->
            positionListener?.let { listener ->
                // [kotlin_NavigationManager_removePositionListener]
                // Remove position listener
                manager.removePositionListener(listener)
                // [kotlin_NavigationManager_removePositionListener]
            }
        }
    }
 
    /**
     * Main demonstration method
     */
    fun runExample() {
        println("=== NavigationManager Example ===")
        
        demonstrateNavigationManagerMethods()
        demonstrateLocationManagerIntegration()
        demonstrateAdvancedNavigationFeatures()
        demonstratePositionTrackingSimulation()
        
        // Wait a bit for position updates
        Thread.sleep(3000)
        
        cleanup()
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() {
    val example = NavigationManagerExample()
    example.runExample()
}