async_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 AsyncRouteManagerExample {
  NavigineSdk? _sdk;
  LocationManager? _locationManager;
  NavigationManager? _navigationManager;
  AsyncRouteManager? _asyncRouteManager;
  AsyncRouteListener? _asyncRouteListener;
  RouteSession? _currentSession;
 
  AsyncRouteManagerExample() {
    _initializeSdk();
    _setupAsyncRouteListener();
  }

  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_getAsyncRouteManager]
      // Get AsyncRouteManager for working with async routes
      _asyncRouteManager = _sdk?.getAsyncRouteManager(
        _locationManager!,
        _navigationManager!,
      );
      // [dart_NavigineSdk_getAsyncRouteManager]
 
      if (_locationManager != null &&
          _navigationManager != null &&
          _asyncRouteManager != null) {
        print(
          "LocationManager, NavigationManager and AsyncRouteManager successfully initialized",
        );
      }
    } catch (e) {
      print("Error initializing SDK: $e");
    }
  }

  void _setupAsyncRouteListener() {
    _asyncRouteListener = AsyncRouteListener(
      // [dart_AsyncRouteListener_onRouteChanged]
      onRouteChanged: (RouteStatus status, RoutePath currentPath) {
        print("Route changed with status: $status");
        if (status == RouteStatus.newRoute && currentPath != null) {
          _demonstrateRoutePathUsage(currentPath);
        } else {
          print("Route not ready, status: $status");
        }
      },
      // [dart_AsyncRouteListener_onRouteChanged]
 
      // [dart_AsyncRouteListener_onRouteAdvanced]
      onRouteAdvanced: (double distance, LocationPoint point) {
        print("Route advanced: $distance meters");
        _demonstrateLocationPointUsage(point);
      },
      // [dart_AsyncRouteListener_onRouteAdvanced]
    );
  }

  void demonstrateAsyncRouteManagerMethods() {
    if (_asyncRouteManager == null) {
      print("AsyncRouteManager not initialized");
      return;
    }
 
    // Create test destination point
    Point destinationPoint = Point(x: 100.0, y: 100.0);
    LocationPoint destinationLocationPoint = LocationPoint(
      point: destinationPoint,
      locationId: 12345,
      sublocationId: 1,
    );
 
    // Create route options
    RouteOptions routeOptions = RouteOptions(2.0, 5.0, 2.0);
 
    // [dart_AsyncRouteManager_createRouteSession]
    // Create route session with default graph tag
    RouteSession session = _asyncRouteManager!.createRouteSession(
      destinationLocationPoint,
      routeOptions,
    );
    print("Created route session with default graph tag");
    // [dart_AsyncRouteManager_createRouteSession]
 
    // [dart_AsyncRouteManager_createRouteSessionWithTag]
    // Create route session with specific graph tag
    RouteSession sessionWithTag = _asyncRouteManager!.createRouteSessionWithTag(
      destinationLocationPoint,
      routeOptions,
      "main",
    );
    print("Created route session with 'main' graph tag");
    // [dart_AsyncRouteManager_createRouteSessionWithTag]
 
    // Store session for later use
    _currentSession = session;
 
    // Add listener to session
    if (_asyncRouteListener != null) {
      // [dart_RouteSession_addRouteListener]
      // Add route listener to session
      session.addRouteListener(_asyncRouteListener!);
      // [dart_RouteSession_addRouteListener]
    }
  }

  void _demonstrateRoutePathUsage(RoutePath routePath) {
    if (routePath == null) {
      print("RoutePath is null");
      return;
    }
 
    // [dart_RoutePath_getLength]
    // Get route length
    double length = routePath.length;
    print("Route length: $length meters");
    // [dart_RoutePath_getLength]
 
    // [dart_RoutePath_getWeight]
    // Get total route weight
    double weight = routePath.weight;
    print("Route weight: $weight");
    // [dart_RoutePath_getWeight]
 
    // [dart_RoutePath_getNodes]
    // Get route nodes
    List<RouteNode> nodes = routePath.nodes;
    print("Number of route nodes: ${nodes.length}");
    for (int i = 0; i < nodes.length && i < 3; i++) {
      _demonstrateRouteNodeUsage(nodes[i]);
    }
    // [dart_RoutePath_getNodes]
 
    // [dart_RoutePath_head]
    // Get route head (first 10 meters)
    RoutePath? head = routePath.head(10.0);
    if (head != null) {
      print("Route head length: ${head.length} meters");
    }
    // [dart_RoutePath_head]
 
    // [dart_RoutePath_tail]
    // Get route tail (remaining after 10 meters)
    RoutePath? tail = routePath.tail(10.0);
    if (tail != null) {
      print("Route tail length: ${tail.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;
    for (final event in events) {
      _demonstrateRouteEventUsage(event);
    }
    // [dart_RouteNode_getEvents]
  }

  void _demonstrateRouteEventUsage(RouteEvent event) {
    if (event == null) {
      print("RouteEvent is null");
      return;
    }
 
    // [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_EVENT: ${RouteEventType.TURN_EVENT}");
    print("  - RouteEventType.TRANSITION_ENTRY_EVENT: ${RouteEventType.TRANSITION_ENTRY_EVENT}");
    print("  - RouteEventType.TRANSITION_EXIT_EVENT: ${RouteEventType.TRANSITION_EXIT_EVENT}");
    print("  - RouteEventType.TARGET_REACHED_EVENT: ${RouteEventType.TARGET_REACHED_EVENT}");
    // [dart_RouteEventType_values]
  }
 
  void demonstrateTurnTypes() {
    // [dart_TurnType_values]
    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) {
    if (locationPoint == null) {
      print("LocationPoint is null");
      return;
    }
 
    // [dart_LocationPoint_getPoint]
    // Get point coordinates
    Point point = locationPoint.point;
    print("Location point: (${point.x}, ${point.y})");
    // [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 location point
    Point newPoint = Point(x: 25.0, y: 35.0);
    LocationPoint newLocationPoint = LocationPoint(
      point: newPoint,
      locationId: 12345,
      sublocationId: 2,
    );
    print(
      "Created new location point: ${newLocationPoint.point.x}, ${newLocationPoint.point.y}",
    );
    // [dart_LocationPoint_constructor]
  }

  void _demonstratePointUsage(Point point) {
    if (point == null) {
      print("Point is null");
      return;
    }
 
    // [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: 15.0, y: 25.0);
    print("Created new point: (${newPoint.x}, ${newPoint.y})");
    // [dart_Point_constructor]
  }

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

  Future<void> demonstrateAdvancedAsyncRoutingFeatures() async {
    print("=== Advanced Async Routing Features ===");
 
    if (_asyncRouteManager == null) {
      return;
    }
 
    // Create multiple destination points
    List<LocationPoint> destinations = [
      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,
      ),
    ];
 
    // Create different route options for each destination
    List<RouteOptions> optionsList = [
      RouteOptions(2.0, 5.0, 2.0),
      RouteOptions(3.0, 7.0, 1.5),
      RouteOptions(1.0, 3.0, 2.5),
    ];
 
    // Create sessions for each destination
    List<RouteSession> sessions = [];
    for (int i = 0; i < destinations.length; i++) {
      RouteSession session = _asyncRouteManager!.createRouteSession(
        destinations[i],
        optionsList[i],
      );
      sessions.add(session);
      print(
        "Created session ${i + 1} for destination: ${destinations[i].point.x}, ${destinations[i].point.y}",
      );
 
      if (_asyncRouteListener != null) {
        session.addRouteListener(_asyncRouteListener!);
      }
 
      await Future.delayed(Duration(seconds: 1));
    }
 
    // Wait for route updates
    await Future.delayed(Duration(seconds: 3));
 
    // Cancel all sessions
    for (int i = 0; i < sessions.length; i++) {
      // [dart_AsyncRouteManager_cancelRouteSession]
      // Cancel route session
      _asyncRouteManager!.cancelRouteSession(sessions[i]);
      print("Cancelled session ${i + 1}");
      // [dart_AsyncRouteManager_cancelRouteSession]
 
      await Future.delayed(Duration(seconds: 1));
    }
  }

  void demonstrateRouteStatusUsage() {
    print("=== RouteStatus Enum Usage ===");
 
    // [dart_RouteStatus_values]
    // Demonstrate all RouteStatus values
    print("Available RouteStatus values:");
    List<RouteStatus> allStatuses = [
      RouteStatus.missingGraph,
      RouteStatus.missingPosition,
      RouteStatus.missingRoute,
      RouteStatus.missingProjection,
      RouteStatus.newRoute,
    ];
    for (RouteStatus status in allStatuses) {
      print("  - $status: ${status.toString()}");
    }
 
    // Demonstrate status checking
    RouteStatus testStatus = RouteStatus.newRoute;
    switch (testStatus) {
      case RouteStatus.newRoute:
        print("Router is ready for navigation");
        break;
      case RouteStatus.missingGraph:
        print("Router is missing the route graph");
        break;
      case RouteStatus.missingPosition:
        print("Router is missing the current position");
        break;
      case RouteStatus.missingProjection:
        print("Current position is off the route graph");
        break;
      case RouteStatus.missingRoute:
        print("Router unable to find the route to the destination point");
        break;
    }
    // [dart_RouteStatus_values]
  }

  void demonstrateRouteSessionManagement() {
    print("=== Route Session Management ===");
 
    if (_asyncRouteManager == null || _asyncRouteListener == null) {
      return;
    }
 
    // Create test destination
    Point destinationPoint = Point(x: 75.0, y: 75.0);
    LocationPoint destinationLocationPoint = LocationPoint(
      point: destinationPoint,
      locationId: 12345,
      sublocationId: 1,
    );
    RouteOptions routeOptions = RouteOptions(2.0, 5.0, 2.0);
 
    // Create session with default tag
    RouteSession defaultSession = _asyncRouteManager!.createRouteSession(
      destinationLocationPoint,
      routeOptions,
    );
    print("Created session with default tag");
 
    // Create session with specific tag
    RouteSession taggedSession = _asyncRouteManager!.createRouteSessionWithTag(
      destinationLocationPoint,
      routeOptions,
      "elevator",
    );
    print("Created session with 'elevator' tag");
 
    // Add listeners to both sessions
    defaultSession.addRouteListener(_asyncRouteListener!);
    taggedSession.addRouteListener(_asyncRouteListener!);
 
    // Simulate some time passing
    Future.delayed(Duration(seconds: 2), () {
      // Remove listeners
      // [dart_RouteSession_removeRouteListener1]
      // Remove route listener from session
      defaultSession.removeRouteListener(_asyncRouteListener!);
      taggedSession.removeRouteListener(_asyncRouteListener!);
      print("Removed listeners from sessions");
      // [dart_RouteSession_removeRouteListener1]
 
      // Cancel sessions
      _asyncRouteManager!.cancelRouteSession(defaultSession);
      _asyncRouteManager!.cancelRouteSession(taggedSession);
      print("Cancelled both sessions");
    });
  }

  void cleanup() {
    if (_currentSession != null && _asyncRouteListener != null) {
      // [dart_RouteSession_removeRouteListener]
      // Remove route listener
      _currentSession!.removeRouteListener(_asyncRouteListener!);
      // [dart_RouteSession_removeRouteListener]
    }
 
    if (_asyncRouteManager != null && _currentSession != null) {
      // [dart_AsyncRouteManager_cancelRouteSession_1]
      // Cancel route session
      _asyncRouteManager!.cancelRouteSession(_currentSession!);
      // [dart_AsyncRouteManager_cancelRouteSession_1]
    }
  }

  Future<void> runExample() async {
    print("=== AsyncRouteManager Example ===");
 
    demonstrateAsyncRouteManagerMethods();
    demonstrateRouteEventTypes();
    demonstrateTurnTypes();
    demonstrateRouteOptions();
    demonstrateRouteStatusUsage();
    demonstrateRouteSessionManagement();
    await demonstrateAdvancedAsyncRoutingFeatures();
 
    // Wait a bit for route updates
    await Future.delayed(Duration(seconds: 3));
 
    cleanup();
    print("=== Example completed ===");
  }
}

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