NavigineSdkExample.swift

Go to the documentation of this file.

import Foundation
import NavigineSDK
 
/**
 * NavigineSDK usage example for Swift
 * Demonstrates SDK initialization and access to various managers
 */
class NavigineSdkExample {
 
    private var sdk: NCNavigineSdk?
    private var locationManager: NCLocationManager?
    private var navigationManager: NCNavigationManager?
    private var zoneManager: NCZoneManager?
    private var routeManager: NCRouteManager?
    private var asyncRouteManager: NCAsyncRouteManager?
    private var notificationManager: NCNotificationManager?
    private var measurementManager: NCMeasurementManager?
    private var locationListManager: NCLocationListManager?
    private var storageManager: NCStorageManager?
    private var mqttSession: NCMqttSession?
    private var locationWindow: NCLocationWindow?
    private var routeLayer: NCRouteLayer?
    private var guidanceCamera: NCGuidanceCamera?
 
    init() {
        initializeSdk()
    }
 
    /**
     * SDK initialization and basic parameter setup
     */
    private func initializeSdk() {
        do {
            // [swift_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NCNavigineSdk.getInstance()
            // [swift_NavigineSdk_getInstance]
 
            guard let sdk = sdk else {
                print("Error: failed to get NavigineSdk instance")
                return
            }
 
            // [swift_NavigineSdk_getVersion]
            // Get SDK version
            print("Navigine SDK Version: \‍(NCNavigineSdk.getVersion())")
            // [swift_NavigineSdk_getVersion]
 
            // [swift_NavigineSdk_getDeviceId]
            // Get device ID
            print("Device ID: \‍(NCNavigineSdk.getDeviceId())")
            // [swift_NavigineSdk_getDeviceId]
 
            // [swift_NavigineSdk_getRelativeTime]
            // Get relative time
            print("Relative Time: \‍(NCNavigineSdk.getRelativeTime())")
            // [swift_NavigineSdk_getRelativeTime]
 
            // [swift_NavigineSdk_setUserHash]
            // Set user hash (authorization token)
            sdk.setUserHash("XXXX-XXXX-XXXX-XXXX")
            // [swift_NavigineSdk_setUserHash]
 
 
            // [swift_NavigineSdk_getUserAgent]
            print("User-Agent: \‍(NCNavigineSdk.getUserAgent())")
            // [swift_NavigineSdk_getUserAgent]
 
            // [swift_NavigineSdk_reset]
            sdk?.reset()
            print("SDK reset to initial state")
            // [swift_NavigineSdk_reset]
 
            // [swift_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk.setServer("https://custom.navigine.com")
            // [swift_NavigineSdk_setServer]
 
            // Initialize managers
            initializeManagers()
 
        } catch {
            print("SDK initialization error: \‍(error)")
        }
    }
 
    /**
     * Initialize all SDK managers
     */
    private func initializeManagers() {
        guard let sdk = sdk else { return }
 
        // [swift_NavigineSdk_getLocationManager]
        // Get LocationManager for working with locations
        locationManager = sdk.getLocationManager()
        if locationManager != nil {
            print("LocationManager successfully initialized")
        }
        // [swift_NavigineSdk_getLocationManager]
 
        // [swift_NavigineSdk_getNavigationManager]
        // Get NavigationManager for navigation
        if let locationManager = locationManager {
            navigationManager = sdk.getNavigationManager(locationManager)
            if navigationManager != nil {
                print("NavigationManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getNavigationManager]
 
        // [swift_NavigineSdk_getZoneManager]
        // Get ZoneManager for working with zones
        if let navigationManager = navigationManager {
            zoneManager = sdk.getZoneManager(navigationManager)
            if zoneManager != nil {
                print("ZoneManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getZoneManager]
 
        // [swift_NavigineSdk_getRouteManager]
        // Get RouteManager for building routes
        if let locationManager = locationManager,
           let navigationManager = navigationManager {
            routeManager = sdk.getRouteManager(locationManager, navigationManager: navigationManager)
            if routeManager != nil {
                print("RouteManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getRouteManager]
 
        // [swift_NavigineSdk_getAsyncRouteManager]
        // Get AsyncRouteManager for async route operations
        if let locationManager = locationManager,
           let navigationManager = navigationManager {
            asyncRouteManager = sdk.getAsyncRouteManager(locationManager, navigationManager: navigationManager)
            if asyncRouteManager != nil {
                print("AsyncRouteManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getAsyncRouteManager]
 
        // [swift_NavigineSdk_getNotificationManager]
        // Get NotificationManager for notifications
        if let locationManager = locationManager {
            notificationManager = sdk.getNotificationManager(locationManager)
            if notificationManager != nil {
                print("NotificationManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getNotificationManager]
 
        // [swift_NavigineSdk_getMeasurementManager]
        // Get MeasurementManager for measurements
        if let locationManager = locationManager {
            measurementManager = sdk.getMeasurementManager(locationManager)
            if measurementManager != nil {
                print("MeasurementManager successfully initialized")
            }
        }
        // [swift_NavigineSdk_getMeasurementManager]
 
        // [swift_NavigineSdk_getLocationListManager]
        // Get LocationListManager for location list operations
        locationListManager = sdk.getLocationListManager()
        if locationListManager != nil {
            print("LocationListManager successfully initialized")
        }
        // [swift_NavigineSdk_getLocationListManager]
 
        // [swift_NavigineSdk_getStorageManager]
        // Get StorageManager for working with storages
        storageManager = sdk.getStorageManager()
        if storageManager != nil {
            print("StorageManager successfully initialized")
        }
        // [swift_NavigineSdk_getStorageManager]
 
        // [swift_NavigineSdk_getRouteLayer]
        // Create RouteLayer for building and drawing routes on the map
        if let locationWindow = locationWindow {
            routeLayer = sdk.getRouteLayer(locationWindow)
            if routeLayer != nil {
                print("RouteLayer successfully initialized")
            }
        }
        // [swift_NavigineSdk_getRouteLayer]
 
        // [swift_NavigineSdk_getGuidanceCamera]
        if let locationWindow = locationWindow, let routeLayer = routeLayer {
            guidanceCamera = sdk.getGuidanceCamera(locationWindow, routeLayer: routeLayer)
            // [swift_GuidanceCamera_setMode]
            guidanceCamera?.setMode(.FOLLOWING)
            // [swift_GuidanceCamera_setMode]
            // [swift_GuidanceCamera_set2DMode]
            guidanceCamera?.set2DMode(false)
            // [swift_GuidanceCamera_set2DMode]
            // [swift_GuidanceCamera_mode]
            print("Guidance mode: \‍(String(describing: guidanceCamera?.mode()))")
            // [swift_GuidanceCamera_mode]
            // [swift_GuidanceCamera_instruction]
            if let next = guidanceCamera?.instruction() {
                print("Next instruction: \‍(next.title ?? "") \‍(next.distance) m")
            }
            // [swift_GuidanceCamera_instruction]
        }
        // [swift_NavigineSdk_getGuidanceCamera]
 
        // [swift_NavigineSdk_getRouteSimulator]
        if let window = locationWindow {
            let routeSimulator = sdk.getRouteSimulator(window)
            // [swift_RouteSimulator_setGeometry]
            let walk = NCLocationPolyline(points: [
                NCGlobalPoint(latitude: 55.751, longitude: 37.618),
                NCGlobalPoint(latitude: 55.752, longitude: 37.618),
            ], sublocationId: nil)
            _ = routeSimulator.setGeometry([walk])
            // [swift_RouteSimulator_setGeometry]
            // [swift_RouteSimulator_setSpeed]
            routeSimulator.setSpeed(1.4)
            // [swift_RouteSimulator_setSpeed]
            // [swift_RouteSimulator_start]
            let started = routeSimulator.start()
            print("Route walk started: \‍(started)")
            // [swift_RouteSimulator_start]
            // [swift_RouteSimulator_sample]
            if let sample = routeSimulator.sample() {
                print("Walk advance: \‍(sample.advance) m")
            }
            // [swift_RouteSimulator_sample]
        }
        // [swift_NavigineSdk_getRouteSimulator]
 
        // [swift_NavigineSdk_getMqttSession]
        // Get MqttSession for publishing position data via MQTT
        if let navigationManager = navigationManager {
            mqttSession = sdk.getMqttSession(navigationManager)
            if mqttSession != nil {
                print("MqttSession successfully initialized")
            }
        }
        // [swift_NavigineSdk_getMqttSession]
    }
 
    /**
     * Get information about current SDK state
     */
    func printSdkInfo() {
        print("=== Navigine SDK Information ===")
        print("SDK Version: \‍(NCNavigineSdk.getVersion())")
        print("Device ID: \‍(NCNavigineSdk.getDeviceId())")
        print("Relative Time: \‍(NCNavigineSdk.getRelativeTime())")
        print("LocationManager: \‍(locationManager != nil ? "available" : "unavailable")")
        print("NavigationManager: \‍(navigationManager != nil ? "available" : "unavailable")")
        print("ZoneManager: \‍(zoneManager != nil ? "available" : "unavailable")")
        print("RouteManager: \‍(routeManager != nil ? "available" : "unavailable")")
        print("AsyncRouteManager: \‍(asyncRouteManager != nil ? "available" : "unavailable")")
        print("NotificationManager: \‍(notificationManager != nil ? "available" : "unavailable")")
        print("MeasurementManager: \‍(measurementManager != nil ? "available" : "unavailable")")
        print("LocationListManager: \‍(locationListManager != nil ? "available" : "unavailable")")
        print("StorageManager: \‍(storageManager != nil ? "available" : "unavailable")")
        print("MqttSession: \‍(mqttSession != nil ? "available" : "unavailable")")
    }
 
    /**
     * Demonstrate usage of all managers
     */
    func demonstrateManagersUsage() {
        print("=== Manager Usage Demonstration ===")
 
        // LocationManager usage example
        if let locationManager = locationManager {
            print("LocationManager ready for location operations")
            // Add code here for loading locations, working with them, etc.
        }
 
        // NavigationManager usage example
        if let navigationManager = navigationManager {
            print("NavigationManager ready for positioning")
            // Add code here for getting position, setting up listeners, etc.
        }
 
        // ZoneManager usage example
        if let zoneManager = zoneManager {
            print("ZoneManager ready for zone operations")
            // Add code here for setting up zones, handling enter/exit events, etc.
        }
 
        // RouteManager usage example
        if let routeManager = routeManager {
            print("RouteManager ready for route building")
            // Add code here for building routes, setting destination points, etc.
        }
 
        // AsyncRouteManager usage example
        if let asyncRouteManager = asyncRouteManager {
            print("AsyncRouteManager ready for async route operations")
            // Add code here for creating routing sessions, etc.
        }
 
        // NotificationManager usage example
        if let notificationManager = notificationManager {
            print("NotificationManager ready for notifications")
            // Add code here for setting up beacon notifications, etc.
        }
 
        // MeasurementManager usage example
        if let measurementManager = measurementManager {
            print("MeasurementManager ready for measurements")
            // Add code here for managing measurement generators, etc.
        }
 
        // LocationListManager usage example
        if let locationListManager = locationListManager {
            print("LocationListManager ready for location list operations")
            // Add code here for getting available locations list, etc.
        }
 
        // StorageManager usage example
        if let storageManager = storageManager {
            print("StorageManager ready for storage operations")
            // Add code here for creating storages, managing data, etc.
        }
 
        // MqttSession usage example
        if let mqttSession = mqttSession {
            print("MqttSession ready for publishing position data via MQTT")
            // Add code here for connecting to MQTT broker, publishing positions, etc.
        }
    }
 
    /**
     * Demonstrate Swift features usage
     */
    func demonstrateSwiftFeatures() {
        print("=== Swift Features Demonstration ===")
 
        // Using guard let for safe optional unwrapping
        guard let sdk = sdk else {
            print("SDK unavailable")
            return
        }
 
        // Using defer for cleanup code execution
        defer {
            print("Swift features demonstration completed")
        }
 
        // Using map for data transformation
        let sdkInfo = [
            "version": NCNavigineSdk.getVersion(),
            "deviceId": NCNavigineSdk.getDeviceId(),
            "relativeTime": NCNavigineSdk.getRelativeTime()
        ]
 
        let infoStrings = sdkInfo.map { key, value in
            "\‍(key): \‍(value)"
        }
        print("SDK Information: \‍(infoStrings.joined(separator: ", "))")
 
        // Using compactMap for nil filtering
        let managers = [
            locationManager,
            navigationManager,
            zoneManager,
            routeManager,
            asyncRouteManager,
            notificationManager,
            measurementManager,
            locationListManager,
            storageManager,
            mqttSession
        ]
 
        let availableManagers = managers.compactMap { $0 }
        print("Available managers: \‍(availableManagers.count)")
 
        // Using async/await (if supported)
        Task {
            await performAsyncOperation()
        }
    }
 
    /**
     * Async operation
     */
    @MainActor
    private func performAsyncOperation() async {
        // Simulate async operation
        try? await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
        print("Async operation completed")
    }
 
    /**
     * Demonstrate property wrappers usage
     */
    func demonstratePropertyWrappers() {
        print("=== Property Wrappers Demonstration ===")
 
        // Example of @Published usage (if this was an ObservableObject)
        // @Published var sdkVersion = NCNavigineSdk.getVersion()
 
        // Example of @State usage (for SwiftUI)
        // @State private var isInitialized = false
 
        print("Property wrappers demonstrated")
    }
 
    /**
     * Main method for demonstration
     */
    func runExample() {
        printSdkInfo()
        demonstrateManagersUsage()
        demonstrateSwiftFeatures()
        demonstratePropertyWrappers()
    }
}
 
/**
 * Extension for additional functionality
 */
extension NavigineSdkExample {
 
    /**
     * Get status of all managers
     */
    func getManagersStatus() -> [String: Bool] {
        return [
            "LocationManager": locationManager != nil,
            "NavigationManager": navigationManager != nil,
            "ZoneManager": zoneManager != nil,
            "RouteManager": routeManager != nil,
            "AsyncRouteManager": asyncRouteManager != nil,
            "NotificationManager": notificationManager != nil,
            "MeasurementManager": measurementManager != nil,
            "LocationListManager": locationListManager != nil,
            "StorageManager": storageManager != nil,
            "MqttSession": mqttSession != nil
        ]
    }
 
    /**
     * Check if SDK is ready for work
     */
    func isSdkReady() -> Bool {
        return sdk != nil && locationManager != nil
    }
}
 
/**
 * Function to run the example
 */
func main() {
    let example = NavigineSdkExample()
    example.runExample()
}
 
// Run the example
main()