NavigationManagerExample.java

Go to the documentation of this file.

package com.navigine.examples;
 
import com.navigine.idl.java.*;

public class NavigationManagerExample {
    private NavigineSdk sdk;
    private LocationManager locationManager;
    private NavigationManager navigationManager;
    private PositionListener positionListener;
 
    public NavigationManagerExample() {
        initializeSdk();
        setupPositionListener();
    }

    private void initializeSdk() {
        try {
            // [java_NavigineSdk_getInstance]
            // Get SDK instance
            sdk = NavigineSdk.getInstance();
            // [java_NavigineSdk_getInstance]
 
            // [java_NavigineSdk_setUserHash]
            // Set user hash
            sdk.setUserHash("USER-HASH-HERE");
            // [java_NavigineSdk_setUserHash]
 
            // [java_NavigineSdk_setServer]
            // Set server URL (optional)
            sdk.setServer("https://custom.navigine.com");
            // [java_NavigineSdk_setServer]
 
            // [java_NavigineSdk_getLocationManager]
            // Get LocationManager for working with locations
            locationManager = sdk.getLocationManager();
            // [java_NavigineSdk_getLocationManager]
 
                    // [java_NavigineSdk_getNavigationManager]
        // Get NavigationManager for working with navigation
        navigationManager = sdk.getNavigationManager(locationManager);
        // [java_NavigineSdk_getNavigationManager]
 
            if (locationManager != null && navigationManager != null) {
                System.out.println("LocationManager and NavigationManager successfully initialized");
            }
        } catch (Exception e) {
            System.err.println("Error initializing SDK: " + e.getMessage());
        }
    }

    private void setupPositionListener() {
        positionListener = new PositionListener() {
            @Override
            // [java_PositionListener_onPositionUpdated]
            public void onPositionUpdated(Position position) {
                System.out.println("Position updated successfully");
                demonstratePositionUsage(position);
            }
            // [java_PositionListener_onPositionUpdated]
 
            @Override
            // [java_PositionListener_onPositionError]
            public void onPositionError(Error error) {
                System.err.println("Position error: " + error.getMessage());
            }
            // [java_PositionListener_onPositionError]
        };
    }

    public void demonstrateNavigationManagerMethods() {
        if (navigationManager == null) {
            System.err.println("NavigationManager not initialized");
            return;
        }
 
        // [java_NavigationManager_addPositionListener]
        // Add position listener
        navigationManager.addPositionListener(positionListener);
        // [java_NavigationManager_addPositionListener]
 
        // [java_NavigationManager_startLogRecording]
        // Start log recording
        navigationManager.startLogRecording();
        // [java_NavigationManager_startLogRecording]
 
        // [java_NavigationManager_addCheckPoint]
        // Add check point
        Point point = new Point(10.0, 20.0);
        LocationPoint locationPoint = new LocationPoint(point, 12345, 1);
        navigationManager.addCheckPoint(locationPoint);
        // [java_NavigationManager_addCheckPoint]
 
        // [java_NavigationManager_addLocationMeasurement]
        // Add location measurement
        GlobalPoint globalPoint = new GlobalPoint(55.7558, 37.6176); // Moscow coordinates
        navigationManager.addLocationMeasurement(globalPoint, 5.0f, "gps");
        // [java_NavigationManager_addLocationMeasurement]
 
        // [java_NavigationManager_stopLogRecording]
        // Stop log recording
        navigationManager.stopLogRecording();
        // [java_NavigationManager_stopLogRecording]
    }

    public void demonstratePositionUsage(Position position) {
        if (position == null) {
            System.err.println("Position is null");
            return;
        }
 
        // [java_Position_getPoint]
        // Get global point (WGS84 coordinates)
        GlobalPoint globalPoint = position.getPoint();
        if (globalPoint != null) {
            demonstrateGlobalPointUsage(globalPoint);
        }
        // [java_Position_getPoint]
 
        // [java_Position_getAccuracy]
        // Get position accuracy
        double accuracy = position.getAccuracy();
        System.out.println("Position accuracy: " + accuracy + " meters");
        // [java_Position_getAccuracy]
 
        // [java_Position_getHeading]
        // Get heading (angle of rotation about the -Z axis in radians)
        Double heading = position.getHeading();
        if (heading != null) {
            System.out.println("Heading: " + heading + " radians");
        }
        // [java_Position_getHeading]
 
        // [java_Position_getHeadingAccuracy]
        // Get heading accuracy
        Double headingAccuracy = position.getHeadingAccuracy();
        if (headingAccuracy != null) {
            System.out.println("Heading accuracy: " + headingAccuracy + " radians");
        }
        // [java_Position_getHeadingAccuracy]
 
        // [java_Position_getLocationPoint]
        // Get location point (metrics coordinates)
        LocationPoint locationPoint = position.getLocationPoint();
        if (locationPoint != null) {
            demonstrateLocationPointUsage(locationPoint);
        }
        // [java_Position_getLocationPoint]
 
        // [java_Position_getLocationHeading]
        // Get location heading (with respect to sublocation north)
        Double locationHeading = position.getLocationHeading();
        if (locationHeading != null) {
            System.out.println("Location heading: " + locationHeading + " radians");
        }
        // [java_Position_getLocationHeading]
    }

    public void demonstrateGlobalPointUsage(GlobalPoint globalPoint) {
        if (globalPoint == null) {
            System.err.println("GlobalPoint is null");
            return;
        }
 
        // [java_GlobalPoint_getLatitude]
        // Get latitude
        double latitude = globalPoint.getLatitude();
        System.out.println("Latitude: " + latitude);
        // [java_GlobalPoint_getLatitude]
 
        // [java_GlobalPoint_getLongitude]
        // Get longitude
        double longitude = globalPoint.getLongitude();
        System.out.println("Longitude: " + longitude);
        // [java_GlobalPoint_getLongitude]
 
        // [java_GlobalPoint_constructor]
        // Create new GlobalPoint
        GlobalPoint newPoint = new GlobalPoint(latitude, longitude);
        System.out.println("Created new GlobalPoint: " + newPoint);
        // [java_GlobalPoint_constructor]
    }

    public void demonstrateLocationPointUsage(LocationPoint locationPoint) {
        if (locationPoint == null) {
            System.err.println("LocationPoint is null");
            return;
        }
 
        // [java_LocationPoint_getPoint]
        // Get point coordinates
        Point point = locationPoint.getPoint();
        if (point != null) {
            demonstratePointUsage(point);
        }
        // [java_LocationPoint_getPoint]
 
        // [java_LocationPoint_getLocationId]
        // Get location ID
        int locationId = locationPoint.getLocationId();
        System.out.println("Location ID: " + locationId);
        // [java_LocationPoint_getLocationId]
 
        // [java_LocationPoint_getSublocationId]
        // Get sublocation ID
        int sublocationId = locationPoint.getSublocationId();
        System.out.println("Sublocation ID: " + sublocationId);
        // [java_LocationPoint_getSublocationId]
 
        // [java_LocationPoint_constructor]
        // Create new LocationPoint
        Point newPoint = new Point(15.0, 25.0);
        LocationPoint newLocationPoint = new LocationPoint(newPoint, locationId, sublocationId);
        System.out.println("Created new LocationPoint: " + newLocationPoint);
        // [java_LocationPoint_constructor]
    }

    public void demonstratePointUsage(Point point) {
        if (point == null) {
            System.err.println("Point is null");
            return;
        }
 
        // [java_Point_getX]
        // Get X coordinate
        double x = point.getX();
        System.out.println("Point X: " + x);
        // [java_Point_getX]
 
        // [java_Point_getY]
        // Get Y coordinate
        double y = point.getY();
        System.out.println("Point Y: " + y);
        // [java_Point_getY]
 
        // [java_Point_constructor]
        // Create new Point
        Point newPoint = new Point(x, y);
        System.out.println("Created new Point: " + newPoint);
        // [java_Point_constructor]
    }

    public void demonstrateLocationManagerIntegration() {
        if (locationManager == null) {
            System.err.println("LocationManager not initialized");
            return;
        }
 
        // [java_LocationManager_addLocationListener]
        // Add location listener for navigation integration
        LocationListener locationListener = new LocationListener() {
            @Override
            // [java_LocationListener_onLocationLoaded]
            public void onLocationLoaded(Location location) {
                System.out.println("Location loaded for navigation");
                if (location != null) {
                    // [java_LocationManager_setLocationId]
                    // Set location ID for navigation
                    locationManager.setLocationId(location.getId());
                    // [java_LocationManager_setLocationId]
                }
            }
            // [java_LocationListener_onLocationLoaded]
 
            @Override
            // [java_LocationListener_onLocationUploaded]
            public void onLocationUploaded(int locationId) {
                System.out.println("Location uploaded: " + locationId);
            }
            // [java_LocationListener_onLocationUploaded]
 
            @Override
            // [java_LocationListener_onLocationFailed]
            public void onLocationFailed(int locationId, Error error) {
                System.err.println("Failed to load location " + locationId + ": " + error.getMessage());
            }
            // [java_LocationListener_onLocationFailed]
        };
        locationManager.addLocationListener(locationListener);
        // [java_LocationManager_addLocationListener]
 
        // [java_LocationManager_setLocationId]
        // Set location ID to load
        locationManager.setLocationId(12345);
        // [java_LocationManager_setLocationId]
 
        // [java_LocationManager_getLocationId]
        // Get current location ID
        int currentLocationId = locationManager.getLocationId();
        System.out.println("Current location ID: " + currentLocationId);
        // [java_LocationManager_getLocationId]
 
        // [java_LocationManager_setLocationUpdateInterval]
        // Set location update interval
        locationManager.setLocationUpdateInterval(300); // 5 minutes
        // [java_LocationManager_setLocationUpdateInterval]
 
        // [java_LocationManager_commitChanges]
        // Commit changes
        locationManager.commitChanges();
        // [java_LocationManager_commitChanges]
    }

    public void demonstrateAdvancedNavigationFeatures() {
        System.out.println("=== Advanced Navigation Features ===");
 
        // Create multiple check points for path tracking
        Point[] checkPoints = {
            new Point(0.0, 0.0),
            new Point(10.0, 10.0),
            new Point(20.0, 20.0),
            new Point(30.0, 30.0)
        };
 
        for (int i = 0; i < checkPoints.length; i++) {
            LocationPoint locationPoint = new LocationPoint(checkPoints[i], 12345, 1);
            // [java_NavigationManager_addCheckPoint]
            // Add check point for path tracking
            navigationManager.addCheckPoint(locationPoint);
            // [java_NavigationManager_addCheckPoint]
            System.out.println("Added check point " + (i + 1) + ": " + locationPoint);
        }
 
        // Add location measurements with different providers
        GlobalPoint[] measurements = {
            new GlobalPoint(55.7558, 37.6176), // Moscow
            new GlobalPoint(40.7128, -74.0060), // New York
            new GlobalPoint(51.5074, -0.1278)  // London
        };
 
        String[] providers = {"gps", "network", "fused"};
 
        for (int i = 0; i < measurements.length; i++) {
            // [java_NavigationManager_addLocationMeasurement]
            // Add location measurement with different providers
            navigationManager.addLocationMeasurement(measurements[i], 3.0f + i, providers[i % providers.length]);
            // [java_NavigationManager_addLocationMeasurement]
            System.out.println("Added measurement " + (i + 1) + " with provider: " + providers[i % providers.length]);
        }
    }

    public void demonstratePositionTrackingSimulation() {
        System.out.println("=== Position Tracking Simulation ===");
 
        // [java_NavigationManager_startLogRecording]
        // Start log recording for position tracking
        navigationManager.startLogRecording();
        // [java_NavigationManager_startLogRecording]
 
        // Simulate position updates
        for (int i = 0; i < 5; i++) {
            double lat = 55.7558 + (i * 0.001); // Move north
            double lon = 37.6176 + (i * 0.001); // Move east
            
            GlobalPoint globalPoint = new GlobalPoint(lat, lon);
            // [java_NavigationManager_addLocationMeasurement]
            // Add simulated location measurement
            navigationManager.addLocationMeasurement(globalPoint, 2.0f, "simulated");
            // [java_NavigationManager_addLocationMeasurement]
            
            System.out.println("Simulated position " + (i + 1) + ": " + globalPoint);
            
            try {
                Thread.sleep(1000); // Wait 1 second between updates
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
 
        // [java_NavigationManager_stopLogRecording]
        // Stop log recording
        navigationManager.stopLogRecording();
        // [java_NavigationManager_stopLogRecording]
    }

    public void cleanup() {
        if (navigationManager != null && positionListener != null) {
            // [java_NavigationManager_removePositionListener]
            // Remove position listener
            navigationManager.removePositionListener(positionListener);
            // [java_NavigationManager_removePositionListener]
        }
    }

    public void runExample() {
        System.out.println("=== NavigationManager Example ===");
        
        demonstrateNavigationManagerMethods();
        demonstrateLocationManagerIntegration();
        demonstrateAdvancedNavigationFeatures();
        demonstratePositionTrackingSimulation();
        
        // Wait a bit for position updates
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        cleanup();
        System.out.println("=== Example completed ===");
    }

    public static void main(String[] args) {
        NavigationManagerExample example = new NavigationManagerExample();
        example.runExample();
    }
}