MeasurementManagerExample.kt

Go to the documentation of this file.

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
 
/**
 * MeasurementManager usage example for Kotlin
 * Demonstrates working with sensor and signal measurements, generators, and measurement management
 */
class MeasurementManagerExample {
    private var sdk: NavigineSdk? = null
    private var locationManager: LocationManager? = null
    private var measurementManager: MeasurementManager? = null
    private var measurementListener: MeasurementListener? = null
 
    init {
        initializeSdk()
        setupMeasurementListener()
    }
 
    /**
     * 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_getMeasurementManager]
            // Get MeasurementManager for working with measurements
            measurementManager = sdk?.getMeasurementManager(locationManager)
            // [kotlin_NavigineSdk_getMeasurementManager]
 
            // [kotlin_MeasurementManager_setPublishIntervalMs]
            // Optional: interval between measurement batches sent to listeners (ms)
            measurementManager?.setPublishIntervalMs(1000)
            // [kotlin_MeasurementManager_setPublishIntervalMs]
 
            if (locationManager != null && measurementManager != null) {
                println("LocationManager and MeasurementManager successfully initialized")
            }
        } catch (e: Exception) {
            System.err.println("Error initializing SDK: ${e.message}")
        }
    }
 
    /**
     * Setup measurement listener
     */
    private fun setupMeasurementListener() {
        measurementListener = object : MeasurementListener() {
            // [kotlin_MeasurementListener_onSensorMeasurementDetected]
            override fun onSensorMeasurementDetected(sensors: Map<SensorType, SensorMeasurement>) {
                println("Sensor measurements detected")
                demonstrateSensorMeasurements(sensors)
            }
            // [kotlin_MeasurementListener_onSensorMeasurementDetected]
 
            // [kotlin_MeasurementListener_onSignalMeasurementDetected]
            override fun onSignalMeasurementDetected(signals: Map<String, SignalMeasurement>) {
                println("Signal measurements detected")
                demonstrateSignalMeasurements(signals)
            }
            // [kotlin_MeasurementListener_onSignalMeasurementDetected]
        }
    }
 
    /**
     * Demonstrate MeasurementManager methods
     */
    fun demonstrateMeasurementManagerMethods() {
        val manager = measurementManager ?: run {
            System.err.println("MeasurementManager not initialized")
            return
        }
 
        val listener = measurementListener ?: return
 
        // [kotlin_MeasurementManager_addMeasurementListener]
        // Add measurement listener
        manager.addMeasurementListener(listener)
        println("Added measurement listener")
        // [kotlin_MeasurementManager_addMeasurementListener]
 
        // Demonstrate beacon generators
        demonstrateBeaconGenerators()
 
        // Demonstrate Eddystone generators
        demonstrateEddystoneGenerators()
 
        // Demonstrate Wi-Fi generators
        demonstrateWifiGenerators()
 
        // Demonstrate Wi-Fi RTT generators
        demonstrateWifiRttGenerators()
 
        // Demonstrate location generators
        demonstrateLocationGenerators()
 
        // Simulate some time passing for measurements
        GlobalScope.launch {
            delay(2000)
 
            // [kotlin_MeasurementManager_removeMeasurementListener]
            // Remove measurement listener
            manager.removeMeasurementListener(listener)
            println("Removed measurement listener")
            // [kotlin_MeasurementManager_removeMeasurementListener]
        }
    }
 
    /**
     * Demonstrate beacon generators
     */
    private fun demonstrateBeaconGenerators() {
        val manager = measurementManager ?: return
 
        // [kotlin_MeasurementManager_addBeaconGenerator]
        // Add beacon generator
        val beaconId = manager.addBeaconGenerator(
            "12345678-1234-1234-1234-123456789012", // UUID
            100, // major
            200, // minor
            -60, // power (dBm)
            5000, // timeout (ms)
            -80, // rssiMin
            -40  // rssiMax
        )
        println("Added beacon generator with ID: $beaconId")
        // [kotlin_MeasurementManager_addBeaconGenerator]
 
        // [kotlin_MeasurementManager_removeBleGenerator]
        // Remove specific BLE generator
        manager.removeBleGenerator(beaconId)
        println("Removed BLE generator: $beaconId")
        // [kotlin_MeasurementManager_removeBleGenerator]
 
        // [kotlin_MeasurementManager_removeBleGenerators]
        // Remove all BLE generators
        manager.removeBleGenerators()
        println("Removed all BLE generators")
        // [kotlin_MeasurementManager_removeBleGenerators]
    }
 
    /**
     * Demonstrate Eddystone generators
     */
    private fun demonstrateEddystoneGenerators() {
        val manager = measurementManager ?: return
 
        // [kotlin_MeasurementManager_addEddystoneGenerator]
        // Add Eddystone generator
        val eddystoneId = manager.addEddystoneGenerator(
            "12345678901234567890", // namespaceId
            "1234567890123456", // instanceId
            -65, // power (dBm)
            3000, // timeout (ms)
            -85, // rssiMin
            -45  // rssiMax
        )
        println("Added Eddystone generator with ID: $eddystoneId")
        // [kotlin_MeasurementManager_addEddystoneGenerator]
 
        // Remove Eddystone generator (uses same method as BLE)
        manager.removeBleGenerator(eddystoneId)
        println("Removed Eddystone generator: $eddystoneId")
    }
 
    /**
     * Demonstrate Wi-Fi generators
     */
    private fun demonstrateWifiGenerators() {
        val manager = measurementManager ?: return
 
        // [kotlin_MeasurementManager_addWifiGenerator]
        // Add Wi-Fi generator
        val wifiId = manager.addWifiGenerator(
            "AA:BB:CC:DD:EE:FF", // MAC address
            4000, // timeout (ms)
            -90, // rssiMin
            -50  // rssiMax
        )
        println("Added Wi-Fi generator with ID: $wifiId")
        // [kotlin_MeasurementManager_addWifiGenerator]
 
        // [kotlin_MeasurementManager_removeWifiGenerator]
        // Remove specific Wi-Fi generator
        manager.removeWifiGenerator(wifiId)
        println("Removed Wi-Fi generator: $wifiId")
        // [kotlin_MeasurementManager_removeWifiGenerator]
 
        // [kotlin_MeasurementManager_removeWifiGenerators]
        // Remove all Wi-Fi generators
        manager.removeWifiGenerators()
        println("Removed all Wi-Fi generators")
        // [kotlin_MeasurementManager_removeWifiGenerators]
    }
 
    /**
     * Demonstrate Wi-Fi RTT generators
     */
    private fun demonstrateWifiRttGenerators() {
        val manager = measurementManager ?: return
 
        // [kotlin_MeasurementManager_addWifiRttGenerator]
        // Add Wi-Fi RTT generator
        val wifiRttId = manager.addWifiRttGenerator(
            "11:22:33:44:55:66", // MAC address
            6000, // timeout (ms)
            1, // distMin (meters)
            10, // distMax (meters)
            0, // stdDevMin
            2, // stdDevMax
            -70, // rssiMin
            -30  // rssiMax
        )
        println("Added Wi-Fi RTT generator with ID: $wifiRttId")
        // [kotlin_MeasurementManager_addWifiRttGenerator]
 
        // [kotlin_MeasurementManager_removeWifiRttGenerator]
        // Remove specific Wi-Fi RTT generator
        manager.removeWifiRttGenerator(wifiRttId)
        println("Removed Wi-Fi RTT generator: $wifiRttId")
        // [kotlin_MeasurementManager_removeWifiRttGenerator]
 
        // [kotlin_MeasurementManager_removeWifiRttGenerators]
        // Remove all Wi-Fi RTT generators
        manager.removeWifiRttGenerators()
        println("Removed all Wi-Fi RTT generators")
        // [kotlin_MeasurementManager_removeWifiRttGenerators]
    }
 
    /**
     * Demonstrate location generators
     */
    private fun demonstrateLocationGenerators() {
        val manager = measurementManager ?: return
 
        // [kotlin_MeasurementManager_addLocationGenerator]
        // Add location generator
        val locationId = manager.addLocationGenerator(
            55.7558, // latMin
            55.7559, // latMax
            37.6176, // lonMin
            37.6177, // lonMax
            1.0, // accMin (meters)
            5.0, // accMax (meters)
            7000  // timeout (ms)
        )
        println("Added location generator with ID: $locationId")
        // [kotlin_MeasurementManager_addLocationGenerator]
 
        // [kotlin_MeasurementManager_removeLocationGenerator]
        // Remove specific location generator
        manager.removeLocationGenerator(locationId)
        println("Removed location generator: $locationId")
        // [kotlin_MeasurementManager_removeLocationGenerator]
 
        // [kotlin_MeasurementManager_removeLocationGenerators]
        // Remove all location generators
        manager.removeLocationGenerators()
        println("Removed all location generators")
        // [kotlin_MeasurementManager_removeLocationGenerators]
    }
 
    /**
     * Demonstrate sensor measurements
     */
    fun demonstrateSensorMeasurements(sensors: Map<SensorType, SensorMeasurement>) {
        sensors.forEach { (sensorType, measurement) ->
            // [kotlin_SensorMeasurement_getType]
            // Get sensor type
            val type = measurement.type
            println("Sensor type: $type")
            // [kotlin_SensorMeasurement_getType]
 
            // [kotlin_SensorMeasurement_getValues]
            // Get sensor values
            val values = measurement.values
            println("Sensor values - X: ${values.x}, Y: ${values.y}, Z: ${values.z}")
            // [kotlin_SensorMeasurement_getValues]
 
            // [kotlin_SensorMeasurement_getTime]
            // Get measurement timestamp
            val time = measurement.time
            println("Measurement time: $time ms")
            // [kotlin_SensorMeasurement_getTime]
 
            // Demonstrate Vector3d properties
            demonstrateVector3d(values)
        }
    }
 
    /**
     * Demonstrate signal measurements
     */
    fun demonstrateSignalMeasurements(signals: Map<String, SignalMeasurement>) {
        signals.forEach { (signalId, measurement) ->
            // [kotlin_SignalMeasurement_getType]
            // Get signal type
            val type = measurement.type
            println("Signal type: $type")
            // [kotlin_SignalMeasurement_getType]
 
            // [kotlin_SignalMeasurement_getId]
            // Get signal identifier
            val id = measurement.id
            println("Signal ID: $id")
            // [kotlin_SignalMeasurement_getId]
 
            // [kotlin_SignalMeasurement_getRssi]
            // Get RSSI value
            val rssi = measurement.rssi
            println("Signal RSSI: $rssi dBm")
            // [kotlin_SignalMeasurement_getRssi]
 
            // [kotlin_SignalMeasurement_getDistance]
            // Get estimated distance
            val distance = measurement.distance
            println("Signal distance: $distance meters")
            // [kotlin_SignalMeasurement_getDistance]
 
            // [kotlin_SignalMeasurement_getTime]
            // Get measurement timestamp
            val time = measurement.time
            println("Signal measurement time: $time ms")
            // [kotlin_SignalMeasurement_getTime]
        }
    }
 
    /**
     * Demonstrate Vector3d properties
     */
    private fun demonstrateVector3d(vector: Vector3d) {
        // [kotlin_Vector3d_getX]
        // Get X coordinate
        val x = vector.x
        println("Vector X: $x")
        // [kotlin_Vector3d_getX]
 
        // [kotlin_Vector3d_getY]
        // Get Y coordinate
        val y = vector.y
        println("Vector Y: $y")
        // [kotlin_Vector3d_getY]
 
        // [kotlin_Vector3d_getZ]
        // Get Z coordinate
        val z = vector.z
        println("Vector Z: $z")
        // [kotlin_Vector3d_getZ]
    }
 
    /**
     * Main demonstration method
     */
    suspend fun runExample() {
        println("=== MeasurementManager Example ===")
 
        demonstrateMeasurementManagerMethods()
 
        // Wait a bit for measurements
        delay(5000)
 
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() = runBlocking {
    val example = MeasurementManagerExample()
    example.runExample()
}