RouteManagerExample.m

Go to the documentation of this file.

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

@interface RouteManagerExample : NSObject <NCRouteListener>
 
@property (nonatomic, strong) NCNavigineSdk *sdk;
@property (nonatomic, strong) NCLocationManager *locationManager;
@property (nonatomic, strong) NCNavigationManager *navigationManager;
@property (nonatomic, strong) NCRouteManager *routeManager;
 
- (void)initializeSdk;
- (void)setupRouteListener;
- (void)demonstrateRouteManagerMethods;
- (void)demonstrateRoutePathUsage:(NSArray<NCRoutePath *> *)paths;
- (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)demonstrateAdvancedRoutingFeatures;
- (void)demonstrateRoutePlanningSimulation;
- (void)cleanup;
- (void)runExample;
 
@end
 
@implementation RouteManagerExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self initializeSdk];
        [self setupRouteListener];
    }
    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_getRouteManager]
        // Get RouteManager for working with routes
        self.routeManager = [self.sdk getRouteManager:self.locationManager navigationManager:self.navigationManager];
        // [objc_NavigineSdk_getRouteManager]
 
        if (self.locationManager != nil && self.navigationManager != nil && self.routeManager != nil) {
            NSLog(@"LocationManager, NavigationManager and RouteManager successfully initialized");
        }
    } @catch (NSException *exception) {
        NSLog(@"Error initializing SDK: %@", exception.reason);
    }
}

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

- (void)demonstrateRouteManagerMethods {
    if (self.routeManager == nil) {
        NSLog(@"RouteManager not initialized");
        return;
    }
 
    // [objc_RouteManager_addRouteListener]
    // Add route listener
    [self.routeManager addRouteListener:self];
    // [objc_RouteManager_addRouteListener]
 
    // [objc_RouteManager_setGraphTag]
    // Set graph tag
    [self.routeManager setGraphTag:@"main"];
    // [objc_RouteManager_setGraphTag]
 
    // [objc_RouteManager_getGraphTag]
    // Get current graph tag
    NSString *currentGraphTag = [self.routeManager getGraphTag];
    NSLog(@"Current graph tag: %@", currentGraphTag);
    // [objc_RouteManager_getGraphTag]
 
    // [objc_RouteManager_getGraphTags]
    // Get all graph tags
    NSArray<NSString *> *graphTags = [self.routeManager getGraphTags];
    NSLog(@"Available graph tags: %@", graphTags);
    // [objc_RouteManager_getGraphTags]
 
    // Create test points
    NCPoint *startPoint = [[NCPoint alloc] initWithX:10.0 y:20.0];
    NCPoint *endPoint = [[NCPoint alloc] initWithX:50.0 y:60.0];
    NCLocationPoint *startLocationPoint = [[NCLocationPoint alloc] initWithPoint:startPoint locationId:12345 sublocationId:1];
    NCLocationPoint *endLocationPoint = [[NCLocationPoint alloc] initWithPoint:endPoint locationId:12345 sublocationId:1];
 
    // [objc_RouteManager_makeRoute]
    // Make route from point to point
    NCRoutePath *routePath = [self.routeManager makeRoute:startLocationPoint to:endLocationPoint];
    NSLog(@"Route created with length: %f meters", [routePath getLength]);
    // [objc_RouteManager_makeRoute]
 
    // [objc_RouteManager_makeRoutes]
    // Make routes to multiple destinations
    NSArray<NCLocationPoint *> *destinations = @[
        [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:30.0 y:40.0] locationId:12345 sublocationId:1],
        [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:70.0 y:80.0] locationId:12345 sublocationId:1]
    ];
    NSArray<NCRoutePath *> *routePaths = [self.routeManager makeRoutes:startLocationPoint to:destinations];
    NSLog(@"Created %lu routes", (unsigned long)routePaths.count);
    // [objc_RouteManager_makeRoutes]
 
    // [objc_RouteManager_setTarget]
    // Set target point
    [self.routeManager setTarget:endLocationPoint];
    // [objc_RouteManager_setTarget]
 
    // [objc_RouteManager_addTarget]
    // Add additional target point
    NCLocationPoint *additionalTarget = [[NCLocationPoint alloc] initWithPoint:[[NCPoint alloc] initWithX:90.0 y:100.0] locationId:12345 sublocationId:1];
    [self.routeManager addTarget:additionalTarget];
    // [objc_RouteManager_addTarget]
 
    // [objc_RouteManager_cancelTarget]
    // Cancel current target
    [self.routeManager cancelTarget];
    // [objc_RouteManager_cancelTarget]
 
    // [objc_RouteManager_clearTargets]
    // Clear all targets
    [self.routeManager clearTargets];
    // [objc_RouteManager_clearTargets]
}

- (void)demonstrateRoutePathUsage:(NSArray<NCRoutePath *> *)paths {
    for (int i = 0; i < paths.count; i++) {
        NCRoutePath *path = paths[i];
        NSLog(@"=== Route Path %d ===", i + 1);
 
        // [objc_RoutePath_getLength]
        // Get route length
        double length = [path getLength];
        NSLog(@"Route length: %f meters", length);
        // [objc_RoutePath_getLength]
 
        // [objc_RoutePath_getWeight]
        // Get total route weight
        double weight = [path getWeight];
        NSLog(@"Route weight: %f", weight);
        // [objc_RoutePath_getWeight]
 
        // [objc_RoutePath_getNodes]
        // Get route nodes
        NSArray<NCRouteNode *> *nodes = [path getNodes];
        NSLog(@"Route has %lu nodes", (unsigned long)nodes.count);
        for (int j = 0; j < nodes.count; j++) {
            [self demonstrateRouteNodeUsage:nodes[j]];
        }
        // [objc_RoutePath_getNodes]
 
        // [objc_RoutePath_head]
        // Get head of route (first 10 meters)
        NCRoutePath *headPath = [path head:10.0];
        if (headPath != nil) {
            NSLog(@"Head path length: %f meters", [headPath getLength]);
        }
        // [objc_RoutePath_head]
 
        // [objc_RoutePath_tail]
        // Get tail of route (remaining after 10 meters)
        NCRoutePath *tailPath = [path tail:10.0];
        if (tailPath != nil) {
            NSLog(@"Tail path length: %f meters", [tailPath 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];
    NSLog(@"Node has %lu events", (unsigned long)events.count);
    for (NCRouteEvent *event in events) {
        [self demonstrateRouteEventUsage:event];
    }
    // [objc_RouteNode_getEvents]
}

- (void)demonstrateRouteEventUsage:(NCRouteEvent *)event {
    // [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 = @[
        @(NCRouteEventTypeTurnLeft),
        @(NCRouteEventTypeTurnRight),
        @(NCRouteEventTypeTransition)
    ];
    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)
    ];
    NSLog(@"Available turn types:");
    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 {
    // [objc_LocationPoint_getPoint]
    // Get point coordinates
    NCPoint *point = [locationPoint getPoint];
    if (point != nil) {
        [self demonstratePointUsage:point];
    }
    // [objc_LocationPoint_getPoint]
 
    // [objc_LocationPoint_getLocationId]
    // Get location ID
    int32_t locationId = [locationPoint getLocationId];
    NSLog(@"Location ID: %d", locationId);
    // [objc_LocationPoint_getLocationId]
 
    // [objc_LocationPoint_getSublocationId]
    // Get sublocation ID
    int32_t sublocationId = [locationPoint getSublocationId];
    NSLog(@"Sublocation ID: %d", sublocationId);
    // [objc_LocationPoint_getSublocationId]
 
    // [objc_LocationPoint_constructor]
    // Create new LocationPoint
    NCPoint *newPoint = [[NCPoint alloc] initWithX:15.0 y:25.0];
    NCLocationPoint *newLocationPoint = [[NCLocationPoint alloc] initWithPoint:newPoint locationId:locationId sublocationId:sublocationId];
    NSLog(@"Created new LocationPoint: %@", newLocationPoint);
    // [objc_LocationPoint_constructor]
}

- (void)demonstratePointUsage:(NCPoint *)point {
    // [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:x y:y];
    NSLog(@"Created new Point: %@", newPoint);
    // [objc_Point_constructor]
}

- (void)demonstrateAdvancedRoutingFeatures {
    NSLog(@"=== Advanced Routing Features ===");
 
    if (self.routeManager == nil) {
        return;
    }
 
    // Create multiple routes with different graph tags
    NSArray<NSString *> *graphTags = @[@"main", @"elevator", @"stairs"];
 
    for (NSString *tag in graphTags) {
        // [objc_RouteManager_setGraphTag_2]
        // Set different graph tag for routing
        [self.routeManager setGraphTag:tag];
        // [objc_RouteManager_setGraphTag_2]
 
        NSLog(@"Routing with graph tag: %@", tag);
 
        // Create test route
        NCPoint *startPoint = [[NCPoint alloc] initWithX:0.0 y:0.0];
        NCPoint *endPoint = [[NCPoint alloc] initWithX:100.0 y:100.0];
        NCLocationPoint *startLocationPoint = [[NCLocationPoint alloc] initWithPoint:startPoint locationId:12345 sublocationId:1];
        NCLocationPoint *endLocationPoint = [[NCLocationPoint alloc] initWithPoint:endPoint locationId:12345 sublocationId:1];
 
        // [objc_RouteManager_makeRoute_2]
        // Make route with specific graph tag
        NCRoutePath *routePath = [self.routeManager makeRoute:startLocationPoint to:endLocationPoint];
        // [objc_RouteManager_makeRoute_2]
 
        NSLog(@"Route with tag '%@' has length: %f meters", tag, [routePath getLength]);
    }
}

- (void)demonstrateRoutePlanningSimulation {
    NSLog(@"=== Route Planning Simulation ===");
 
    if (self.routeManager == nil) {
        return;
    }
 
    // Create multiple target points
    NSArray<NCLocationPoint *> *targets = @[
        [[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]
    ];
 
    // [objc_RouteManager_setTarget_2]
    // Set first target
    [self.routeManager setTarget:targets[0]];
    // [objc_RouteManager_setTarget_2]
 
    NSLog(@"Set target 1: %@", targets[0]);
    [NSThread sleepForTimeInterval:1.0];
 
    // [objc_RouteManager_addTarget_2]
    // Add additional targets
    for (int i = 1; i < targets.count; i++) {
        [self.routeManager addTarget:targets[i]];
        NSLog(@"Added target %d: %@", i + 1, targets[i]);
        [NSThread sleepForTimeInterval:1.0];
    }
    // [objc_RouteManager_addTarget_2]
 
    // [objc_RouteManager_cancelTarget_2]
    // Cancel current target
    [self.routeManager cancelTarget];
    NSLog(@"Cancelled current target");
    // [objc_RouteManager_cancelTarget_2]
 
    [NSThread sleepForTimeInterval:1.0];
 
    // [objc_RouteManager_clearTargets_2]
    // Clear all targets
    [self.routeManager clearTargets];
    NSLog(@"Cleared all targets");
    // [objc_RouteManager_clearTargets_2]
}

- (void)cleanup {
    if (self.routeManager != nil) {
        // [objc_RouteManager_removeRouteListener]
        // Remove route listener
        [self.routeManager removeRouteListener:self];
        // [objc_RouteManager_removeRouteListener]
    }
}

- (void)runExample {
    NSLog(@"=== RouteManager Example ===");
 
    [self demonstrateRouteManagerMethods];
    [self demonstrateRouteEventTypes];
    [self demonstrateTurnTypes];
    [self demonstrateAdvancedRoutingFeatures];
    [self demonstrateRoutePlanningSimulation];
 
    // Wait a bit for route updates
    [NSThread sleepForTimeInterval:3.0];
 
    [self cleanup];
    NSLog(@"=== Example completed ===");
}
 
#pragma mark - NCRouteListener
 
// [objc_RouteListener_onPathsUpdated]
- (void)onPathsUpdated:(NSArray<NCRoutePath *> *)paths {
    NSLog(@"Routes updated successfully");
    [self demonstrateRoutePathUsage:paths];
}
// [objc_RouteListener_onPathsUpdated]
 
@end

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