NavigineSdkExample.kt

Go to the documentation of this file.

package com.navigine.examples
 
import com.navigine.idl.java.*
 
/**
 * NavigineSDK usage example for Kotlin
 * Demonstrates SDK initialization and access to various managers
 */
class NavigineSdkExample {
 
    private var sdk: NavigineSdk? = null
    private var locationManager: LocationManager? = null
    private var navigationManager: NavigationManager? = null
    private var zoneManager: ZoneManager? = null
    private var routeManager: RouteManager? = null
    private var asyncRouteManager: AsyncRouteManager? = null
    private var notificationManager: NotificationManager? = null
    private var measurementManager: MeasurementManager? = null
    private var locationListManager: LocationListManager? = null
    private var storageManager: StorageManager? = null
    private var mqttSession: MqttSession? = null
    private var locationWindow: LocationWindow? = null
    private var routeLayer: RouteLayer? = null
    private var guidanceCamera: GuidanceCamera? = null
 
    init {
        initializeSdk()
    }
 
    /**
     * SDK initialization and basic parameter setup
     */
    private fun initializeSdk() {
        try {
            // [kotlin_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance()
            // [kotlin_NavigineSdk_getInstance]
 
            // [kotlin_NavigineSdk_getVersion]
            // Get SDK version
            println("Navigine SDK Version: ${NavigineSdk.getVersion()}")
            // [kotlin_NavigineSdk_getVersion]
 
            // [kotlin_NavigineSdk_getDeviceId]
            // Get device ID
            println("Device ID: ${NavigineSdk.getDeviceId()}")
            // [kotlin_NavigineSdk_getDeviceId]
 
            // [kotlin_NavigineSdk_getRelativeTime]
            // Get relative time
            println("Relative Time: ${NavigineSdk.getRelativeTime()}")
            // [kotlin_NavigineSdk_getRelativeTime]
 
            // [kotlin_NavigineSdk_setUserHash]
            // Set user hash (authorization token)
            sdk?.setUserHash("XXXX-XXXX-XXXX-XXXX")
            // [kotlin_NavigineSdk_setUserHash]
 
 
            // [kotlin_NavigineSdk_getUserAgent]
            println("User-Agent: ${NavigineSdk.getUserAgent()}")
            // [kotlin_NavigineSdk_getUserAgent]
 
            // [kotlin_NavigineSdk_reset]
            sdk!!.reset()
            println("SDK reset to initial state")
            // [kotlin_NavigineSdk_reset]
 
            // [kotlin_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk?.setServer("https://custom.navigine.com")
            // [kotlin_NavigineSdk_setServer]
 
            // Initialize managers
            initializeManagers()
 
        } catch (e: Exception) {
            System.err.println("SDK initialization error: ${e.message}")
        }
    }
 
    /**
     * Initialize all SDK managers
     */
    private fun initializeManagers() {
        sdk?.let { sdkInstance ->
            // [kotlin_NavigineSdk_getLocationManager]
            // Get LocationManager for working with locations
            locationManager = sdkInstance.locationManager
            locationManager?.let {
                println("LocationManager successfully initialized")
            }
            // [kotlin_NavigineSdk_getLocationManager]
 
            // [kotlin_NavigineSdk_getNavigationManager]
            // Get NavigationManager for navigation
            locationManager?.let { locationManager ->
                navigationManager = sdkInstance.getNavigationManager(locationManager)
                navigationManager?.let {
                    println("NavigationManager successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getNavigationManager]
 
            // [kotlin_NavigineSdk_getZoneManager]
            // Get ZoneManager for working with zones
            navigationManager?.let { navigationManager ->
                zoneManager = sdkInstance.getZoneManager(navigationManager)
                zoneManager?.let {
                    println("ZoneManager successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getZoneManager]
 
            // [kotlin_NavigineSdk_getRouteManager]
            // Get RouteManager for building routes
            locationManager?.let { locationManager ->
                navigationManager?.let { navigationManager ->
                    routeManager = sdkInstance.getRouteManager(locationManager, navigationManager)
                    routeManager?.let {
                        println("RouteManager successfully initialized")
                    }
                }
            }
            // [kotlin_NavigineSdk_getRouteManager]
 
            // [kotlin_NavigineSdk_getAsyncRouteManager]
            // Get AsyncRouteManager for async route operations
            locationManager?.let { locationManager ->
                navigationManager?.let { navigationManager ->
                    asyncRouteManager = sdkInstance.getAsyncRouteManager(locationManager, navigationManager)
                    asyncRouteManager?.let {
                        println("AsyncRouteManager successfully initialized")
                    }
                }
            }
            // [kotlin_NavigineSdk_getAsyncRouteManager]
 
            // [kotlin_NavigineSdk_getNotificationManager]
            // Get NotificationManager for notifications
            locationManager?.let { locationManager ->
                notificationManager = sdkInstance.getNotificationManager(locationManager)
                notificationManager?.let {
                    println("NotificationManager successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getNotificationManager]
 
            // [kotlin_NavigineSdk_getMeasurementManager]
            // Get MeasurementManager for measurements
            locationManager?.let { locationManager ->
                measurementManager = sdkInstance.getMeasurementManager(locationManager)
                measurementManager?.let {
                    println("MeasurementManager successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getMeasurementManager]
 
            // [kotlin_NavigineSdk_getLocationListManager]
            // Get LocationListManager for location list operations
            locationListManager = sdkInstance.locationListManager
            locationListManager?.let {
                println("LocationListManager successfully initialized")
            }
            // [kotlin_NavigineSdk_getLocationListManager]
 
            // [kotlin_NavigineSdk_getStorageManager]
            // Get StorageManager for working with storages
            storageManager = sdkInstance.storageManager
            storageManager?.let {
                println("StorageManager successfully initialized")
            }
            // [kotlin_NavigineSdk_getStorageManager]
 
            // [kotlin_NavigineSdk_getRouteLayer]
            // Create RouteLayer for building and drawing routes on the map
            if (locationWindow != null) {
                routeLayer = sdkInstance.getRouteLayer(locationWindow!!)
                routeLayer?.let {
                    println("RouteLayer successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getRouteLayer]
 
            // [kotlin_NavigineSdk_getGuidanceCamera]
            if (locationWindow != null && routeLayer != null) {
                guidanceCamera = sdkInstance.getGuidanceCamera(locationWindow!!, routeLayer!!)
                // [kotlin_GuidanceCamera_setMode]
                guidanceCamera?.setMode(GuidanceCameraMode.FOLLOWING)
                // [kotlin_GuidanceCamera_setMode]
                // [kotlin_GuidanceCamera_set2DMode]
                guidanceCamera?.set2DMode(false)
                // [kotlin_GuidanceCamera_set2DMode]
                // [kotlin_GuidanceCamera_mode]
                println("Guidance mode: ${guidanceCamera?.mode}")
                // [kotlin_GuidanceCamera_mode]
                // [kotlin_GuidanceCamera_instruction]
                val next = guidanceCamera?.instruction
                println("Next instruction: ${next?.title} ${next?.distance} m")
                // [kotlin_GuidanceCamera_instruction]
                // [kotlin_GuidanceCamera_addListener]
                guidanceCamera?.addListener(object : GuidanceListener() {
                    override fun onCameraModeChanged(mode: GuidanceCameraMode) {
                        println("Guidance camera mode: $mode")
                    }
 
                    override fun onInstructionChanged(instruction: RouteInstruction?) {
                        println("Next: ${instruction?.title} ${instruction?.distance} m")
                    }
                })
                // [kotlin_GuidanceCamera_addListener]
            }
            // [kotlin_NavigineSdk_getGuidanceCamera]
 
            // [kotlin_NavigineSdk_getRouteSimulator]
            if (locationWindow != null) {
                val routeSimulator = sdkInstance.getRouteSimulator(locationWindow!!)
                // [kotlin_RouteSimulator_setGeometry]
                val walk = LocationPolyline(
                    listOf(GlobalPoint(55.751, 37.618), GlobalPoint(55.752, 37.618)),
                    null,
                )
                routeSimulator.setGeometry(listOf(walk))
                // [kotlin_RouteSimulator_setGeometry]
                // [kotlin_RouteSimulator_setSpeed]
                routeSimulator.setSpeed(1.4f)
                // [kotlin_RouteSimulator_setSpeed]
                // [kotlin_RouteSimulator_start]
                val started = routeSimulator.start()
                println("Route walk started: $started")
                // [kotlin_RouteSimulator_start]
                // [kotlin_RouteSimulator_sample]
                val sample = routeSimulator.sample
                println("Walk advance: ${sample?.advance} m")
                // [kotlin_RouteSimulator_sample]
            }
            // [kotlin_NavigineSdk_getRouteSimulator]
 
            // [kotlin_NavigineSdk_getMqttSession]
            // Get MqttSession for publishing position data via MQTT
            navigationManager?.let { navigationManager ->
                mqttSession = sdkInstance.getMqttSession(navigationManager)
                mqttSession?.let {
                    println("MqttSession successfully initialized")
                }
            }
            // [kotlin_NavigineSdk_getMqttSession]
        }
    }
 
    /**
     * Get information about current SDK state
     */
    fun printSdkInfo() {
        println("=== Navigine SDK Information ===")
        println("SDK Version: ${NavigineSdk.getVersion()}")
        println("Device ID: ${NavigineSdk.getDeviceId()}")
        println("Relative Time: ${NavigineSdk.getRelativeTime()}")
        println("LocationManager: ${if (locationManager != null) "available" else "unavailable"}")
        println("NavigationManager: ${if (navigationManager != null) "available" else "unavailable"}")
        println("ZoneManager: ${if (zoneManager != null) "available" else "unavailable"}")
        println("RouteManager: ${if (routeManager != null) "available" else "unavailable"}")
        println("AsyncRouteManager: ${if (asyncRouteManager != null) "available" else "unavailable"}")
        println("NotificationManager: ${if (notificationManager != null) "available" else "unavailable"}")
        println("MeasurementManager: ${if (measurementManager != null) "available" else "unavailable"}")
        println("LocationListManager: ${if (locationListManager != null) "available" else "unavailable"}")
        println("StorageManager: ${if (storageManager != null) "available" else "unavailable"}")
        println("MqttSession: ${if (mqttSession != null) "available" else "unavailable"}")
    }
 
    /**
     * Demonstrate usage of all managers
     */
    fun demonstrateManagersUsage() {
        println("=== Manager Usage Demonstration ===")
 
        // LocationManager usage example
        locationManager?.let {
            println("LocationManager ready for location operations")
            // Add code here for loading locations, working with them, etc.
        }
 
        // NavigationManager usage example
        navigationManager?.let {
            println("NavigationManager ready for positioning")
            // Add code here for getting position, setting up listeners, etc.
        }
 
        // ZoneManager usage example
        zoneManager?.let {
            println("ZoneManager ready for zone operations")
            // Add code here for setting up zones, handling enter/exit events, etc.
        }
 
        // RouteManager usage example
        routeManager?.let {
            println("RouteManager ready for route building")
            // Add code here for building routes, setting destination points, etc.
        }
 
        // AsyncRouteManager usage example
        asyncRouteManager?.let {
            println("AsyncRouteManager ready for async route operations")
            // Add code here for creating routing sessions, etc.
        }
 
        // NotificationManager usage example
        notificationManager?.let {
            println("NotificationManager ready for notifications")
            // Add code here for setting up beacon notifications, etc.
        }
 
        // MeasurementManager usage example
        measurementManager?.let {
            println("MeasurementManager ready for measurements")
            // Add code here for managing measurement generators, etc.
        }
 
        // LocationListManager usage example
        locationListManager?.let {
            println("LocationListManager ready for location list operations")
            // Add code here for getting available locations list, etc.
        }
 
        // StorageManager usage example
        storageManager?.let {
            println("StorageManager ready for storage operations")
            // Add code here for creating storages, managing data, etc.
        }
 
        // MqttSession usage example
        mqttSession?.let {
            println("MqttSession ready for publishing position data via MQTT")
            // Add code here for connecting to MQTT broker, publishing positions, etc.
        }
    }
 
    /**
     * Demonstrate Kotlin features usage
     */
    fun demonstrateKotlinFeatures() {
        println("=== Kotlin Features Demonstration ===")
 
        // Using let for safe calls
        sdk?.let { sdkInstance ->
            sdkInstance.setUserHash("YYYY-YYYY-YYYY-YYYY")
            println("User hash updated")
        }
 
        // Using run for code block execution
        val sdkInfo = run {
            mapOf(
                "version" to NavigineSdk.getVersion(),
                "deviceId" to NavigineSdk.getDeviceId(),
                "relativeTime" to NavigineSdk.getRelativeTime()
            )
        }
        println("SDK Information: $sdkInfo")
 
        // Using with for object operations
        with(locationManager) {
            this?.let {
                println("LocationManager available for operations")
                // Call LocationManager methods here
            }
        }
 
        // Using apply for object configuration
        sdk?.apply {
            setUserHash("ZZZZ-ZZZZ-ZZZZ-ZZZZ")
            setServer("https://custom.navigine.com")
        }
        println("SDK settings updated")
    }
 
    /**
     * Main function for demonstration
     */
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val example = NavigineSdkExample()
            example.printSdkInfo()
            example.demonstrateManagersUsage()
            example.demonstrateKotlinFeatures()
        }
    }
}