RouteManagerExample.java

Go to the documentation of this file.

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

public class RouteManagerExample {
    private NavigineSdk sdk;
    private LocationManager locationManager;
    private NavigationManager navigationManager;
    private RouteManager routeManager;
    private RouteListener routeListener;
 
    public RouteManagerExample() {
        initializeSdk();
        setupRouteListener();
    }

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

    private void setupRouteListener() {
        routeListener = new RouteListener() {
            @Override
            // [java_RouteListener_onPathsUpdated]
            public void onPathsUpdated(List<RoutePath> paths) {
                System.out.println("Routes updated successfully");
                demonstrateRoutePathUsage(paths);
            }
            // [java_RouteListener_onPathsUpdated]
        };
    }

    public void demonstrateRouteManagerMethods() {
        if (routeManager == null) {
            System.err.println("RouteManager not initialized");
            return;
        }
 
        if (routeListener == null) return;
 
        // [java_RouteManager_addRouteListener]
        // Add route listener
        routeManager.addRouteListener(routeListener);
        // [java_RouteManager_addRouteListener]
 
        // [java_RouteManager_setGraphTag]
        // Set graph tag
        routeManager.setGraphTag("main");
        // [java_RouteManager_setGraphTag]
 
        // [java_RouteManager_getGraphTag]
        // Get current graph tag
        String currentGraphTag = routeManager.getGraphTag();
        System.out.println("Current graph tag: " + currentGraphTag);
        // [java_RouteManager_getGraphTag]
 
        // [java_RouteManager_getGraphTags]
        // Get all graph tags
        List<String> graphTags = routeManager.getGraphTags();
        System.out.println("Available graph tags: " + graphTags);
        // [java_RouteManager_getGraphTags]
 
        // Create test points
        Point startPoint = new Point(10.0, 20.0);
        Point endPoint = new Point(50.0, 60.0);
        LocationPoint startLocationPoint = new LocationPoint(startPoint, 12345, 1);
        LocationPoint endLocationPoint = new LocationPoint(endPoint, 12345, 1);
 
        // [java_RouteManager_makeRoute]
        // Make route from point to point
        RoutePath routePath = routeManager.makeRoute(startLocationPoint, endLocationPoint);
        System.out.println("Route created with length: " + routePath.getLength() + " meters");
        // [java_RouteManager_makeRoute]
 
        // [java_RouteManager_makeRoutes]
        // Make routes to multiple destinations
        List<LocationPoint> destinations = new ArrayList<>();
        destinations.add(new LocationPoint(new Point(30.0, 40.0), 12345, 1));
        destinations.add(new LocationPoint(new Point(70.0, 80.0), 12345, 1));
        List<RoutePath> routePaths = routeManager.makeRoutes(startLocationPoint, destinations);
        System.out.println("Created " + routePaths.size() + " routes");
        // [java_RouteManager_makeRoutes]
 
        // [java_RouteManager_setTarget]
        // Set target point
        routeManager.setTarget(endLocationPoint);
        // [java_RouteManager_setTarget]
 
        // [java_RouteManager_addTarget]
        // Add additional target point
        LocationPoint additionalTarget = new LocationPoint(new Point(90.0, 100.0), 12345, 1);
        routeManager.addTarget(additionalTarget);
        // [java_RouteManager_addTarget]
 
        // [java_RouteManager_cancelTarget]
        // Cancel current target
        routeManager.cancelTarget();
        // [java_RouteManager_cancelTarget]
 
        // [java_RouteManager_clearTargets]
        // Clear all targets
        routeManager.clearTargets();
        // [java_RouteManager_clearTargets]
    }

    public void demonstrateRoutePathUsage(List<RoutePath> paths) {
        for (int i = 0; i < paths.size(); i++) {
            RoutePath path = paths.get(i);
            System.out.println("=== Route Path " + (i + 1) + " ===");
 
            // [java_RoutePath_getLength]
            // Get route length
            double length = path.getLength();
            System.out.println("Route length: " + length + " meters");
            // [java_RoutePath_getLength]
 
            // [java_RoutePath_getWeight]
            // Get total route weight
            double weight = path.getWeight();
            System.out.println("Route weight: " + weight);
            // [java_RoutePath_getWeight]
 
            // [java_RoutePath_getNodes]
            // Get route nodes
            List<RouteNode> nodes = path.getNodes();
            System.out.println("Route has " + nodes.size() + " nodes");
            for (RouteNode node : nodes) {
                demonstrateRouteNodeUsage(node);
            }
            // [java_RoutePath_getNodes]
 
            // [java_RoutePath_head]
            // Get head of route (first 10 meters)
            RoutePath headPath = path.head(10.0);
            if (headPath != null) {
                System.out.println("Head path length: " + headPath.getLength() + " meters");
            }
            // [java_RoutePath_head]
 
            // [java_RoutePath_tail]
            // Get tail of route (remaining after 10 meters)
            RoutePath tailPath = path.tail(10.0);
            if (tailPath != null) {
                System.out.println("Tail path length: " + tailPath.getLength() + " meters");
            }
            // [java_RoutePath_tail]
        }
    }

    public void demonstrateRouteNodeUsage(RouteNode node) {
        // [java_RouteNode_getPoint]
        LocationPoint point = node.getPoint();
        if (point != null) {
            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();
        System.out.println("Node has " + events.size() + " events");
        for (RouteEvent event : events) {
            demonstrateRouteEventUsage(event);
        }
        // [java_RouteNode_getEvents]
    }

    public void demonstrateRouteEventUsage(RouteEvent event) {
        // [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[] turnTypes = TurnType.values();
        System.out.println("Available turn types:");
        for (TurnType turnType : turnTypes) {
            System.out.println("  - " + turnType);
        }
        // [java_TurnType_values]
    }
 
    public void demonstrateTurnEventUsage(TurnEvent turnEvent) {
        // [java_TurnEvent_getType]
        TurnType turnType = turnEvent.getType();
        System.out.println("Turn type: " + turnType);
        // [java_TurnEvent_getType]
 
        // [java_TurnEvent_getAngle]
        int angle = turnEvent.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();
        if (point != null) {
            demonstrateLocationPointUsage(point);
        }
        // [java_TargetReachedEvent_getPoint]
    }

    public void demonstrateLocationPointUsage(LocationPoint locationPoint) {
        // [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) {
        // [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 demonstrateAdvancedRoutingFeatures() {
        System.out.println("=== Advanced Routing Features ===");
 
        if (routeManager == null) {
            return;
        }
 
        // Create multiple routes with different graph tags
        String[] graphTags = {"main", "elevator", "stairs"};
 
        for (String tag : graphTags) {
            // [java_RouteManager_setGraphTag_2]
            // Set different graph tag for routing
            routeManager.setGraphTag(tag);
            // [java_RouteManager_setGraphTag_2]
 
            System.out.println("Routing with graph tag: " + tag);
 
            // Create test route
            Point startPoint = new Point(0.0, 0.0);
            Point endPoint = new Point(100.0, 100.0);
            LocationPoint startLocationPoint = new LocationPoint(startPoint, 12345, 1);
            LocationPoint endLocationPoint = new LocationPoint(endPoint, 12345, 1);
 
            // [java_RouteManager_makeRoute_2]
            // Make route with specific graph tag
            RoutePath routePath = routeManager.makeRoute(startLocationPoint, endLocationPoint);
            // [java_RouteManager_makeRoute_2]
 
            System.out.println("Route with tag '" + tag + "' has length: " + routePath.getLength() + " meters");
        }
    }

    public void demonstrateRoutePlanningSimulation() {
        System.out.println("=== Route Planning Simulation ===");
 
        if (routeManager == null) {
            return;
        }
 
        // Create multiple target points
        List<LocationPoint> targets = new ArrayList<>();
        targets.add(new LocationPoint(new Point(50.0, 50.0), 12345, 1));
        targets.add(new LocationPoint(new Point(100.0, 100.0), 12345, 1));
        targets.add(new LocationPoint(new Point(150.0, 150.0), 12345, 1));
 
        // [java_RouteManager_setTarget_2]
        // Set first target
        routeManager.setTarget(targets.get(0));
        // [java_RouteManager_setTarget_2]
 
        System.out.println("Set target 1: " + targets.get(0));
 
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
 
        // [java_RouteManager_addTarget_2]
        // Add additional targets
        for (int i = 1; i < targets.size(); i++) {
            routeManager.addTarget(targets.get(i));
            System.out.println("Added target " + (i + 1) + ": " + targets.get(i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        // [java_RouteManager_addTarget_2]
 
        // [java_RouteManager_cancelTarget_2]
        // Cancel current target
        routeManager.cancelTarget();
        System.out.println("Cancelled current target");
        // [java_RouteManager_cancelTarget_2]
 
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
 
        // [java_RouteManager_clearTargets_2]
        // Clear all targets
        routeManager.clearTargets();
        System.out.println("Cleared all targets");
        // [java_RouteManager_clearTargets_2]
    }

    public void cleanup() {
        if (routeManager != null && routeListener != null) {
            // [java_RouteManager_removeRouteListener]
            // Remove route listener
            routeManager.removeRouteListener(routeListener);
            // [java_RouteManager_removeRouteListener]
        }
    }

    public void runExample() {
        System.out.println("=== RouteManager Example ===");
 
        demonstrateRouteManagerMethods();
        demonstrateRouteEventTypes();
        demonstrateTurnTypes();
        demonstrateAdvancedRoutingFeatures();
        demonstrateRoutePlanningSimulation();
 
        // 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) {
        RouteManagerExample example = new RouteManagerExample();
        example.runExample();
    }
}