NavigationManagerExample.m

Go to the documentation of this file.

#import <Foundation/Foundation.h>
#import "NCNavigineSdk.h"
#import "NCLocationManager.h"
#import "NCLocationListener.h"
#import "NCNavigationManager.h"
#import "NCPositionListener.h"
#import "NCPosition.h"
#import "NCGlobalPoint.h"
#import "NCLocationPoint.h"
#import "NCPoint.h"

@interface NavigationManagerExample : NSObject <NCPositionListener, NCLocationListener>
 
@property (nonatomic, strong) NCNavigineSdk *sdk;
@property (nonatomic, strong) NCLocationManager *locationManager;
@property (nonatomic, strong) NCNavigationManager *navigationManager;
 
@end
 
@implementation NavigationManagerExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self initializeSdk];
    }
    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]
 
        if (self.locationManager != nil && self.navigationManager != nil) {
            NSLog(@"LocationManager and NavigationManager successfully initialized");
        }
    } @catch (NSException *exception) {
        NSLog(@"Error initializing SDK: %@", exception.reason);
    }
}

- (void)demonstrateNavigationManagerMethods {
    if (self.navigationManager == nil) {
        NSLog(@"NavigationManager not initialized");
        return;
    }
 
    // [objc_NavigationManager_addPositionListener]
    // Add position listener
    [self.navigationManager addPositionListener:self];
    // [objc_NavigationManager_addPositionListener]
 
    // [objc_NavigationManager_startLogRecording]
    // Start log recording
    [self.navigationManager startLogRecording];
    // [objc_NavigationManager_startLogRecording]
 
    // [objc_NavigationManager_addCheckPoint]
    // Add check point
    NCPoint *point = [[NCPoint alloc] initWithX:10.0 y:20.0];
    NCLocationPoint *locationPoint = [[NCLocationPoint alloc] initWithPoint:point locationId:12345 sublocationId:1];
    [self.navigationManager addCheckPoint:locationPoint];
    // [objc_NavigationManager_addCheckPoint]
 
    // [objc_NavigationManager_addLocationMeasurement]
    // Add location measurement
    NCGlobalPoint *globalPoint = [[NCGlobalPoint alloc] initWithLatitude:55.7558 longitude:37.6176]; // Moscow coordinates
    [self.navigationManager addLocationMeasurement:globalPoint accuracy:5.0f provider:@"gps"];
    // [objc_NavigationManager_addLocationMeasurement]
 
    // [objc_NavigationManager_stopLogRecording]
    // Stop log recording
    [self.navigationManager stopLogRecording];
    // [objc_NavigationManager_stopLogRecording]
}

- (void)demonstratePositionUsage:(NCPosition *)position {
    if (position == nil) {
        NSLog(@"Position is null");
        return;
    }
 
    // [objc_Position_getPoint]
    // Get global point (WGS84 coordinates)
    NCGlobalPoint *globalPoint = [position getPoint];
    if (globalPoint != nil) {
        [self demonstrateGlobalPointUsage:globalPoint];
    }
    // [objc_Position_getPoint]
 
    // [objc_Position_getAccuracy]
    // Get position accuracy
    double accuracy = [position getAccuracy];
    NSLog(@"Position accuracy: %f meters", accuracy);
    // [objc_Position_getAccuracy]
 
    // [objc_Position_getHeading]
    // Get heading (angle of rotation about the -Z axis in radians)
    NSNumber *heading = [position getHeading];
    if (heading != nil) {
        NSLog(@"Heading: %f radians", [heading doubleValue]);
    }
    // [objc_Position_getHeading]
 
    // [objc_Position_getHeadingAccuracy]
    // Get heading accuracy
    NSNumber *headingAccuracy = [position getHeadingAccuracy];
    if (headingAccuracy != nil) {
        NSLog(@"Heading accuracy: %f radians", [headingAccuracy doubleValue]);
    }
    // [objc_Position_getHeadingAccuracy]
 
    // [objc_Position_getLocationPoint]
    // Get location point (metrics coordinates)
    NCLocationPoint *locationPoint = [position getLocationPoint];
    if (locationPoint != nil) {
        [self demonstrateLocationPointUsage:locationPoint];
    }
    // [objc_Position_getLocationPoint]
 
    // [objc_Position_getLocationHeading]
    // Get location heading (with respect to sublocation north)
    NSNumber *locationHeading = [position getLocationHeading];
    if (locationHeading != nil) {
        NSLog(@"Location heading: %f radians", [locationHeading doubleValue]);
    }
    // [objc_Position_getLocationHeading]
}

- (void)demonstrateGlobalPointUsage:(NCGlobalPoint *)globalPoint {
    if (globalPoint == nil) {
        NSLog(@"GlobalPoint is null");
        return;
    }
 
    // [objc_GlobalPoint_getLatitude]
    // Get latitude
    double latitude = [globalPoint getLatitude];
    NSLog(@"Latitude: %f", latitude);
    // [objc_GlobalPoint_getLatitude]
 
    // [objc_GlobalPoint_getLongitude]
    // Get longitude
    double longitude = [globalPoint getLongitude];
    NSLog(@"Longitude: %f", longitude);
    // [objc_GlobalPoint_getLongitude]
 
    // [objc_GlobalPoint_constructor]
    // Create new GlobalPoint
    NCGlobalPoint *newPoint = [[NCGlobalPoint alloc] initWithLatitude:latitude longitude:longitude];
    NSLog(@"Created new GlobalPoint: %@", newPoint);
    // [objc_GlobalPoint_constructor]
}

- (void)demonstrateLocationPointUsage:(NCLocationPoint *)locationPoint {
    if (locationPoint == nil) {
        NSLog(@"LocationPoint is null");
        return;
    }
 
    // [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 {
    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:x y:y];
    NSLog(@"Created new Point: %@", newPoint);
    // [objc_Point_constructor]
}

- (void)demonstrateLocationManagerIntegration {
    if (self.locationManager == nil) {
        NSLog(@"LocationManager not initialized");
        return;
    }
 
    // [objc_LocationManager_addLocationListener]
    // Add location listener for navigation integration
    [self.locationManager addLocationListener:self];
    // [objc_LocationManager_addLocationListener]
 
    // [objc_LocationManager_setLocationId]
    // Set location ID to load
    [self.locationManager setLocationId:12345];
    // [objc_LocationManager_setLocationId]
 
    // [objc_LocationManager_getLocationId]
    // Get current location ID
    int32_t currentLocationId = [self.locationManager getLocationId];
    NSLog(@"Current location ID: %d", currentLocationId);
    // [objc_LocationManager_getLocationId]
 
    // [objc_LocationManager_setLocationUpdateInterval]
    // Set location update interval
    [self.locationManager setLocationUpdateInterval:300]; // 5 minutes
    // [objc_LocationManager_setLocationUpdateInterval]
 
    // [objc_LocationManager_commitChanges]
    // Commit changes
    [self.locationManager commitChanges];
    // [objc_LocationManager_commitChanges]
}

- (void)demonstrateAdvancedNavigationFeatures {
    NSLog(@"=== Advanced Navigation Features ===");
 
    if (self.navigationManager == nil) {
        return;
    }
 
    // Create multiple check points for path tracking
    NSArray<NCPoint *> *checkPoints = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:10.0],
        [[NCPoint alloc] initWithX:20.0 y:20.0],
        [[NCPoint alloc] initWithX:30.0 y:30.0]
    ];
 
    for (int i = 0; i < checkPoints.count; i++) {
        NCLocationPoint *locationPoint = [[NCLocationPoint alloc] initWithPoint:checkPoints[i] locationId:12345 sublocationId:1];
        // [objc_NavigationManager_addCheckPoint]
        // Add check point for path tracking
        [self.navigationManager addCheckPoint:locationPoint];
        // [objc_NavigationManager_addCheckPoint]
        NSLog(@"Added check point %d: %@", i + 1, locationPoint);
    }
 
    // Add location measurements with different providers
    NSArray<NCGlobalPoint *> *measurements = @[
        [[NCGlobalPoint alloc] initWithLatitude:55.7558 longitude:37.6176], // Moscow
        [[NCGlobalPoint alloc] initWithLatitude:40.7128 longitude:-74.0060], // New York
        [[NCGlobalPoint alloc] initWithLatitude:51.5074 longitude:-0.1278]   // London
    ];
 
    NSArray<NSString *> *providers = @[@"gps", @"network", @"fused"];
 
    for (int i = 0; i < measurements.count; i++) {
        // [objc_NavigationManager_addLocationMeasurement]
        // Add location measurement with different providers
        [self.navigationManager addLocationMeasurement:measurements[i] accuracy:3.0f + i provider:providers[i % providers.count]];
        // [objc_NavigationManager_addLocationMeasurement]
        NSLog(@"Added measurement %d with provider: %@", i + 1, providers[i % providers.count]);
    }
}

- (void)demonstratePositionTrackingSimulation {
    NSLog(@"=== Position Tracking Simulation ===");
 
    if (self.navigationManager == nil) {
        return;
    }
 
    // [objc_NavigationManager_startLogRecording]
    // Start log recording for position tracking
    [self.navigationManager startLogRecording];
    // [objc_NavigationManager_startLogRecording]
 
    // Simulate position updates
    for (int i = 0; i < 5; i++) {
        double lat = 55.7558 + (i * 0.001); // Move north
        double lon = 37.6176 + (i * 0.001); // Move east
        
        NCGlobalPoint *globalPoint = [[NCGlobalPoint alloc] initWithLatitude:lat longitude:lon];
        // [objc_NavigationManager_addLocationMeasurement]
        // Add simulated location measurement
        [self.navigationManager addLocationMeasurement:globalPoint accuracy:2.0f provider:@"simulated"];
        // [objc_NavigationManager_addLocationMeasurement]
        
        NSLog(@"Simulated position %d: %@", i + 1, globalPoint);
        
        [NSThread sleepForTimeInterval:1.0]; // Wait 1 second between updates
    }
 
    // [objc_NavigationManager_stopLogRecording]
    // Stop log recording
    [self.navigationManager stopLogRecording];
    // [objc_NavigationManager_stopLogRecording]
}

- (void)cleanup {
    if (self.navigationManager != nil) {
        // [objc_NavigationManager_removePositionListener]
        // Remove position listener
        [self.navigationManager removePositionListener:self];
        // [objc_NavigationManager_removePositionListener]
    }
}

- (void)runExample {
    NSLog(@"=== NavigationManager Example ===");
    
    [self demonstrateNavigationManagerMethods];
    [self demonstrateLocationManagerIntegration];
    [self demonstrateAdvancedNavigationFeatures];
    [self demonstratePositionTrackingSimulation];
    
    // Wait a bit for position updates
    [NSThread sleepForTimeInterval:3.0];
    
    [self cleanup];
    NSLog(@"=== Example completed ===");
}
 
#pragma mark - NCPositionListener
 
// [objc_PositionListener_onPositionUpdated]
- (void)onPositionUpdated:(NCPosition *)position {
    NSLog(@"Position updated successfully");
    [self demonstratePositionUsage:position];
}
// [objc_PositionListener_onPositionUpdated]
 
// [objc_PositionListener_onPositionError]
- (void)onPositionError:(NSError *)error {
    NSLog(@"Position error: %@", error.localizedDescription);
}
// [objc_PositionListener_onPositionError]
 
#pragma mark - NCLocationListener
 
// [objc_LocationListener_onLocationLoaded]
- (void)onLocationLoaded:(NCLocation *)location {
    NSLog(@"Location loaded for navigation");
    if (location != nil) {
        // [objc_LocationManager_setLocationId]
        // Set location ID for navigation
        [self.locationManager setLocationId:[location getId]];
        // [objc_LocationManager_setLocationId]
    }
}
// [objc_LocationListener_onLocationLoaded]
 
// [objc_LocationListener_onLocationUploaded]
- (void)onLocationUploaded:(int32_t)locationId {
    NSLog(@"Location uploaded: %d", locationId);
}
// [objc_LocationListener_onLocationUploaded]
 
// [objc_LocationListener_onLocationFailed]
- (void)onLocationFailed:(int32_t)locationId error:(NSError *)error {
    NSLog(@"Failed to load location %d: %@", locationId, error.localizedDescription);
}
// [objc_LocationListener_onLocationFailed]
 
@end

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