AsyncRouteManagerExample.java

Go to the documentation of this file.

package com.navigine.examples;
 
import java.util.List;
import java.util.ArrayList;

public class AsyncRouteManagerExample {
    private NavigineSdk sdk;
    private LocationManager locationManager;
    private NavigationManager navigationManager;
    private AsyncRouteManager asyncRouteManager;
    private AsyncRouteListener asyncRouteListener;
    private RouteSession currentSession;
 
    public AsyncRouteManagerExample() {
        initializeSdk();
        setupAsyncRouteListener();
    }

    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]
 
            // [java_NavigineSdk_getAsyncRouteManager]
            // Get AsyncRouteManager for working with async routes
            asyncRouteManager = sdk.getAsyncRouteManager(locationManager, navigationManager);
            // [java_NavigineSdk_getAsyncRouteManager]
 
            if (locationManager != null && navigationManager != null && asyncRouteManager != null) {
                System.out.println("LocationManager, NavigationManager and AsyncRouteManager successfully initialized");
            }
        } catch (Exception e) {
            System.err.println("Error initializing SDK: " + e.getMessage());
        }
    }

    private void setupAsyncRouteListener() {
        asyncRouteListener = new AsyncRouteListener() {
            @Override
            // [java_AsyncRouteListener_onRouteChanged]
            public void onRouteChanged(RouteStatus status, RoutePath currentPath) {
                System.out.println("Route changed with status: " + status);
                if (status == RouteStatus.NEW_ROUTE && currentPath != null) {
                    demonstrateRoutePathUsage(currentPath);
                } else {
                    System.out.println("Route not ready, status: " + status);
                }
            }
            // [java_AsyncRouteListener_onRouteChanged]
 
            @Override
            // [java_AsyncRouteListener_onRouteAdvanced]
            public void onRouteAdvanced(float distance, LocationPoint point) {
                System.out.println("Route advanced: " + distance + " meters");
                demonstrateLocationPointUsage(point);
            }
            // [java_AsyncRouteListener_onRouteAdvanced]
        };
    }

    public void demonstrateAsyncRouteManagerMethods() {
        if (asyncRouteManager == null) {
            System.err.println("AsyncRouteManager not initialized");
            return;
        }
 
        // Create test destination point
        Point destinationPoint = new Point(100.0, 100.0);
        LocationPoint destinationLocationPoint = new LocationPoint(destinationPoint, 12345, 1);
 
        // Create route options
        RouteOptions routeOptions = new RouteOptions(2.0, 5.0, 2.0);
 
        // [java_AsyncRouteManager_createRouteSession]
        // Create route session with default graph tag
        RouteSession session = asyncRouteManager.createRouteSession(destinationLocationPoint, routeOptions);
        System.out.println("Created route session with default graph tag");
        // [java_AsyncRouteManager_createRouteSession]
 
        // [java_AsyncRouteManager_createRouteSessionWithTag]
        // Create route session with specific graph tag
        RouteSession sessionWithTag = asyncRouteManager.createRouteSessionWithTag(destinationLocationPoint, routeOptions, "main");
        System.out.println("Created route session with 'main' graph tag");
        // [java_AsyncRouteManager_createRouteSessionWithTag]
 
        // Store session for later use
        currentSession = session;
 
        // Add listener to session
        if (asyncRouteListener != null) {
            // [java_RouteSession_addRouteListener]
            // Add route listener to session
            session.addRouteListener(asyncRouteListener);
            // [java_RouteSession_addRouteListener]
        }
    }

    public void demonstrateRoutePathUsage(RoutePath routePath) {
        if (routePath == null) {
            System.err.println("RoutePath is null");
            return;
        }
 
        // [java_RoutePath_getLength]
        // Get route length
        double length = routePath.getLength();
        System.out.println("Route length: " + length + " meters");
        // [java_RoutePath_getLength]
 
        // [java_RoutePath_getWeight]
        // Get total route weight
        double weight = routePath.getWeight();
        System.out.println("Route weight: " + weight);
        // [java_RoutePath_getWeight]
 
        // [java_RoutePath_getNodes]
        // Get route nodes
        List<RouteNode> nodes = routePath.getNodes();
        System.out.println("Number of route nodes: " + nodes.size());
        for (int i = 0; i < nodes.size() && i < 3; i++) {
            demonstrateRouteNodeUsage(nodes.get(i));
        }
        // [java_RoutePath_getNodes]
 
        // [java_RoutePath_head]
        // Get route head (first 10 meters)
        RoutePath head = routePath.head(10.0);
        if (head != null) {
            System.out.println("Route head length: " + head.getLength() + " meters");
        }
        // [java_RoutePath_head]
 
        // [java_RoutePath_tail]
        // Get route tail (remaining after 10 meters)
        RoutePath tail = routePath.tail(10.0);
        if (tail != null) {
            System.out.println("Route tail length: " + tail.getLength() + " meters");
        }
        // [java_RoutePath_tail]
    }
 
    public void demonstrateRouteNodeUsage(RouteNode node) {
        // [java_RouteNode_getPoint]
        LocationPoint point = node.getPoint();
        demonstrateLocationPointUsage(point);
        // [java_RouteNode_getPoint]
 
        // [java_RouteNode_getWeight]
        float weight = node.getWeight();
        System.out.println("Node weight: " + weight);
        // [java_RouteNode_getWeight]
 
        // [java_RouteNode_getDistance]
        float distance = node.getDistance();
        System.out.println("Node distance: " + distance + " meters");
        // [java_RouteNode_getDistance]
 
        // [java_RouteNode_getEvents]
        List<RouteEvent> events = node.getEvents();
        for (RouteEvent event : events) {
            demonstrateRouteEventUsage(event);
        }
        // [java_RouteNode_getEvents]
    }

    public void demonstrateRouteEventUsage(RouteEvent event) {
        if (event == null) {
            System.err.println("RouteEvent is null");
            return;
        }
 
        // [java_RouteEvent_getType]
        // Get event type
        RouteEventType type = event.getType();
        System.out.println("Event type: " + type);
        // [java_RouteEvent_getType]
 
        // [java_RouteEvent_getTurnEvent]
        TurnEvent turnEvent = event.getTurnEvent();
        if (turnEvent != null) {
            demonstrateTurnEventUsage(turnEvent);
        }
        // [java_RouteEvent_getTurnEvent]
 
        // [java_RouteEvent_getTransitionEntryEvent]
        TransitionEntryEvent entryEvent = event.getTransitionEntryEvent();
        if (entryEvent != null) {
            demonstrateTransitionEntryEventUsage(entryEvent);
        }
        // [java_RouteEvent_getTransitionEntryEvent]
 
        // [java_RouteEvent_getTransitionExitEvent]
        TransitionExitEvent exitEvent = event.getTransitionExitEvent();
        if (exitEvent != null) {
            demonstrateTransitionExitEventUsage(exitEvent);
        }
        // [java_RouteEvent_getTransitionExitEvent]
 
        // [java_RouteEvent_getTargetReachedEvent]
        TargetReachedEvent reachedEvent = event.getTargetReachedEvent();
        if (reachedEvent != null) {
            demonstrateTargetReachedEventUsage(reachedEvent);
        }
        // [java_RouteEvent_getTargetReachedEvent]
    }

    public void demonstrateRouteEventTypes() {
        // [java_RouteEventType_values]
        // Get all route event type values
        RouteEventType[] types = RouteEventType.values();
        System.out.println("Available route event types:");
        for (RouteEventType type : types) {
            System.out.println("  - " + type);
        }
        // [java_RouteEventType_values]
    }
 
    public void demonstrateTurnTypes() {
        // [java_TurnType_values]
        TurnType[] types = TurnType.values();
        for (TurnType type : types) {
            System.out.println("  - " + type);
        }
        // [java_TurnType_values]
    }
 
    public void demonstrateTurnEventUsage(TurnEvent event) {
        // [java_TurnEvent_getType]
        TurnType type = event.getType();
        System.out.println("Turn type: " + type);
        // [java_TurnEvent_getType]
 
        // [java_TurnEvent_getAngle]
        int angle = event.getAngle();
        System.out.println("Turn angle: " + angle);
        // [java_TurnEvent_getAngle]
    }
 
    public void demonstrateTransitionEntryEventUsage(TransitionEntryEvent event) {
        // [java_TransitionEntryEvent_getFrom]
        long from = event.getFrom();
        System.out.println("Transition entry from: " + from);
        // [java_TransitionEntryEvent_getFrom]
 
        // [java_TransitionEntryEvent_getTo]
        long to = event.getTo();
        System.out.println("Transition entry to: " + to);
        // [java_TransitionEntryEvent_getTo]
    }
 
    public void demonstrateTransitionExitEventUsage(TransitionExitEvent event) {
        // [java_TransitionExitEvent_getFrom]
        long from = event.getFrom();
        System.out.println("Transition exit from: " + from);
        // [java_TransitionExitEvent_getFrom]
 
        // [java_TransitionExitEvent_getTo]
        long to = event.getTo();
        System.out.println("Transition exit to: " + to);
        // [java_TransitionExitEvent_getTo]
    }
 
    public void demonstrateTargetReachedEventUsage(TargetReachedEvent event) {
        // [java_TargetReachedEvent_getIndex]
        long index = event.getIndex();
        System.out.println("Reached target index: " + index);
        // [java_TargetReachedEvent_getIndex]
 
        // [java_TargetReachedEvent_getPoint]
        LocationPoint point = event.getPoint();
        demonstrateLocationPointUsage(point);
        // [java_TargetReachedEvent_getPoint]
    }

    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();
        System.out.println("Location point: (" + point.getX() + ", " + point.getY() + ")");
        // [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 location point
        Point newPoint = new Point(25.0, 35.0);
        LocationPoint newLocationPoint = new LocationPoint(newPoint, 12345, 2);
        System.out.println("Created new location point: " + newLocationPoint.getPoint().getX() + ", " + newLocationPoint.getPoint().getY());
        // [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(15.0, 25.0);
        System.out.println("Created new point: (" + newPoint.getX() + ", " + newPoint.getY() + ")");
        // [java_Point_constructor]
    }

    public void demonstrateRouteOptions() {
        System.out.println("=== Route Options ===");
 
        // [java_RouteOptions_constructor]
        // Create route options with custom parameters
        RouteOptions routeOptions = new RouteOptions(3.0, 7.0, 2.5);
        System.out.println("Created route options with smoothRadius: " + routeOptions.getSmoothRadius() +
                          ", maxProjectionDistance: " + routeOptions.getMaxProjectionDistance() +
                          ", maxAdvance: " + routeOptions.getMaxAdvance());
        // [java_RouteOptions_constructor]
 
        // Demonstrate different route options configurations
        RouteOptions[] optionsList = {
            new RouteOptions(0.0, 5.0, 2.0),    // No smoothing
            new RouteOptions(2.0, 10.0, 1.0),   // High smoothing, high projection distance
            new RouteOptions(1.0, 3.0, 3.0),    // Low smoothing, low projection distance
        };
 
        for (int i = 0; i < optionsList.length; i++) {
            RouteOptions options = optionsList[i];
            System.out.println("Options " + (i + 1) + ": smoothRadius=" + options.getSmoothRadius() +
                              ", maxProjectionDistance=" + options.getMaxProjectionDistance() +
                              ", maxAdvance=" + options.getMaxAdvance());
        }
    }

    public void demonstrateAdvancedAsyncRoutingFeatures() {
        System.out.println("=== Advanced Async Routing Features ===");
 
        if (asyncRouteManager == null) {
            return;
        }
 
        // Create multiple destination points
        List<LocationPoint> destinations = new ArrayList<>();
        destinations.add(new LocationPoint(new Point(50.0, 50.0), 12345, 1));
        destinations.add(new LocationPoint(new Point(100.0, 100.0), 12345, 1));
        destinations.add(new LocationPoint(new Point(150.0, 150.0), 12345, 1));
 
        // Create different route options for each destination
        RouteOptions[] optionsList = {
            new RouteOptions(2.0, 5.0, 2.0),
            new RouteOptions(3.0, 7.0, 1.5),
            new RouteOptions(1.0, 3.0, 2.5),
        };
 
        // Create sessions for each destination
        List<RouteSession> sessions = new ArrayList<>();
        for (int i = 0; i < destinations.size(); i++) {
            RouteSession session = asyncRouteManager.createRouteSession(destinations.get(i), optionsList[i]);
            sessions.add(session);
            System.out.println("Created session " + (i + 1) + " for destination: " +
                              destinations.get(i).getPoint().getX() + ", " + destinations.get(i).getPoint().getY());
 
            if (asyncRouteListener != null) {
                session.addRouteListener(asyncRouteListener);
            }
 
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
 
        // Wait for route updates
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
 
        // Cancel all sessions
        for (int i = 0; i < sessions.size(); i++) {
            // [java_AsyncRouteManager_cancelRouteSession]
            // Cancel route session
            asyncRouteManager.cancelRouteSession(sessions.get(i));
            System.out.println("Cancelled session " + (i + 1));
            // [java_AsyncRouteManager_cancelRouteSession]
 
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public void demonstrateRouteStatusUsage() {
        System.out.println("=== RouteStatus Enum Usage ===");
 
        // [java_RouteStatus_values]
        // Demonstrate all RouteStatus values
        System.out.println("Available RouteStatus values:");
        for (RouteStatus status : RouteStatus.values()) {
            System.out.println("  - " + status.name() + ": " + status.toString());
        }
 
        // Demonstrate status checking
        RouteStatus testStatus = RouteStatus.NEW_ROUTE;
        if (testStatus == RouteStatus.NEW_ROUTE) {
            System.out.println("Router is ready for navigation");
        } else if (testStatus == RouteStatus.MISSING_GRAPH) {
            System.out.println("Router is missing the route graph");
        } else if (testStatus == RouteStatus.MISSING_POSITION) {
            System.out.println("Router is missing the current position");
        } else if (testStatus == RouteStatus.MISSING_PROJECTION) {
            System.out.println("Current position is off the route graph");
        } else if (testStatus == RouteStatus.MISSING_ROUTE) {
            System.out.println("Router unable to find the route to the destination point");
        }
        // [java_RouteStatus_values]
    }

    public void demonstrateRouteSessionManagement() {
        System.out.println("=== Route Session Management ===");
 
        if (asyncRouteManager == null || asyncRouteListener == null) {
            return;
        }
 
        // Create test destination
        Point destinationPoint = new Point(75.0, 75.0);
        LocationPoint destinationLocationPoint = new LocationPoint(destinationPoint, 12345, 1);
        RouteOptions routeOptions = new RouteOptions(2.0, 5.0, 2.0);
 
        // Create session with default tag
        RouteSession defaultSession = asyncRouteManager.createRouteSession(destinationLocationPoint, routeOptions);
        System.out.println("Created session with default tag");
 
        // Create session with specific tag
        RouteSession taggedSession = asyncRouteManager.createRouteSessionWithTag(destinationLocationPoint, routeOptions, "elevator");
        System.out.println("Created session with 'elevator' tag");
 
        // Add listeners to both sessions
        defaultSession.addRouteListener(asyncRouteListener);
        taggedSession.addRouteListener(asyncRouteListener);
 
        // Simulate some time passing
        new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
 
            // Remove listeners
            // [java_RouteSession_removeRouteListener1]
            // Remove route listener from session
            defaultSession.removeRouteListener(asyncRouteListener);
            taggedSession.removeRouteListener(asyncRouteListener);
            System.out.println("Removed listeners from sessions");
            // [java_RouteSession_removeRouteListener1]
 
            // Cancel sessions
            asyncRouteManager.cancelRouteSession(defaultSession);
            asyncRouteManager.cancelRouteSession(taggedSession);
            System.out.println("Cancelled both sessions");
        }).start();
    }

    public void cleanup() {
        if (currentSession != null && asyncRouteListener != null) {
            // [java_RouteSession_removeRouteListener]
            // Remove route listener
            currentSession.removeRouteListener(asyncRouteListener);
            // [java_RouteSession_removeRouteListener]
        }
 
        if (asyncRouteManager != null && currentSession != null) {
            // [java_AsyncRouteManager_cancelRouteSession_1]
            // Cancel route session
            asyncRouteManager.cancelRouteSession(currentSession);
            // [java_AsyncRouteManager_cancelRouteSession_1]
        }
    }

    public void runExample() {
        System.out.println("=== AsyncRouteManager Example ===");
 
        demonstrateAsyncRouteManagerMethods();
        demonstrateRouteEventTypes();
        demonstrateTurnTypes();
        demonstrateRouteOptions();
        demonstrateRouteStatusUsage();
        demonstrateRouteSessionManagement();
        demonstrateAdvancedAsyncRoutingFeatures();
 
        // Wait a bit for route updates
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
 
        cleanup();
        System.out.println("=== Example completed ===");
    }

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