route_manager_example.dart

Go to the documentation of this file.

import 'dart:async';
import 'dart:io';
import 'package:navigine_sdk/navigine_sdk.dart';

class RouteManagerExample {
  NavigineSdk? _sdk;
  LocationManager? _locationManager;
  NavigationManager? _navigationManager;
  RouteManager? _routeManager;
  RouteListener? _routeListener;
 
  RouteManagerExample() {
    _initializeSdk();
    _setupRouteListener();
  }

  void _initializeSdk() {
    try {
      // [dart_NavigineSdk_getInstance]
      // Get SDK instance
      _sdk = NavigineSdk.getInstance();
      // [dart_NavigineSdk_getInstance]
 
      // [dart_NavigineSdk_setUserHash]
      // Set user hash
      _sdk?.setUserHash("USER-HASH-HERE");
      // [dart_NavigineSdk_setUserHash]
 
      // [dart_NavigineSdk_setServer]
      // Set server URL (optional)
      _sdk?.setServer("https://custom.navigine.com");
      // [dart_NavigineSdk_setServer]
 
      // [dart_NavigineSdk_getLocationManager]
      // Get LocationManager for working with locations
      _locationManager = _sdk?.getLocationManager();
      // [dart_NavigineSdk_getLocationManager]
 
      // [dart_NavigineSdk_getNavigationManager]
      // Get NavigationManager for working with navigation
      _navigationManager = _sdk?.getNavigationManager(_locationManager!);
      // [dart_NavigineSdk_getNavigationManager]
 
      // [dart_NavigineSdk_getRouteManager]
      // Get RouteManager for working with routes
      _routeManager = _sdk?.getRouteManager(_locationManager!, _navigationManager!);
      // [dart_NavigineSdk_getRouteManager]
 
      if (_locationManager != null && _navigationManager != null && _routeManager != null) {
        print("LocationManager, NavigationManager and RouteManager successfully initialized");
      }
    } catch (e) {
      print("Error initializing SDK: $e");
    }
  }

  void _setupRouteListener() {
    _routeListener = RouteListener(
      // [dart_RouteListener_onPathsUpdated]
      onPathsUpdated: (List<RoutePath> paths) {
        print("Routes updated successfully");
        _demonstrateRoutePathUsage(paths);
      },
      // [dart_RouteListener_onPathsUpdated]
    );
  }

  void demonstrateRouteManagerMethods() {
    if (_routeManager == null) {
      print("RouteManager not initialized");
      return;
    }
 
    if (_routeListener == null) return;
 
    // [dart_RouteManager_addRouteListener]
    // Add route listener
    _routeManager!.addRouteListener(_routeListener!);
    // [dart_RouteManager_addRouteListener]
 
    // [dart_RouteManager_setGraphTag]
    // Set graph tag
    _routeManager!.setGraphTag("main");
    // [dart_RouteManager_setGraphTag]
 
    // [dart_RouteManager_getGraphTag]
    // Get current graph tag
    String currentGraphTag = _routeManager!.getGraphTag();
    print("Current graph tag: $currentGraphTag");
    // [dart_RouteManager_getGraphTag]
 
    // [dart_RouteManager_getGraphTags]
    // Get all graph tags
    List<String> graphTags = _routeManager!.getGraphTags();
    print("Available graph tags: $graphTags");
    // [dart_RouteManager_getGraphTags]
 
    // Create test points
    Point startPoint = Point(x: 10.0, y: 20.0);
    Point endPoint = Point(x: 50.0, y: 60.0);
    LocationPoint startLocationPoint = LocationPoint(point: startPoint, locationId: 12345, sublocationId: 1);
    LocationPoint endLocationPoint = LocationPoint(point: endPoint, locationId: 12345, sublocationId: 1);
 
    // [dart_RouteManager_makeRoute]
    // Make route from point to point
    RoutePath routePath = _routeManager!.makeRoute(startLocationPoint, endLocationPoint);
    print("Route created with length: ${routePath.length} meters");
    // [dart_RouteManager_makeRoute]
 
    // [dart_RouteManager_makeRoutes]
    // Make routes to multiple destinations
    List<LocationPoint> destinations = [
      LocationPoint(point: Point(x: 30.0, y: 40.0), locationId: 12345, sublocationId: 1),
      LocationPoint(point: Point(x: 70.0, y: 80.0), locationId: 12345, sublocationId: 1),
    ];
    List<RoutePath> routePaths = _routeManager!.makeRoutes(startLocationPoint, destinations);
    print("Created ${routePaths.length} routes");
    // [dart_RouteManager_makeRoutes]
 
    // [dart_RouteManager_setTarget]
    // Set target point
    _routeManager!.setTarget(endLocationPoint);
    // [dart_RouteManager_setTarget]
 
    // [dart_RouteManager_addTarget]
    // Add additional target point
    LocationPoint additionalTarget = LocationPoint(point: Point(x: 90.0, y: 100.0), locationId: 12345, sublocationId: 1);
    _routeManager!.addTarget(additionalTarget);
    // [dart_RouteManager_addTarget]
 
    // [dart_RouteManager_cancelTarget]
    // Cancel current target
    _routeManager!.cancelTarget();
    // [dart_RouteManager_cancelTarget]
 
    // [dart_RouteManager_clearTargets]
    // Clear all targets
    _routeManager!.clearTargets();
    // [dart_RouteManager_clearTargets]
  }

  void _demonstrateRoutePathUsage(List<RoutePath> paths) {
    for (int i = 0; i < paths.length; i++) {
      RoutePath path = paths[i];
      print("=== Route Path ${i + 1} ===");
 
      // [dart_RoutePath_getLength]
      // Get route length
      double length = path.length;
      print("Route length: $length meters");
      // [dart_RoutePath_getLength]
 
      // [dart_RoutePath_getWeight]
      // Get total route weight
      double weight = path.weight;
      print("Route weight: $weight");
      // [dart_RoutePath_getWeight]
 
      // [dart_RoutePath_getNodes]
      // Get route nodes
      List<RouteNode> nodes = path.nodes;
      print("Route has ${nodes.length} nodes");
      for (int j = 0; j < nodes.length; j++) {
        _demonstrateRouteNodeUsage(nodes[j]);
      }
      // [dart_RoutePath_getNodes]
 
      // [dart_RoutePath_head]
      // Get head of route (first 10 meters)
      RoutePath? headPath = path.head(10.0);
      if (headPath != null) {
        print("Head path length: ${headPath.length} meters");
      }
      // [dart_RoutePath_head]
 
      // [dart_RoutePath_tail]
      // Get tail of route (remaining after 10 meters)
      RoutePath? tailPath = path.tail(10.0);
      if (tailPath != null) {
        print("Tail path length: ${tailPath.length} meters");
      }
      // [dart_RoutePath_tail]
    }
  }
 
  void _demonstrateRouteNodeUsage(RouteNode node) {
    // [dart_RouteNode_getPoint]
    LocationPoint point = node.point;
    _demonstrateLocationPointUsage(point);
    // [dart_RouteNode_getPoint]
 
    // [dart_RouteNode_getWeight]
    double weight = node.weight;
    print("Node weight: $weight");
    // [dart_RouteNode_getWeight]
 
    // [dart_RouteNode_getDistance]
    double distance = node.distance;
    print("Node distance: $distance meters");
    // [dart_RouteNode_getDistance]
 
    // [dart_RouteNode_getEvents]
    List<RouteEvent> events = node.events;
    print("Node has ${events.length} events");
    for (final event in events) {
      _demonstrateRouteEventUsage(event);
    }
    // [dart_RouteNode_getEvents]
  }

  void _demonstrateRouteEventUsage(RouteEvent event) {
    // [dart_RouteEvent_getType]
    // Get event type
    RouteEventType type = event.type;
    print("Event type: $type");
    // [dart_RouteEvent_getType]
 
    // [dart_RouteEvent_getTurnEvent]
    TurnEvent? turnEvent = event.turnEvent;
    if (turnEvent != null) {
      _demonstrateTurnEventUsage(turnEvent);
    }
    // [dart_RouteEvent_getTurnEvent]
 
    // [dart_RouteEvent_getTransitionEntryEvent]
    TransitionEntryEvent? entryEvent = event.transitionEntryEvent;
    if (entryEvent != null) {
      _demonstrateTransitionEntryEventUsage(entryEvent);
    }
    // [dart_RouteEvent_getTransitionEntryEvent]
 
    // [dart_RouteEvent_getTransitionExitEvent]
    TransitionExitEvent? exitEvent = event.transitionExitEvent;
    if (exitEvent != null) {
      _demonstrateTransitionExitEventUsage(exitEvent);
    }
    // [dart_RouteEvent_getTransitionExitEvent]
 
    // [dart_RouteEvent_getTargetReachedEvent]
    TargetReachedEvent? reachedEvent = event.targetReachedEvent;
    if (reachedEvent != null) {
      _demonstrateTargetReachedEventUsage(reachedEvent);
    }
    // [dart_RouteEvent_getTargetReachedEvent]
  }

  void demonstrateRouteEventTypes() {
    // [dart_RouteEventType_values]
    // Get all route event type values
    print("Available route event types:");
    print("  - RouteEventType.TURN_LEFT: ${RouteEventType.TURN_LEFT}");
    print("  - RouteEventType.TURN_RIGHT: ${RouteEventType.TURN_RIGHT}");
    print("  - RouteEventType.TRANSITION: ${RouteEventType.TRANSITION}");
    // [dart_RouteEventType_values]
  }
 
  void demonstrateTurnTypes() {
    // [dart_TurnType_values]
    print("Available turn types:");
    for (final type in TurnType.values) {
      print("  - $type");
    }
    // [dart_TurnType_values]
  }
 
  void _demonstrateTurnEventUsage(TurnEvent event) {
    // [dart_TurnEvent_getType]
    TurnType type = event.type;
    print("Turn type: $type");
    // [dart_TurnEvent_getType]
 
    // [dart_TurnEvent_getAngle]
    int angle = event.angle;
    print("Turn angle: $angle");
    // [dart_TurnEvent_getAngle]
  }
 
  void _demonstrateTransitionEntryEventUsage(TransitionEntryEvent event) {
    // [dart_TransitionEntryEvent_getFrom]
    int from = event.from;
    print("Transition entry from: $from");
    // [dart_TransitionEntryEvent_getFrom]
 
    // [dart_TransitionEntryEvent_getTo]
    int to = event.to;
    print("Transition entry to: $to");
    // [dart_TransitionEntryEvent_getTo]
  }
 
  void _demonstrateTransitionExitEventUsage(TransitionExitEvent event) {
    // [dart_TransitionExitEvent_getFrom]
    int from = event.from;
    print("Transition exit from: $from");
    // [dart_TransitionExitEvent_getFrom]
 
    // [dart_TransitionExitEvent_getTo]
    int to = event.to;
    print("Transition exit to: $to");
    // [dart_TransitionExitEvent_getTo]
  }
 
  void _demonstrateTargetReachedEventUsage(TargetReachedEvent event) {
    // [dart_TargetReachedEvent_getIndex]
    int index = event.index;
    print("Reached target index: $index");
    // [dart_TargetReachedEvent_getIndex]
 
    // [dart_TargetReachedEvent_getPoint]
    LocationPoint point = event.point;
    _demonstrateLocationPointUsage(point);
    // [dart_TargetReachedEvent_getPoint]
  }

  void _demonstrateLocationPointUsage(LocationPoint locationPoint) {
    // [dart_LocationPoint_getPoint]
    // Get point coordinates
    Point? point = locationPoint.point;
    if (point != null) {
      _demonstratePointUsage(point);
    }
    // [dart_LocationPoint_getPoint]
 
    // [dart_LocationPoint_getLocationId]
    // Get location ID
    int locationId = locationPoint.locationId;
    print("Location ID: $locationId");
    // [dart_LocationPoint_getLocationId]
 
    // [dart_LocationPoint_getSublocationId]
    // Get sublocation ID
    int sublocationId = locationPoint.sublocationId;
    print("Sublocation ID: $sublocationId");
    // [dart_LocationPoint_getSublocationId]
 
    // [dart_LocationPoint_constructor]
    // Create new LocationPoint
    Point newPoint = Point(x: 15.0, y: 25.0);
    LocationPoint newLocationPoint = LocationPoint(point: newPoint, locationId: locationId, sublocationId: sublocationId);
    print("Created new LocationPoint: $newLocationPoint");
    // [dart_LocationPoint_constructor]
  }

  void _demonstratePointUsage(Point point) {
    // [dart_Point_getX]
    // Get X coordinate
    double x = point.x;
    print("Point X: $x");
    // [dart_Point_getX]
 
    // [dart_Point_getY]
    // Get Y coordinate
    double y = point.y;
    print("Point Y: $y");
    // [dart_Point_getY]
 
    // [dart_Point_constructor]
    // Create new Point
    Point newPoint = Point(x: x, y: y);
    print("Created new Point: $newPoint");
    // [dart_Point_constructor]
  }

  void demonstrateAdvancedRoutingFeatures() {
    print("=== Advanced Routing Features ===");
 
    if (_routeManager == null) {
      return;
    }
 
    // Create multiple routes with different graph tags
    List<String> graphTags = ["main", "elevator", "stairs"];
 
    for (String tag in graphTags) {
      // [dart_RouteManager_setGraphTag_2]
      // Set different graph tag for routing
      _routeManager!.setGraphTag(tag);
      // [dart_RouteManager_setGraphTag_2]
 
      print("Routing with graph tag: $tag");
 
      // Create test route
      Point startPoint = Point(x: 0.0, y: 0.0);
      Point endPoint = Point(x: 100.0, y: 100.0);
      LocationPoint startLocationPoint = LocationPoint(point: startPoint, locationId: 12345, sublocationId: 1);
      LocationPoint endLocationPoint = LocationPoint(point: endPoint, locationId: 12345, sublocationId: 1);
 
      // [dart_RouteManager_makeRoute_2]
      // Make route with specific graph tag
      RoutePath routePath = _routeManager!.makeRoute(startLocationPoint, endLocationPoint);
      // [dart_RouteManager_makeRoute_2]
 
      print("Route with tag '$tag' has length: ${routePath.length} meters");
    }
  }

  Future<void> demonstrateRoutePlanningSimulation() async {
    print("=== Route Planning Simulation ===");
 
    if (_routeManager == null) {
      return;
    }
 
    // Create multiple target points
    List<LocationPoint> targets = [
      LocationPoint(point: Point(x: 50.0, y: 50.0), locationId: 12345, sublocationId: 1),
      LocationPoint(point: Point(x: 100.0, y: 100.0), locationId: 12345, sublocationId: 1),
      LocationPoint(point: Point(x: 150.0, y: 150.0), locationId: 12345, sublocationId: 1),
    ];
 
    // [dart_RouteManager_setTarget_2]
    // Set first target
    _routeManager!.setTarget(targets[0]);
    // [dart_RouteManager_setTarget_2]
 
    print("Set target 1: ${targets[0]}");
    await Future.delayed(Duration(seconds: 1));
 
    // [dart_RouteManager_addTarget_2]
    // Add additional targets
    for (int i = 1; i < targets.length; i++) {
      _routeManager!.addTarget(targets[i]);
      print("Added target ${i + 1}: ${targets[i]}");
      await Future.delayed(Duration(seconds: 1));
    }
    // [dart_RouteManager_addTarget_2]
 
    // [dart_RouteManager_cancelTarget_2]
    // Cancel current target
    _routeManager!.cancelTarget();
    print("Cancelled current target");
    // [dart_RouteManager_cancelTarget_2]
 
    await Future.delayed(Duration(seconds: 1));
 
    // [dart_RouteManager_clearTargets_2]
    // Clear all targets
    _routeManager!.clearTargets();
    print("Cleared all targets");
    // [dart_RouteManager_clearTargets_2]
  }

  void cleanup() {
    if (_routeManager != null && _routeListener != null) {
      // [dart_RouteManager_removeRouteListener]
      // Remove route listener
      _routeManager!.removeRouteListener(_routeListener!);
      // [dart_RouteManager_removeRouteListener]
    }
  }

  Future<void> runExample() async {
    print("=== RouteManager Example ===");
 
    demonstrateRouteManagerMethods();
    demonstrateRouteEventTypes();
    demonstrateTurnTypes();
    demonstrateAdvancedRoutingFeatures();
    await demonstrateRoutePlanningSimulation();
 
    // Wait a bit for route updates
    await Future.delayed(Duration(seconds: 3));
 
    cleanup();
    print("=== Example completed ===");
  }
}

Future<void> main() async {
  RouteManagerExample example = RouteManagerExample();
  await example.runExample();
}