MeasurementManagerExample.m

Go to the documentation of this file.

#import "MeasurementManagerExample.h"

@implementation MeasurementManagerExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self initializeSdk];
        [self setupMeasurementListener];
    }
    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_getMeasurementManager]
        // Get MeasurementManager for working with measurements
        self.measurementManager = [self.sdk getMeasurementManager:self.locationManager];
        // [objc_NavigineSdk_getMeasurementManager]
 
        // [objc_MeasurementManager_setPublishIntervalMs]
        // Optional: interval between measurement batches sent to listeners (ms)
        [self.measurementManager setPublishIntervalMs:1000];
        // [objc_MeasurementManager_setPublishIntervalMs]
 
        if (self.locationManager != nil && self.measurementManager != nil) {
            NSLog(@"LocationManager and MeasurementManager successfully initialized");
        }
    } @catch (NSException *exception) {
        NSLog(@"Error initializing SDK: %@", exception.reason);
    }
}

- (void)setupMeasurementListener {
    self.measurementListener = [[MeasurementListenerImpl alloc] initWithExample:self];
}

- (void)demonstrateMeasurementManagerMethods {
    if (self.measurementManager == nil) {
        NSLog(@"MeasurementManager not initialized");
        return;
    }
 
    // [objc_MeasurementManager_addMeasurementListener]
    // Add measurement listener
    [self.measurementManager addMeasurementListener:self.measurementListener];
    NSLog(@"Added measurement listener");
    // [objc_MeasurementManager_addMeasurementListener]
 
    // Demonstrate beacon generators
    [self demonstrateBeaconGenerators];
 
    // Demonstrate Eddystone generators
    [self demonstrateEddystoneGenerators];
 
    // Demonstrate Wi-Fi generators
    [self demonstrateWifiGenerators];
 
    // Demonstrate Wi-Fi RTT generators
    [self demonstrateWifiRttGenerators];
 
    // Demonstrate location generators
    [self demonstrateLocationGenerators];
 
    // Simulate some time passing for measurements
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // [objc_MeasurementManager_removeMeasurementListener]
        // Remove measurement listener
        [self.measurementManager removeMeasurementListener:self.measurementListener];
        NSLog(@"Removed measurement listener");
        // [objc_MeasurementManager_removeMeasurementListener]
    });
}

- (void)demonstrateBeaconGenerators {
    // [objc_MeasurementManager_addBeaconGenerator]
    // Add beacon generator
    NSString *beaconId = [self.measurementManager addBeaconGeneratorWithUuid:@"12345678-1234-1234-1234-123456789012"
                                                                       major:100
                                                                       minor:200
                                                                       power:-60
                                                                     timeout:5000
                                                                    rssiMin:-80
                                                                    rssiMax:-40];
    NSLog(@"Added beacon generator with ID: %@", beaconId);
    // [objc_MeasurementManager_addBeaconGenerator]
 
    // [objc_MeasurementManager_removeBleGenerator]
    // Remove specific BLE generator
    [self.measurementManager removeBleGeneratorWithId:beaconId];
    NSLog(@"Removed BLE generator: %@", beaconId);
    // [objc_MeasurementManager_removeBleGenerator]
 
    // [objc_MeasurementManager_removeBleGenerators]
    // Remove all BLE generators
    [self.measurementManager removeBleGenerators];
    NSLog(@"Removed all BLE generators");
    // [objc_MeasurementManager_removeBleGenerators]
}

- (void)demonstrateEddystoneGenerators {
    // [objc_MeasurementManager_addEddystoneGenerator]
    // Add Eddystone generator
    NSString *eddystoneId = [self.measurementManager addEddystoneGeneratorWithNamespaceId:@"12345678901234567890"
                                                                               instanceId:@"1234567890123456"
                                                                                   power:-65
                                                                                 timeout:3000
                                                                                rssiMin:-85
                                                                                rssiMax:-45];
    NSLog(@"Added Eddystone generator with ID: %@", eddystoneId);
    // [objc_MeasurementManager_addEddystoneGenerator]
 
    // Remove Eddystone generator (uses same method as BLE)
    [self.measurementManager removeBleGeneratorWithId:eddystoneId];
    NSLog(@"Removed Eddystone generator: %@", eddystoneId);
}

- (void)demonstrateWifiGenerators {
    // [objc_MeasurementManager_addWifiGenerator]
    // Add Wi-Fi generator
    NSString *wifiId = [self.measurementManager addWifiGeneratorWithMac:@"AA:BB:CC:DD:EE:FF"
                                                                 timeout:4000
                                                                rssiMin:-90
                                                                rssiMax:-50];
    NSLog(@"Added Wi-Fi generator with ID: %@", wifiId);
    // [objc_MeasurementManager_addWifiGenerator]
 
    // [objc_MeasurementManager_removeWifiGenerator]
    // Remove specific Wi-Fi generator
    [self.measurementManager removeWifiGeneratorWithId:wifiId];
    NSLog(@"Removed Wi-Fi generator: %@", wifiId);
    // [objc_MeasurementManager_removeWifiGenerator]
 
    // [objc_MeasurementManager_removeWifiGenerators]
    // Remove all Wi-Fi generators
    [self.measurementManager removeWifiGenerators];
    NSLog(@"Removed all Wi-Fi generators");
    // [objc_MeasurementManager_removeWifiGenerators]
}

- (void)demonstrateWifiRttGenerators {
    // [objc_MeasurementManager_addWifiRttGenerator]
    // Add Wi-Fi RTT generator
    NSString *wifiRttId = [self.measurementManager addWifiRttGeneratorWithMac:@"11:22:33:44:55:66"
                                                                      timeout:6000
                                                                     distMin:1
                                                                     distMax:10
                                                                  stdDevMin:0
                                                                  stdDevMax:2
                                                                    rssiMin:-70
                                                                    rssiMax:-30];
    NSLog(@"Added Wi-Fi RTT generator with ID: %@", wifiRttId);
    // [objc_MeasurementManager_addWifiRttGenerator]
 
    // [objc_MeasurementManager_removeWifiRttGenerator]
    // Remove specific Wi-Fi RTT generator
    [self.measurementManager removeWifiRttGeneratorWithHash:wifiRttId];
    NSLog(@"Removed Wi-Fi RTT generator: %@", wifiRttId);
    // [objc_MeasurementManager_removeWifiRttGenerator]
 
    // [objc_MeasurementManager_removeWifiRttGenerators]
    // Remove all Wi-Fi RTT generators
    [self.measurementManager removeWifiRttGenerators];
    NSLog(@"Removed all Wi-Fi RTT generators");
    // [objc_MeasurementManager_removeWifiRttGenerators]
}

- (void)demonstrateLocationGenerators {
    // [objc_MeasurementManager_addLocationGenerator]
    // Add location generator
    NSString *locationId = [self.measurementManager addLocationGeneratorWithLatMin:55.7558
                                                                           latMax:55.7559
                                                                           lonMin:37.6176
                                                                           lonMax:37.6177
                                                                          accMin:1.0
                                                                          accMax:5.0
                                                                         timeout:7000];
    NSLog(@"Added location generator with ID: %@", locationId);
    // [objc_MeasurementManager_addLocationGenerator]
 
    // [objc_MeasurementManager_removeLocationGenerator]
    // Remove specific location generator
    [self.measurementManager removeLocationGeneratorWithId:locationId];
    NSLog(@"Removed location generator: %@", locationId);
    // [objc_MeasurementManager_removeLocationGenerator]
 
    // [objc_MeasurementManager_removeLocationGenerators]
    // Remove all location generators
    [self.measurementManager removeLocationGenerators];
    NSLog(@"Removed all location generators");
    // [objc_MeasurementManager_removeLocationGenerators]
}

- (void)demonstrateSensorMeasurements:(NSDictionary<NSNumber *, NCSensorMeasurement *> *)sensors {
    [sensors enumerateKeysAndObjectsUsingBlock:^(NSNumber *sensorTypeKey, NCSensorMeasurement *measurement, BOOL *stop) {
        // [objc_SensorMeasurement_getType]
        // Get sensor type
        NCSensorType type = measurement.type;
        NSLog(@"Sensor type: %ld", (long)type);
        // [objc_SensorMeasurement_getType]
 
        // [objc_SensorMeasurement_getValues]
        // Get sensor values
        NCVector3d *values = measurement.values;
        NSLog(@"Sensor values - X: %f, Y: %f, Z: %f", values.x, values.y, values.z);
        // [objc_SensorMeasurement_getValues]
 
        // [objc_SensorMeasurement_getTime]
        // Get measurement timestamp
        long long time = measurement.time;
        NSLog(@"Measurement time: %lld ms", time);
        // [objc_SensorMeasurement_getTime]
 
        // Demonstrate Vector3d properties
        [self demonstrateVector3d:values];
    }];
}

- (void)demonstrateSignalMeasurements:(NSDictionary<NSString *, NCSignalMeasurement *> *)signals {
    [signals enumerateKeysAndObjectsUsingBlock:^(NSString *signalId, NCSignalMeasurement *measurement, BOOL *stop) {
        // [objc_SignalMeasurement_getType]
        // Get signal type
        NCSignalType type = measurement.type;
        NSLog(@"Signal type: %ld", (long)type);
        // [objc_SignalMeasurement_getType]
 
        // [objc_SignalMeasurement_getId]
        // Get signal identifier
        NSString *id = measurement.id;
        NSLog(@"Signal ID: %@", id);
        // [objc_SignalMeasurement_getId]
 
        // [objc_SignalMeasurement_getRssi]
        // Get RSSI value
        double rssi = measurement.rssi;
        NSLog(@"Signal RSSI: %f dBm", rssi);
        // [objc_SignalMeasurement_getRssi]
 
        // [objc_SignalMeasurement_getDistance]
        // Get estimated distance
        double distance = measurement.distance;
        NSLog(@"Signal distance: %f meters", distance);
        // [objc_SignalMeasurement_getDistance]
 
        // [objc_SignalMeasurement_getTime]
        // Get measurement timestamp
        long long time = measurement.time;
        NSLog(@"Signal measurement time: %lld ms", time);
        // [objc_SignalMeasurement_getTime]
    }];
}

- (void)demonstrateVector3d:(NCVector3d *)vector {
    // [objc_Vector3d_getX]
    // Get X coordinate
    double x = vector.x;
    NSLog(@"Vector X: %f", x);
    // [objc_Vector3d_getX]
 
    // [objc_Vector3d_getY]
    // Get Y coordinate
    double y = vector.y;
    NSLog(@"Vector Y: %f", y);
    // [objc_Vector3d_getY]
 
    // [objc_Vector3d_getZ]
    // Get Z coordinate
    double z = vector.z;
    NSLog(@"Vector Z: %f", z);
    // [objc_Vector3d_getZ]
}

- (void)runExample {
    NSLog(@"=== MeasurementManager Example ===");
 
    [self demonstrateMeasurementManagerMethods];
 
    // Wait a bit for measurements
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"=== Example completed ===");
    });
}
 
@end

@interface MeasurementListenerImpl : NSObject <NCMeasurementListener>
 
@property (nonatomic, weak) MeasurementManagerExample *example;
 
- (instancetype)initWithExample:(MeasurementManagerExample *)example;
 
@end
 
@implementation MeasurementListenerImpl
 
- (instancetype)initWithExample:(MeasurementManagerExample *)example {
    self = [super init];
    if (self) {
        self.example = example;
    }
    return self;
}
 
// [objc_MeasurementListener_onSensorMeasurementDetected]
- (void)onSensorMeasurementDetected:(NSDictionary<NSNumber *, NCSensorMeasurement *> *)sensors {
    NSLog(@"Sensor measurements detected");
    [self.example demonstrateSensorMeasurements:sensors];
}
// [objc_MeasurementListener_onSensorMeasurementDetected]
 
// [objc_MeasurementListener_onSignalMeasurementDetected]
- (void)onSignalMeasurementDetected:(NSDictionary<NSString *, NCSignalMeasurement *> *)signals {
    NSLog(@"Signal measurements detected");
    [self.example demonstrateSignalMeasurements:signals];
}
// [objc_MeasurementListener_onSignalMeasurementDetected]
 
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MeasurementManagerExample *example = [[MeasurementManagerExample alloc] init];
        [example runExample];
 
        // Keep the app running for a while to see the output
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:10.0]];
    }
    return 0;
}