AsyncRouteManagerExample.m

Go to the documentation of this file.

#import <Foundation/Foundation.h>
#import <NavigineSDK/NavigineSDK.h>

@interface AsyncRouteManagerExample : NSObject <NCAsyncRouteListener>
 
@property (nonatomic, strong) NCNavigineSdk *sdk;
@property (nonatomic, strong) NCLocationManager *locationManager;
@property (nonatomic, strong) NCNavigationManager *navigationManager;
@property (nonatomic, strong) NCAsyncRouteManager *asyncRouteManager;
@property (nonatomic, strong) NCRouteSession *currentSession;
 
- (void)initializeSdk;
- (void)setupAsyncRouteListener;
- (void)demonstrateAsyncRouteManagerMethods;
- (void)demonstrateRoutePathUsage:(NCRoutePath *)routePath;
- (void)demonstrateRouteNodeUsage:(NCRouteNode *)node;
- (void)demonstrateRouteEventUsage:(NCRouteEvent *)event;
- (void)demonstrateRouteEventTypes;
- (void)demonstrateTurnTypes;
- (void)demonstrateTurnEventUsage:(NCTurnEvent *)event;
- (void)demonstrateTransitionEntryEventUsage:(NCTransitionEntryEvent *)event;
- (void)demonstrateTransitionExitEventUsage:(NCTransitionExitEvent *)event;
- (void)demonstrateTargetReachedEventUsage:(NCTargetReachedEvent *)event;
- (void)demonstrateLocationPointUsage:(NCLocationPoint *)locationPoint;
- (void)demonstratePointUsage:(NCPoint *)point;
- (void)demonstrateRouteOptions;
- (void)demonstrateAdvancedAsyncRoutingFeatures;
- (void)demonstrateRouteSessionManagement;
- (void)cleanup;
- (void)runExample;
 
@end
 
@implementation AsyncRouteManagerExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self initializeSdk];
        [self setupAsyncRouteListener];
    }
    return self;
}
 
- (void)initializeSdk {
    @try {
        // [objc_NavigineSdk_getInstance]
        // Get SDK instance
        self.sdk = [NCNavigineSdk getInstance];
        // [objc_NavigineSdk_getInstance]
 
        // [objc_NavigineSdk_setUserHash]
        // Set user hash
        [self.sdk setUserHash:@"USER-HASH-HERE"];
        // [objc_NavigineSdk_setUserHash]
 
        // [objc_NavigineSdk_setServer]
        // Set server URL (optional)
        [self.sdk setServer:@"https://custom.navigine.com"];
        // [objc_NavigineSdk_setServer]
 
        // [objc_NavigineSdk_getLocationManager]
        // Get LocationManager for working with locations
        self.locationManager = [self.sdk getLocationManager];
        // [objc_NavigineSdk_getLocationManager]
 
        // [objc_NavigineSdk_getNavigationManager]
        // Get NavigationManager for working with navigation
        self.navigationManager = [self.sdk getNavigationManager:self.locationManager];
        // [objc_NavigineSdk_getNavigationManager]
 
        // [objc_NavigineSdk_getAsyncRouteManager]
        // Get AsyncRouteManager for working with async routes
        self.asyncRouteManager = [self.sdk getAsyncRouteManager:self.locationManager navigationManager:self.navigationManager];
        // [objc_NavigineSdk_getAsyncRouteManager]
 
        if (self.locationManager != nil && self.navigationManager != nil && self.asyncRouteManager != nil) {
            NSLog(@"LocationManager, NavigationManager and AsyncRouteManager successfully initialized");
        }
    } @catch (NSException *exception) {
        NSLog(@"Error initializing SDK: %@", exception.reason);
    }
}

- (void)setupAsyncRouteListener {
    // AsyncRouteListener is implemented via protocol
    // No additional setup needed for Objective-C
}

- (void)demonstrateAsyncRouteManagerMethods {
    if (self.asyncRouteManager == nil) {
        NSLog(@"AsyncRouteManager not initialized");
        return;
    }
 
    // Create test destination point
    NCPoint *destinationPoint = [[NCPoint alloc] initWithX:100.0 y:100.0];
    NCLocationPoint *destinationLocationPoint = [[NCLocationPoint alloc] initWithPoint:destinationPoint locationId:12345 sublocationId:1];
 
    // Create route options
    NCRouteOptions *routeOptions = [[NCRouteOptions alloc] initWithSmoothRadius:2.0 maxProjectionDistance:5.0 maxAdvance:2.0];
 
    // [objc_AsyncRouteManager_createRouteSession]
    // Create route session with default graph tag
    NCRouteSession *session = [self.asyncRouteManager createRouteSession:destinationLocationPoint routeOptions:routeOptions];
    NSLog(@"Created route session with default graph tag");
    // [objc_AsyncRouteManager_createRouteSession]
 
    // [objc_AsyncRouteManager_createRouteSessionWithTag]
    // Create route session with specific graph tag
    NCRouteSession *sessionWithTag = [self.asyncRouteManager createRouteSessionWithTag:destinationLocationPoint routeOptions:routeOptions tag:@"main"];
    NSLog(@"Created route session with 'main' graph tag");
    // [objc_AsyncRouteManager_createRouteSessionWithTag]
 
    // Store session for later use
    self.currentSession = session;
 
    // Add listener to session
    // [objc_RouteSession_addRouteListener]
    // Add route listener to session
    [session addRouteListener:self];
    // [objc_RouteSession_addRouteListener]
}

- (void)demonstrateRoutePathUsage:(NCRoutePath *)routePath {
    if (routePath == nil) {
        NSLog(@"RoutePath is null");
        return;
    }
 
    // [objc_RoutePath_getLength]
    // Get route length
    double length = [routePath getLength];
    NSLog(@"Route length: %f meters", length);
    // [objc_RoutePath_getLength]
 
    // [objc_RoutePath_getWeight]
    // Get total route weight
    double weight = [routePath getWeight];
    NSLog(@"Route weight: %f", weight);
    // [objc_RoutePath_getWeight]
 
    // [objc_RoutePath_getNodes]
    // Get route nodes
    NSArray<NCRouteNode *> *nodes = [routePath getNodes];
    NSLog(@"Number of route nodes: %lu", (unsigned long)nodes.count);
    for (int i = 0; i < nodes.count && i < 3; i++) {
        [self demonstrateRouteNodeUsage:nodes[i]];
    }
    // [objc_RoutePath_getNodes]
 
    // [objc_RoutePath_head]
    // Get route head (first 10 meters)
    NCRoutePath *head = [routePath head:10.0];
    if (head != nil) {
        NSLog(@"Route head length: %f meters", [head getLength]);
    }
    // [objc_RoutePath_head]
 
    // [objc_RoutePath_tail]
    // Get route tail (remaining after 10 meters)
    NCRoutePath *tail = [routePath tail:10.0];
    if (tail != nil) {
        NSLog(@"Route tail length: %f meters", [tail getLength]);
    }
    // [objc_RoutePath_tail]
}
 
- (void)demonstrateRouteNodeUsage:(NCRouteNode *)node {
    // [objc_RouteNode_getPoint]
    NCLocationPoint *point = [node getPoint];
    [self demonstrateLocationPointUsage:point];
    // [objc_RouteNode_getPoint]
 
    // [objc_RouteNode_getWeight]
    float weight = [node getWeight];
    NSLog(@"Node weight: %f", weight);
    // [objc_RouteNode_getWeight]
 
    // [objc_RouteNode_getDistance]
    float distance = [node getDistance];
    NSLog(@"Node distance: %f meters", distance);
    // [objc_RouteNode_getDistance]
 
    // [objc_RouteNode_getEvents]
    NSArray<NCRouteEvent *> *events = [node getEvents];
    for (NCRouteEvent *event in events) {
        [self demonstrateRouteEventUsage:event];
    }
    // [objc_RouteNode_getEvents]
}

- (void)demonstrateRouteEventUsage:(NCRouteEvent *)event {
    if (event == nil) {
        NSLog(@"RouteEvent is null");
        return;
    }
 
    // [objc_RouteEvent_getType]
    // Get event type
    NCRouteEventType type = [event getType];
    NSLog(@"Event type: %ld", (long)type);
    // [objc_RouteEvent_getType]
 
    // [objc_RouteEvent_getTurnEvent]
    NCTurnEvent *turnEvent = [event getTurnEvent];
    if (turnEvent != nil) {
        [self demonstrateTurnEventUsage:turnEvent];
    }
    // [objc_RouteEvent_getTurnEvent]
 
    // [objc_RouteEvent_getTransitionEntryEvent]
    NCTransitionEntryEvent *entryEvent = [event getTransitionEntryEvent];
    if (entryEvent != nil) {
        [self demonstrateTransitionEntryEventUsage:entryEvent];
    }
    // [objc_RouteEvent_getTransitionEntryEvent]
 
    // [objc_RouteEvent_getTransitionExitEvent]
    NCTransitionExitEvent *exitEvent = [event getTransitionExitEvent];
    if (exitEvent != nil) {
        [self demonstrateTransitionExitEventUsage:exitEvent];
    }
    // [objc_RouteEvent_getTransitionExitEvent]
 
    // [objc_RouteEvent_getTargetReachedEvent]
    NCTargetReachedEvent *targetEvent = [event getTargetReachedEvent];
    if (targetEvent != nil) {
        [self demonstrateTargetReachedEventUsage:targetEvent];
    }
    // [objc_RouteEvent_getTargetReachedEvent]
}

- (void)demonstrateRouteEventTypes {
    // [objc_RouteEventType_values]
    // Get all route event type values
    NSArray<NSNumber *> *types = @[
        @(NCRouteEventTypeTurnEvent),
        @(NCRouteEventTypeTransitionEntryEvent),
        @(NCRouteEventTypeTransitionExitEvent),
        @(NCRouteEventTypeTargetReachedEvent)
    ];
    NSLog(@"Available route event types:");
    for (NSNumber *type in types) {
        NSLog(@"  - %ld", (long)[type integerValue]);
    }
    // [objc_RouteEventType_values]
}
 
- (void)demonstrateTurnTypes {
    // [objc_TurnType_values]
    NSArray<NSNumber *> *types = @[
        @(NCTurnTypeLeftSlight),
        @(NCTurnTypeLeftNormal),
        @(NCTurnTypeLeftSharp),
        @(NCTurnTypeRightSlight),
        @(NCTurnTypeRightNormal),
        @(NCTurnTypeRightSharp),
        @(NCTurnTypeComplete)
    ];
    for (NSNumber *type in types) {
        NSLog(@"  - %ld", (long)[type integerValue]);
    }
    // [objc_TurnType_values]
}
 
- (void)demonstrateTurnEventUsage:(NCTurnEvent *)event {
    // [objc_TurnEvent_getType]
    NCTurnType type = [event getType];
    NSLog(@"Turn type: %ld", (long)type);
    // [objc_TurnEvent_getType]
 
    // [objc_TurnEvent_getAngle]
    int32_t angle = [event getAngle];
    NSLog(@"Turn angle: %d", angle);
    // [objc_TurnEvent_getAngle]
}
 
- (void)demonstrateTransitionEntryEventUsage:(NCTransitionEntryEvent *)event {
    // [objc_TransitionEntryEvent_getFrom]
    int64_t from = [event getFrom];
    NSLog(@"Transition entry from: %lld", from);
    // [objc_TransitionEntryEvent_getFrom]
 
    // [objc_TransitionEntryEvent_getTo]
    int64_t to = [event getTo];
    NSLog(@"Transition entry to: %lld", to);
    // [objc_TransitionEntryEvent_getTo]
}
 
- (void)demonstrateTransitionExitEventUsage:(NCTransitionExitEvent *)event {
    // [objc_TransitionExitEvent_getFrom]
    int64_t from = [event getFrom];
    NSLog(@"Transition exit from: %lld", from);
    // [objc_TransitionExitEvent_getFrom]
 
    // [objc_TransitionExitEvent_getTo]
    int64_t to = [event getTo];
    NSLog(@"Transition exit to: %lld", to);
    // [objc_TransitionExitEvent_getTo]
}
 
- (void)demonstrateTargetReachedEventUsage:(NCTargetReachedEvent *)event {
    // [objc_TargetReachedEvent_getIndex]
    int64_t index = [event getIndex];
    NSLog(@"Reached target index: %lld", index);
    // [objc_TargetReachedEvent_getIndex]
 
    // [objc_TargetReachedEvent_getPoint]
    NCLocationPoint *point = [event getPoint];
    [self demonstrateLocationPointUsage:point];
    // [objc_TargetReachedEvent_getPoint]
}

- (void)demonstrateLocationPointUsage:(NCLocationPoint *)locationPoint {
    if (locationPoint == nil) {
        NSLog(@"LocationPoint is null");
        return;
    }
 
    // [objc_LocationPoint_getPoint]
    // Get point coordinates
    NCPoint *point = [locationPoint getPoint];
    NSLog(@"Location point: (%f, %f)", [point getX], [point getY]);
    // [objc_LocationPoint_getPoint]
 
    // [objc_LocationPoint_getLocationId]
    // Get location ID
    int locationId = [locationPoint getLocationId];
    NSLog(@"Location ID: %d", locationId);
    // [objc_LocationPoint_getLocationId]
 
    // [objc_LocationPoint_getSublocationId]
    // Get sublocation ID
    int sublocationId = [locationPoint getSublocationId];
    NSLog(@"Sublocation ID: %d", sublocationId);
    // [objc_LocationPoint_getSublocationId]
 
    // [objc_LocationPoint_constructor]
    // Create new location point
    NCPoint *newPoint = [[NCPoint alloc] initWithX:25.0 y:35.0];
    NCLocationPoint *newLocationPoint = [[NCLocationPoint alloc] initWithPoint:newPoint locationId:12345 sublocationId:2];
    NSLog(@"Created new location point: %f, %f", [[newLocationPoint getPoint] getX], [[newLocationPoint getPoint] getY]);
    // [objc_LocationPoint_constructor]
}

- (void)demonstratePointUsage:(NCPoint *)point {
    if (point == nil) {
        NSLog(@"Point is null");
        return;
    }
 
    // [objc_Point_getX]
    // Get X coordinate
    double x = [point getX];
    NSLog(@"Point X: %f", x);
    // [objc_Point_getX]
 
    // [objc_Point_getY]
    // Get Y coordinate
    double y = [point getY];
    NSLog(@"Point Y: %f", y);
    // [objc_Point_getY]
 
    // [objc_Point_constructor]
    // Create new point
    NCPoint *newPoint = [[NCPoint alloc] initWithX:15.0 y:25.0];
    NSLog(@"Created new point: (%f, %f)", [newPoint getX], [newPoint getY]);
    // [objc_Point_constructor]
}

- (void)demonstrateRouteOptions {
    NSLog(@"=== Route Options ===");
 
    // [objc_RouteOptions_constructor]
    // Create route options with custom parameters
    NCRouteOptions *routeOptions = [[NCRouteOptions alloc] initWithSmoothRadius:3.0 maxProjectionDistance:7.0 maxAdvance:2.5];
    NSLog(@"Created route options with smoothRadius: %f, maxProjectionDistance: %f, maxAdvance: %f",
          [routeOptions getSmoothRadius], [routeOptions getMaxProjectionDistance], [routeOptions getMaxAdvance]);
    // [objc_RouteOptions_constructor]
 
    // Demonstrate different route options configurations
    NSArray<NCRouteOptions *> *optionsList = @[
        [[NCRouteOptions alloc] initWithSmoothRadius:0.0 maxProjectionDistance:5.0 maxAdvance:2.0],    // No smoothing
        [[NCRouteOptions alloc] initWithSmoothRadius:2.0 maxProjectionDistance:10.0 maxAdvance:1.0],   // High smoothing, high projection distance
        [[NCRouteOptions alloc] initWithSmoothRadius:1.0 maxProjectionDistance:3.0 maxAdvance:3.0],    // Low smoothing, low projection distance
    ];
 
    for (int i = 0; i < optionsList.count; i++) {
        NCRouteOptions *options = optionsList[i];
        NSLog(@"Options %d: smoothRadius=%f, maxProjectionDistance=%f, maxAdvance=%f",
              i + 1, [options getSmoothRadius], [options getMaxProjectionDistance], [options getMaxAdvance]);
    }
}

- (void)demonstrateAdvancedAsyncRoutingFeatures {
    NSLog(@"=== Advanced Async Routing Features ===");
 
    if (self.asyncRouteManager == nil) {
        return;
    }
 
    // Create multiple destination points
    NSArray<NCLocationPoint *> *destinations = @[
        [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:50.0 y:50.0] locationId:12345 sublocationId:1],
        [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:100.0 y:100.0] locationId:12345 sublocationId:1],
        [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:150.0 y:150.0] locationId:12345 sublocationId:1]
    ];
 
    // Create different route options for each destination
    NSArray<NCRouteOptions *> *optionsList = @[
        [[NCRouteOptions alloc] initWithSmoothRadius:2.0 maxProjectionDistance:5.0 maxAdvance:2.0],
        [[NCRouteOptions alloc] initWithSmoothRadius:3.0 maxProjectionDistance:7.0 maxAdvance:1.5],
        [[NCRouteOptions alloc] initWithSmoothRadius:1.0 maxProjectionDistance:3.0 maxAdvance:2.5],
    ];
 
    // Create sessions for each destination
    NSMutableArray<NCRouteSession *> *sessions = [NSMutableArray array];
    for (int i = 0; i < destinations.count; i++) {
        NCRouteSession *session = [self.asyncRouteManager createRouteSession:destinations[i] routeOptions:optionsList[i]];
        [sessions addObject:session];
        NSLog(@"Created session %d for destination: %f, %f",
              i + 1, [destinations[i].getPoint getX], [destinations[i].getPoint getY]);
 
        [session addRouteListener:self];
 
        [NSThread sleepForTimeInterval:1.0];
    }
 
    // Wait for route updates
    [NSThread sleepForTimeInterval:3.0];
 
    // Cancel all sessions
    for (int i = 0; i < sessions.count; i++) {
        // [objc_AsyncRouteManager_cancelRouteSession]
        // Cancel route session
        [self.asyncRouteManager cancelRouteSession:sessions[i]];
        NSLog(@"Cancelled session %d", i + 1);
        // [objc_AsyncRouteManager_cancelRouteSession]
 
        [NSThread sleepForTimeInterval:1.0];
    }
}

- (void)demonstrateRouteStatusUsage {
    NSLog(@"=== RouteStatus Enum Usage ===");
 
    // [objc_RouteStatus_values]
    // Demonstrate all RouteStatus values
    NSLog(@"Available RouteStatus values:");
    NSArray *allStatuses = @[@(NCRouteStatusMissingGraph), @(NCRouteStatusMissingPosition), @(NCRouteStatusMissingRoute), @(NCRouteStatusMissingProjection), @(NCRouteStatusNewRoute)];
    for (NSNumber *statusNumber in allStatuses) {
        NCRouteStatus status = [statusNumber integerValue];
        NSLog(@"  - %@: %@", @(status), @(status));
    }
 
    // Demonstrate status checking
    NCRouteStatus testStatus = NCRouteStatusNewRoute;
    switch (testStatus) {
        case NCRouteStatusNewRoute:
            NSLog(@"Router is ready for navigation");
            break;
        case NCRouteStatusMissingGraph:
            NSLog(@"Router is missing the route graph");
            break;
        case NCRouteStatusMissingPosition:
            NSLog(@"Router is missing the current position");
            break;
        case NCRouteStatusMissingProjection:
            NSLog(@"Current position is off the route graph");
            break;
        case NCRouteStatusMissingRoute:
            NSLog(@"Router unable to find the route to the destination point");
            break;
    }
    // [objc_RouteStatus_values]
}

- (void)demonstrateRouteSessionManagement {
    NSLog(@"=== Route Session Management ===");
 
    if (self.asyncRouteManager == nil) {
        return;
    }
 
    // Create test destination
    NCPoint *destinationPoint = [[NCPoint alloc] initWithX:75.0 y:75.0];
    NCLocationPoint *destinationLocationPoint = [[NCLocationPoint alloc] initWithPoint:destinationPoint locationId:12345 sublocationId:1];
    NCRouteOptions *routeOptions = [[NCRouteOptions alloc] initWithSmoothRadius:2.0 maxProjectionDistance:5.0 maxAdvance:2.0];
 
    // Create session with default tag
    NCRouteSession *defaultSession = [self.asyncRouteManager createRouteSession:destinationLocationPoint routeOptions:routeOptions];
    NSLog(@"Created session with default tag");
 
    // Create session with specific tag
    NCRouteSession *taggedSession = [self.asyncRouteManager createRouteSessionWithTag:destinationLocationPoint routeOptions:routeOptions tag:@"elevator"];
    NSLog(@"Created session with 'elevator' tag");
 
    // Add listeners to both sessions
    [defaultSession addRouteListener:self];
    [taggedSession addRouteListener:self];
 
    // Simulate some time passing
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // Remove listeners
        // [objc_RouteSession_removeRouteListener1]
        // Remove route listener from session
        [defaultSession removeRouteListener:self];
        [taggedSession removeRouteListener:self];
        NSLog(@"Removed listeners from sessions");
        // [objc_RouteSession_removeRouteListener1]
 
        // Cancel sessions
        [self.asyncRouteManager cancelRouteSession:defaultSession];
        [self.asyncRouteManager cancelRouteSession:taggedSession];
        NSLog(@"Cancelled both sessions");
    });
}

- (void)cleanup {
    if (self.currentSession != nil) {
        // [objc_RouteSession_removeRouteListener]
        // Remove route listener
        [self.currentSession removeRouteListener:self];
        // [objc_RouteSession_removeRouteListener]
    }
 
    if (self.asyncRouteManager != nil && self.currentSession != nil) {
        // [objc_AsyncRouteManager_cancelRouteSession_1]
        // Cancel route session
        [self.asyncRouteManager cancelRouteSession:self.currentSession];
        // [objc_AsyncRouteManager_cancelRouteSession_1]
    }
}

- (void)runExample {
    NSLog(@"=== AsyncRouteManager Example ===");
 
    [self demonstrateAsyncRouteManagerMethods];
    [self demonstrateRouteEventTypes];
    [self demonstrateTurnTypes];
    [self demonstrateRouteOptions];
    [self demonstrateRouteStatusUsage];
    [self demonstrateRouteSessionManagement];
    [self demonstrateAdvancedAsyncRoutingFeatures];
 
    // Wait a bit for route updates
    [NSThread sleepForTimeInterval:3.0];
 
    [self cleanup];
    NSLog(@"=== Example completed ===");
}
 
#pragma mark - NCAsyncRouteListener
 
// [objc_AsyncRouteListener_onRouteChanged]
- (void)onRouteChanged:(NCRouteStatus)status currentPath:(NCRoutePath *)currentPath {
    NSLog(@"Route changed with status: %@", @(status));
    if (status == NCRouteStatusNewRoute && currentPath != nil) {
        [self demonstrateRoutePathUsage:currentPath];
    } else {
        NSLog(@"Route not ready, status: %@", @(status));
    }
}
// [objc_AsyncRouteListener_onRouteChanged]
 
// [objc_AsyncRouteListener_onRouteAdvanced]
- (void)onRouteAdvanced:(float)distance point:(NCLocationPoint *)point {
    NSLog(@"Route advanced: %f meters", distance);
    [self demonstrateLocationPointUsage:point];
}
// [objc_AsyncRouteListener_onRouteAdvanced]
 
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        AsyncRouteManagerExample *example = [[AsyncRouteManagerExample alloc] init];
        [example runExample];
    }
    return 0;
}