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_getPoints]
            // Get route points
            List<LocationPoint> points = path.getPoints();
            System.out.println("Route has " + points.size() + " points");
            for (int j = 0; j < points.size(); j++) {
                demonstrateLocationPointUsage(points.get(j));
            }
            // [java_RoutePath_getPoints]
 
            // [java_RoutePath_getEvents]
            // Get route events
            List<RouteEvent> events = path.getEvents();
            System.out.println("Route has " + events.size() + " events");
            for (int j = 0; j < events.size(); j++) {
                demonstrateRouteEventUsage(events.get(j));
            }
            // [java_RoutePath_getEvents]
 
            // [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 demonstrateRouteEventUsage(RouteEvent event) {
        // [java_RouteEvent_getType]
        // Get event type
        RouteEventType type = event.getType();
        System.out.println("Event type: " + type);
        // [java_RouteEvent_getType]
 
        // [java_RouteEvent_getValue]
        // Get event value (angle for turns, sublocation ID for transitions)
        int value = event.getValue();
        System.out.println("Event value: " + value);
        // [java_RouteEvent_getValue]
 
        // [java_RouteEvent_getDistance]
        // Get distance from route start
        double distance = event.getDistance();
        System.out.println("Event distance: " + distance + " meters");
        // [java_RouteEvent_getDistance]
 
        // [java_RouteEvent_constructor]
        // Create new RouteEvent
        RouteEvent newEvent = new RouteEvent(type, value, distance);
        System.out.println("Created new RouteEvent: " + newEvent);
        // [java_RouteEvent_constructor]
    }

    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 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();
        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();
    }
}