shakebug-react-native 1.0.14

package/ios/Senors/RNSensorsGravity.m

@@ -0,0 +1,165 @@
+
+//  Orientation.m
+
+
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import "RNSensorsGravity.h"
+#import "RNSensorsUtils.h"
+
+@implementation ShakebugSDKRNSensorsGravity
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE();
+
+- (id) init {
+    self = [super init];
+    NSLog(@"ShakebugSDKRNSensorsGravity");
+
+    if (self) {
+        self->_motionManager = [[CMMotionManager alloc] init];
+        self->logLevel = 0;
+    }
+    return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"ShakebugSDKRNSensorsGravity"];
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+RCT_REMAP_METHOD(isAvailable,
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    return [self isAvailableWithResolver:resolve
+                               rejecter:reject];
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+                        rejecter:(RCTPromiseRejectBlock) reject {
+    if([self->_motionManager isDeviceMotionAvailable])
+    {
+        /* Start the accelerometer if it is not active already */
+        if([self->_motionManager isDeviceMotionActive] == NO)
+        {
+            resolve(@YES);
+        } else {
+            reject(@"-1", @"Gravity is not active", nil);
+        }
+    }
+    else
+    {
+        reject(@"-1", @"Gravity is not available", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(setUpdateInterval:(double) interval) {
+    if (self->logLevel > 0) {
+        NSLog(@"setUpdateInterval: %f", interval);
+    }
+
+    double intervalInSeconds = interval / 1000;
+
+    [self->_motionManager setDeviceMotionUpdateInterval:intervalInSeconds];
+}
+
+RCT_EXPORT_METHOD(setLogLevel:(int) level) {
+    if (level > 0) {
+        NSLog(@"setLogLevel: %f", level);
+    }
+
+    self->logLevel = level;
+}
+
+RCT_EXPORT_METHOD(getUpdateInterval:(RCTResponseSenderBlock) cb) {
+    double interval = self->_motionManager.deviceMotionUpdateInterval;
+
+    if (self->logLevel > 0) {
+        NSLog(@"getUpdateInterval: %f", interval);
+    }
+
+    cb(@[[NSNull null], [NSNumber numberWithDouble:interval]]);
+}
+
+RCT_EXPORT_METHOD(getData:(RCTResponseSenderBlock) cb) {    
+    double x = self->_motionManager.deviceMotion.gravity.x;
+    double y = self->_motionManager.deviceMotion.gravity.y;
+    double z = self->_motionManager.deviceMotion.gravity.z;
+    double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:self->_motionManager.deviceMotion.timestamp];
+
+    if (self->logLevel > 0) {
+        NSLog(@"getData: %f, %f, %f, %f", x, y, z, timestamp);
+    }
+
+    cb(@[[NSNull null], @{
+                 @"x" : [NSNumber numberWithDouble:x],
+                 @"y" : [NSNumber numberWithDouble:y],
+                 @"z" : [NSNumber numberWithDouble:z],
+                 @"timestamp" : [NSNumber numberWithDouble:timestamp]
+             }]
+       );
+}
+
+RCT_EXPORT_METHOD(startUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"startUpdates/startGravityUpdates");
+    }
+
+    [self->_motionManager setShowsDeviceMovementDisplay:YES];
+
+    /* Receive the orientation data on this block */
+    [self->_motionManager startDeviceMotionUpdatesToQueue:[NSOperationQueue mainQueue]
+                                               withHandler:^(CMDeviceMotion *deviceMotion, NSError *error)
+     {
+
+        double x = deviceMotion.gravity.x;
+        double y = deviceMotion.gravity.y;
+        double z = deviceMotion.gravity.z;
+
+         double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:deviceMotion.timestamp];
+
+         if (self->logLevel > 1) {
+             NSLog(@"Updated gravity values: %f, %f, %f, %f", x, y, z, timestamp);
+         }
+
+         [self sendEventWithName:@"ShakebugSDKRNSensorsGravity" body:@{
+                                                           @"x" : [NSNumber numberWithDouble:x],
+                                                           @"y" : [NSNumber numberWithDouble:y],
+                                                           @"z" : [NSNumber numberWithDouble:z],
+                                                           @"timestamp" : [NSNumber numberWithDouble:timestamp]
+                                                       }];
+     }];
+
+}
+
+RCT_EXPORT_METHOD(stopUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"stopUpdates");
+    }
+
+    [self->_motionManager stopDeviceMotionUpdates];
+}
+
+// Will be called when this module's first listener is added.
+-(void)startObserving {
+    hasListeners = YES;
+    // Set up any upstream listeners or background tasks as necessary
+}
+
+// Will be called when this module's last listener is removed, or on dealloc.
+-(void)stopObserving {
+    // Remove upstream listeners, stop unnecessary background tasks
+    hasListeners = NO;
+    // If we no longer have listeners registered we should also probably also stop the sensor since the sensor events are essentially being dropped.
+    if (self->_motionManager) {
+        [self stopUpdates];
+    }
+}
+
+@end

package/ios/Senors/RNSensorsGyroscope.h

@@ -0,0 +1,22 @@
+// Inspired by https://github.com/pwmckenna/react-native-motion-manager
+
+#import <React/RCTBridgeModule.h>
+#import <CoreMotion/CoreMotion.h>
+#import <React/RCTEventEmitter.h>
+
+@interface ShakebugSDKRNSensorsGyroscope : RCTEventEmitter <RCTBridgeModule> {
+    CMMotionManager *_motionManager;
+    int logLevel;
+    bool hasListeners;
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+         rejecter:(RCTPromiseRejectBlock) reject;
+- (void) setUpdateInterval:(double) interval;
+- (void) getUpdateInterval:(RCTResponseSenderBlock) cb;
+- (void) setLogLevel:(int) level;
+- (void) getData:(RCTResponseSenderBlock) cb;
+- (void) startUpdates;
+- (void) stopUpdates;
+
+@end

package/ios/Senors/RNSensorsGyroscope.m

@@ -0,0 +1,160 @@
+// Inspired by https://github.com/pwmckenna/react-native-motion-manager
+
+#import "RNSensorsGyroscope.h"
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import "RNSensorsUtils.h"
+
+@implementation ShakebugSDKRNSensorsGyroscope
+
+@synthesize bridge = _bridge;
+RCT_EXPORT_MODULE();
+
+- (id) init {
+    self = [super init];
+    NSLog(@"ShakebugSDKRNSensorsGyroscope");
+
+    if (self) {
+        self->_motionManager = [[CMMotionManager alloc] init];
+        self->logLevel = 0;
+    }
+    return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"ShakebugSDKRNSensorsGyroscope"];
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+RCT_REMAP_METHOD(isAvailable,
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    return [self isAvailableWithResolver:resolve
+                                rejecter:reject];
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+                        rejecter:(RCTPromiseRejectBlock) reject {
+    if([self->_motionManager isGyroAvailable])
+    {
+        /* Start the accelerometer if it is not active already */
+        if([self->_motionManager isGyroActive] == NO)
+        {
+            resolve(@YES);
+        } else {
+            reject(@"-1", @"Gyroscope is not active", nil);
+        }
+    }
+    else
+    {
+        reject(@"-1", @"Gyroscope is not available", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(setUpdateInterval:(double) interval) {
+    if (self->logLevel > 0) {
+        NSLog(@"setUpdateInterval: %f", interval);
+    }
+
+    double intervalInSeconds = interval / 1000;
+
+    [self->_motionManager setGyroUpdateInterval:intervalInSeconds];
+}
+
+RCT_EXPORT_METHOD(setLogLevel:(int) level) {
+    if (level > 0) {
+        NSLog(@"setLogLevel: %f", level);
+    }
+
+    self->logLevel = level;
+}
+
+RCT_EXPORT_METHOD(getUpdateInterval:(RCTResponseSenderBlock) cb) {
+    double interval = self->_motionManager.gyroUpdateInterval;
+
+    if (self->logLevel > 0) {
+        NSLog(@"getUpdateInterval: %f", interval);
+    }
+
+    cb(@[[NSNull null], [NSNumber numberWithDouble:interval]]);
+}
+
+RCT_EXPORT_METHOD(getData:(RCTResponseSenderBlock) cb) {
+    double x = self->_motionManager.gyroData.rotationRate.x;
+    double y = self->_motionManager.gyroData.rotationRate.y;
+    double z = self->_motionManager.gyroData.rotationRate.z;
+    double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:self->_motionManager.gyroData.timestamp];
+
+    if (self->logLevel > 0) {
+        NSLog(@"getData: %f, %f, %f, %f", x, y, z, timestamp);
+    }
+
+    cb(@[[NSNull null], @{
+                 @"x" : [NSNumber numberWithDouble:x],
+                 @"y" : [NSNumber numberWithDouble:y],
+                 @"z" : [NSNumber numberWithDouble:z],
+                 @"timestamp" : [NSNumber numberWithDouble:timestamp]
+             }]
+       );
+}
+
+RCT_EXPORT_METHOD(startUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"startUpdates/startGyroUpdates");
+    }
+
+    [self->_motionManager startGyroUpdates];
+
+    /* Receive the gyroscope data on this block */
+    [self->_motionManager startGyroUpdatesToQueue:[NSOperationQueue mainQueue]
+                                      withHandler:^(CMGyroData *gyroData, NSError *error)
+     {
+         double x = gyroData.rotationRate.x;
+         double y = gyroData.rotationRate.y;
+         double z = gyroData.rotationRate.z;
+         double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:gyroData.timestamp];
+
+         if (self->logLevel > 1) {
+             NSLog(@"Updated gyro values: %f, %f, %f, %f", x, y, z, timestamp);
+         }
+
+         [self sendEventWithName:@"ShakebugSDKRNSensorsGyroscope" body:@{
+                                                         @"x" : [NSNumber numberWithDouble:x],
+                                                         @"y" : [NSNumber numberWithDouble:y],
+                                                         @"z" : [NSNumber numberWithDouble:z],
+                                                         @"timestamp" : [NSNumber numberWithDouble:timestamp]
+                                                     }];
+     }];
+
+}
+
+RCT_EXPORT_METHOD(stopUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"stopUpdates");
+    }
+
+    [self->_motionManager stopGyroUpdates];
+}
+
+// Will be called when this module's first listener is added.
+-(void)startObserving {
+    hasListeners = YES;
+    // Set up any upstream listeners or background tasks as necessary
+}
+
+// Will be called when this module's last listener is removed, or on dealloc.
+-(void)stopObserving {
+    // Remove upstream listeners, stop unnecessary background tasks
+    hasListeners = NO;
+    // If we no longer have listeners registered we should also probably also stop the sensor since the sensor events are essentially being dropped.
+    if (self->_motionManager) {
+        [self stopUpdates];
+    }
+}
+
+@end

package/ios/Senors/RNSensorsMagnetometer.h

@@ -0,0 +1,22 @@
+// Inspired by https://github.com/pwmckenna/react-native-motion-manager
+
+#import <React/RCTBridgeModule.h>
+#import <CoreMotion/CoreMotion.h>
+#import <React/RCTEventEmitter.h>
+
+@interface ShakebugSDKRNSensorsMagnetometer : RCTEventEmitter <RCTBridgeModule> {
+    CMMotionManager *_motionManager;
+    int logLevel;
+    bool hasListeners;
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+         rejecter:(RCTPromiseRejectBlock) reject;
+- (void) setUpdateInterval:(double) interval;
+- (void) getUpdateInterval:(RCTResponseSenderBlock) cb;
+- (void) setLogLevel:(int) level;
+- (void) getData:(RCTResponseSenderBlock) cb;
+- (void) startUpdates;
+- (void) stopUpdates;
+
+@end

package/ios/Senors/RNSensorsMagnetometer.m

@@ -0,0 +1,163 @@
+
+//  RNSensorsMagnetometer.m
+
+
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import "RNSensorsMagnetometer.h"
+#import "RNSensorsUtils.h"
+
+@implementation ShakebugSDKRNSensorsMagnetometer
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE();
+
+- (id) init {
+    self = [super init];
+    NSLog(@"ShakebugSDKRNSensorsMagnetometer");
+
+    if (self) {
+        self->_motionManager = [[CMMotionManager alloc] init];
+        self->logLevel = 0;
+    }
+    return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"ShakebugSDKRNSensorsMagnetometer"];
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+RCT_REMAP_METHOD(isAvailable,
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    return [self isAvailableWithResolver:resolve
+                               rejecter:reject];
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+                        rejecter:(RCTPromiseRejectBlock) reject {
+    if([self->_motionManager isMagnetometerAvailable])
+    {
+        /* Start the accelerometer if it is not active already */
+        if([self->_motionManager isMagnetometerActive] == NO)
+        {
+            resolve(@YES);
+        } else {
+            reject(@"-1", @"Magnetometer is not active", nil);
+        }
+    }
+    else
+    {
+        reject(@"-1", @"Magnetometer is not available", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(setUpdateInterval:(double) interval) {
+    if (self->logLevel > 0) {
+        NSLog(@"setUpdateInterval: %f", interval);
+    }
+
+    double intervalInSeconds = interval / 1000;
+
+    [self->_motionManager setMagnetometerUpdateInterval:intervalInSeconds];
+}
+
+RCT_EXPORT_METHOD(setLogLevel:(int) level) {
+    if (level > 0) {
+        NSLog(@"setLogLevel: %f", level);
+    }
+
+    self->logLevel = level;
+}
+
+RCT_EXPORT_METHOD(getUpdateInterval:(RCTResponseSenderBlock) cb) {
+    double interval = self->_motionManager.magnetometerUpdateInterval;
+
+    if (self->logLevel > 0) {
+        NSLog(@"getUpdateInterval: %f", interval);
+    }
+
+    cb(@[[NSNull null], [NSNumber numberWithDouble:interval]]);
+}
+
+RCT_EXPORT_METHOD(getData:(RCTResponseSenderBlock) cb) {
+    double x = self->_motionManager.magnetometerData.magneticField.x;
+    double y = self->_motionManager.magnetometerData.magneticField.y;
+    double z = self->_motionManager.magnetometerData.magneticField.z;
+    double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:self->_motionManager.magnetometerData.timestamp];
+
+    if (self->logLevel > 0) {
+        NSLog(@"getData: %f, %f, %f, %f", x, y, z, timestamp);
+    }
+
+    cb(@[[NSNull null], @{
+                 @"x" : [NSNumber numberWithDouble:x],
+                 @"y" : [NSNumber numberWithDouble:y],
+                 @"z" : [NSNumber numberWithDouble:z],
+                 @"timestamp" : [NSNumber numberWithDouble:timestamp]
+             }]
+       );
+}
+
+RCT_EXPORT_METHOD(startUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"startUpdates/startMagnetometerUpdates");
+    }
+
+    [self->_motionManager startMagnetometerUpdates];
+
+    /* Receive the magnetometer data on this block */
+    [self->_motionManager startMagnetometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                                               withHandler:^(CMMagnetometerData *magnetometerData, NSError *error)
+     {
+         double x = magnetometerData.magneticField.x;
+         double y = magnetometerData.magneticField.y;
+         double z = magnetometerData.magneticField.z;
+         double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:magnetometerData.timestamp];
+
+         if (self->logLevel > 1) {
+             NSLog(@"Updated magnetometer values: %f, %f, %f, %f", x, y, z, timestamp);
+         }
+
+         [self sendEventWithName:@"ShakebugSDKRNSensorsMagnetometer" body:@{
+                                                           @"x" : [NSNumber numberWithDouble:x],
+                                                           @"y" : [NSNumber numberWithDouble:y],
+                                                           @"z" : [NSNumber numberWithDouble:z],
+                                                           @"timestamp" : [NSNumber numberWithDouble:timestamp]
+                                                       }];
+     }];
+
+}
+
+RCT_EXPORT_METHOD(stopUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"stopUpdates");
+    }
+
+    [self->_motionManager stopMagnetometerUpdates];
+}
+
+// Will be called when this module's first listener is added.
+-(void)startObserving {
+    hasListeners = YES;
+    // Set up any upstream listeners or background tasks as necessary
+}
+
+// Will be called when this module's last listener is removed, or on dealloc.
+-(void)stopObserving {
+    // Remove upstream listeners, stop unnecessary background tasks
+    hasListeners = NO;
+    // If we no longer have listeners registered we should also probably also stop the sensor since the sensor events are essentially being dropped.
+    if (self->_motionManager) {
+        [self stopUpdates];
+    }
+}
+
+@end

package/ios/Senors/RNSensorsOrientation.h

@@ -0,0 +1,22 @@
+// Inspired by https://github.com/pwmckenna/react-native-motion-manager
+
+#import <React/RCTBridgeModule.h>
+#import <CoreMotion/CoreMotion.h>
+#import <React/RCTEventEmitter.h>
+
+@interface ShakebugSDKRNSensorsOrientation : RCTEventEmitter <RCTBridgeModule> {
+    CMMotionManager *_motionManager;
+    int logLevel;
+    bool hasListeners;
+}
+
+- (void) isAvailableWithResolver:(RCTPromiseResolveBlock) resolve
+         rejecter:(RCTPromiseRejectBlock) reject;
+- (void) setUpdateInterval:(double) interval;
+- (void) getUpdateInterval:(RCTResponseSenderBlock) cb;
+- (void) setLogLevel:(int) level;
+- (void) getData:(RCTResponseSenderBlock) cb;
+- (void) startUpdates;
+- (void) stopUpdates;
+
+@end