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_getPoints]
      // Get route points
      List<LocationPoint> points = path.points;
      print("Route has ${points.length} points");
      for (int j = 0; j < points.length; j++) {
        _demonstrateLocationPointUsage(points[j]);
      }
      // [dart_RoutePath_getPoints]
 
      // [dart_RoutePath_getEvents]
      // Get route events
      List<RouteEvent> events = path.events;
      print("Route has ${events.length} events");
      for (int j = 0; j < events.length; j++) {
        _demonstrateRouteEventUsage(events[j]);
      }
      // [dart_RoutePath_getEvents]
 
      // [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 _demonstrateRouteEventUsage(RouteEvent event) {
    // [dart_RouteEvent_getType]
    // Get event type
    RouteEventType type = event.type;
    print("Event type: $type");
    // [dart_RouteEvent_getType]
 
    // [dart_RouteEvent_getValue]
    // Get event value (angle for turns, sublocation ID for transitions)
    int value = event.value;
    print("Event value: $value");
    // [dart_RouteEvent_getValue]
 
    // [dart_RouteEvent_getDistance]
    // Get distance from route start
    double distance = event.distance;
    print("Event distance: $distance meters");
    // [dart_RouteEvent_getDistance]
 
    // [dart_RouteEvent_constructor]
    // Create new RouteEvent
    RouteEvent newEvent = RouteEvent(type, value, distance);
    print("Created new RouteEvent: $newEvent");
    // [dart_RouteEvent_constructor]
  }

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