shakebug-react-native 1.0.14

package/ios/ScreenShot/ShakebugSDKRNViewShot.m

@@ -0,0 +1,186 @@
+#import "ShakebugSDKRNViewShot.h"
+#import <AVFoundation/AVFoundation.h>
+#import <React/RCTLog.h>
+#import <React/UIView+React.h>
+#import <React/RCTUtils.h>
+#import <React/RCTConvert.h>
+#import <React/RCTScrollView.h>
+#import <React/RCTUIManager.h>
+#if __has_include(<React/RCTUIManagerUtils.h>)
+#import <React/RCTUIManagerUtils.h>
+#endif
+#import <React/RCTBridge.h>
+
+@implementation ShakebugSDKRNViewShot
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+  return RCTGetUIManagerQueue();
+}
+
+RCT_EXPORT_METHOD(captureScreen: (NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  [self captureRef: [NSNumber numberWithInt:-1] withOptions:options resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(releaseCapture:(nonnull NSString *)uri)
+{
+  NSString *directory = [NSTemporaryDirectory() stringByAppendingPathComponent:@"ReactNative"];
+  // Ensure it's a valid file in the tmp directory
+  if ([uri hasPrefix:directory] && ![uri isEqualToString:directory]) {
+    NSFileManager *fileManager = [NSFileManager new];
+    if ([fileManager fileExistsAtPath:uri]) {
+      [fileManager removeItemAtPath:uri error:NULL];
+    }
+  }
+}
+
+RCT_EXPORT_METHOD(captureRef:(nonnull NSNumber *)target
+                  withOptions:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+
+    // Get view
+    UIView *view;
+
+    if ([target intValue] == -1) {
+      UIWindow *window = [[UIApplication sharedApplication] keyWindow];
+      view = window;
+    } else {
+      view = viewRegistry[target];
+    }
+
+    if (!view) {
+      reject(RCTErrorUnspecified, [NSString stringWithFormat:@"No view found with reactTag: %@", target], nil);
+      return;
+    }
+
+    // Get options
+    CGSize size = [RCTConvert CGSize:options];
+    NSString *format = [RCTConvert NSString:options[@"format"]];
+    NSString *result = [RCTConvert NSString:options[@"result"]];
+    BOOL renderInContext = [RCTConvert BOOL:options[@"useRenderInContext"]];
+    BOOL snapshotContentContainer = [RCTConvert BOOL:options[@"snapshotContentContainer"]];
+
+    // Capture image
+    BOOL success;
+
+    UIView* rendered;
+    UIScrollView* scrollView;
+    if (snapshotContentContainer) {
+      if (![view isKindOfClass:[RCTScrollView class]]) {
+        reject(RCTErrorUnspecified, [NSString stringWithFormat:@"snapshotContentContainer can only be used on a RCTScrollView. instead got: %@", view], nil);
+        return;
+      }
+      RCTScrollView* rctScrollView = view;
+      scrollView = rctScrollView.scrollView;
+      rendered = scrollView;
+    }
+    else {
+      rendered = view;
+    }
+
+    if (size.width < 0.1 || size.height < 0.1) {
+      size = snapshotContentContainer ? scrollView.contentSize : view.bounds.size;
+    }
+    if (size.width < 0.1 || size.height < 0.1) {
+      reject(RCTErrorUnspecified, [NSString stringWithFormat:@"The content size must not be zero or negative. Got: (%g, %g)", size.width, size.height], nil);
+      return;
+    }
+
+    CGPoint savedContentOffset;
+    CGRect savedFrame;
+    if (snapshotContentContainer) {
+      // Save scroll & frame and set it temporarily to the full content size
+      savedContentOffset = scrollView.contentOffset;
+      savedFrame = scrollView.frame;
+      scrollView.contentOffset = CGPointZero;
+      scrollView.frame = CGRectMake(0, 0, scrollView.contentSize.width, scrollView.contentSize.height);
+    }
+
+    UIGraphicsBeginImageContextWithOptions(size, NO, 0);
+    
+    if (renderInContext) {
+      // this comes with some trade-offs such as inability to capture gradients or scrollview's content in full but it works for large views
+      [rendered.layer renderInContext: UIGraphicsGetCurrentContext()];
+      success = YES;
+    }
+    else {
+      // this doesn't work for large views and reports incorrect success even though the image is blank
+      success = [rendered drawViewHierarchyInRect:(CGRect){CGPointZero, size} afterScreenUpdates:YES];
+    }
+    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
+    UIGraphicsEndImageContext();
+
+    if (snapshotContentContainer) {
+      // Restore scroll & frame
+      scrollView.contentOffset = savedContentOffset;
+      scrollView.frame = savedFrame;
+    }
+
+    if (!success) {
+      reject(RCTErrorUnspecified, @"The view cannot be captured. drawViewHierarchyInRect was not successful. This is a potential technical or security limitation.", nil);
+      return;
+    }
+
+    if (!image) {
+      reject(RCTErrorUnspecified, @"Failed to capture view snapshot. UIGraphicsGetImageFromCurrentImageContext() returned nil!", nil);
+      return;
+    }
+
+    // Convert image to data (on a background thread)
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+
+      NSData *data;
+      if ([format isEqualToString:@"jpg"]) {
+        CGFloat quality = [RCTConvert CGFloat:options[@"quality"]];
+        data = UIImageJPEGRepresentation(image, quality);
+      }
+      else {
+        data = UIImagePNGRepresentation(image);
+      }
+
+      NSError *error = nil;
+      NSString *res = nil;
+      if ([result isEqualToString:@"base64"]) {
+        // Return as a base64 raw string
+        res = [data base64EncodedStringWithOptions: NSDataBase64Encoding64CharacterLineLength];
+      }
+      else if ([result isEqualToString:@"data-uri"]) {
+        // Return as a base64 data uri string
+        NSString *base64 = [data base64EncodedStringWithOptions: NSDataBase64Encoding64CharacterLineLength];
+        NSString *imageFormat = ([format isEqualToString:@"jpg"]) ? @"jpeg" : format;
+        res = [NSString stringWithFormat:@"data:image/%@;base64,%@", imageFormat, base64];
+      }
+      else {
+        // Save to a temp file
+        NSString *path = RCTTempFilePath(format, &error);
+        if (path && !error) {
+          if ([data writeToFile:path options:(NSDataWritingOptions)0 error:&error]) {
+            res = path;
+          }
+        }
+      }
+
+      if (res && !error) {
+        resolve(res);
+        return;
+      }
+
+      // If we reached here, something went wrong
+      if (error) reject(RCTErrorUnspecified, error.localizedDescription, error);
+      else reject(RCTErrorUnspecified, @"viewshot unknown error", nil);
+    });
+  }];
+}
+
+
+@end

package/ios/ScreenshotDetector/ScreenShotDetector.h

@@ -0,0 +1,12 @@
+//
+//  ScreenShotDetector.h
+//  TestApp
+//
+//  Created by ideveloper2 on 17/05/24.
+//
+
+#import <React/RCTEventEmitter.h>
+
+@interface ShakebugSDKScreenShotDetector : RCTEventEmitter <RCTBridgeModule>
+- (void)sendScreenShotEvent:(NSDictionary *)eventData;
+@end

package/ios/ScreenshotDetector/ScreenShotDetector.m

@@ -0,0 +1,37 @@
+//
+//  ScreenShotDetector.m
+//  TestApp
+//
+//  Created by ideveloper2 on 17/05/24.
+//
+
+#import "ScreenShotDetector.h"
+
+@implementation ShakebugSDKScreenShotDetector
+
+RCT_EXPORT_MODULE();
+
+- (void)startObserving {
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleScreenShot:) name:UIApplicationUserDidTakeScreenshotNotification object:nil];
+}
+
+- (void)stopObserving {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"ScreenshotTaken"];
+}
+
+- (void)handleScreenShot:(NSNotification *)notification {
+    NSDictionary *eventData = @{@"timestamp": @([[NSDate date] timeIntervalSince1970])};
+    [self sendScreenShotEvent:eventData];
+}
+
+- (void)sendScreenShotEvent:(NSDictionary *)eventData {
+    [self sendEventWithName:@"ScreenshotTaken" body:eventData];
+}
+
+@end
+
+

package/ios/Senors/RNSensorsAccelerometer.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 ShakebugSDKRNSensorsAccelerometer : 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/RNSensorsAccelerometer.m

@@ -0,0 +1,162 @@
+//  Accelerometer.m
+
+
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import "RNSensorsAccelerometer.h"
+#import "RNSensorsUtils.h"
+
+@implementation ShakebugSDKRNSensorsAccelerometer
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE();
+
+- (id) init {
+    self = [super init];
+    NSLog(@"ShakebugSDKRNSensorsAccelerometer");
+
+    if (self) {
+        self->_motionManager = [[CMMotionManager alloc] init];
+        self->logLevel = 0;
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"ShakebugSDKRNSensorsAccelerometer"];
+}
+
+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 isAccelerometerAvailable])
+    {
+        /* Start the accelerometer if it is not active already */
+        if([self->_motionManager isAccelerometerActive] == NO)
+        {
+            resolve(@YES);
+        } else {
+            reject(@"-1", @"Accelerometer is not active", nil);
+        }
+    }
+    else
+    {
+        reject(@"-1", @"Accelerometer is not available", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(setUpdateInterval:(double) interval) {
+    if (self->logLevel > 0) {
+        NSLog(@"setUpdateInterval: %f", interval);
+    }
+
+    double intervalInSeconds = interval / 1000;
+
+    [self->_motionManager setAccelerometerUpdateInterval:intervalInSeconds];
+}
+
+RCT_EXPORT_METHOD(setLogLevel:(int) level) {
+    if (level > 0) {
+        NSLog(@"setLogLevel: %d", level);
+    }
+
+    self->logLevel = level;
+}
+
+RCT_EXPORT_METHOD(getUpdateInterval:(RCTResponseSenderBlock) cb) {
+    double interval = self->_motionManager.accelerometerUpdateInterval;
+
+    if (self->logLevel > 0) {
+        NSLog(@"getUpdateInterval: %f", interval);
+    }
+
+    cb(@[[NSNull null], [NSNumber numberWithDouble:interval]]);
+}
+
+RCT_EXPORT_METHOD(getData:(RCTResponseSenderBlock) cb) {
+    double x = self->_motionManager.accelerometerData.acceleration.x;
+    double y = self->_motionManager.accelerometerData.acceleration.y;
+    double z = self->_motionManager.accelerometerData.acceleration.z;
+    double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:self->_motionManager.accelerometerData.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/startAccelerometerUpdates");
+    }
+
+    [self->_motionManager startAccelerometerUpdates];
+
+    /* Receive the accelerometer data on this block */
+    [self->_motionManager startAccelerometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                                               withHandler:^(CMAccelerometerData *accelerometerData, NSError *error)
+     {
+         double x = accelerometerData.acceleration.x;
+         double y = accelerometerData.acceleration.y;
+         double z = accelerometerData.acceleration.z;
+         double timestamp = [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:accelerometerData.timestamp];
+
+         if (self->logLevel > 1) {
+             NSLog(@"Updated accelerometer values: %f, %f, %f, %f", x, y, z, timestamp);
+         }
+
+         [self sendEventWithName:@"ShakebugSDKRNSensorsAccelerometer" 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 stopAccelerometerUpdates];
+}
+
+// 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/RNSensorsBarometer.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 ShakebugSDKRNSensorsBarometer : RCTEventEmitter <RCTBridgeModule> {
+    CMAltimeter *_altimeter;
+    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/RNSensorsBarometer.m

@@ -0,0 +1,141 @@
+//  Barometer.m
+
+
+#import "RNSensorsBarometer.h"
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import <CoreMotion/CoreMotion.h>
+#import "RNSensorsUtils.h"
+
+@implementation ShakebugSDKRNSensorsBarometer
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE();
+
+- (id) init {
+    self = [super init];
+    NSLog(@"ShakebugSDKRNSensorsBarometer");
+
+    if (self) {
+        self->_altimeter = [[CMAltimeter alloc] init];
+        self->logLevel = 0;
+    }
+    return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"ShakebugSDKRNSensorsBarometer"];
+}
+
++ (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 ([CMAltimeter isRelativeAltitudeAvailable])
+    {
+        resolve(@YES);
+    }
+    else
+    {
+        reject(@"-1", @"Barometer is not available", nil);
+    }
+}
+
+RCT_EXPORT_METHOD(setUpdateInterval:(double) interval) {
+    NSLog(@"Can not set update interval for barometer, doing nothing");
+}
+
+RCT_EXPORT_METHOD(setLogLevel:(int) level) {
+    if (level > 0) {
+        NSLog(@"setLogLevel: %f", level);
+    }
+
+    self->logLevel = level;
+}
+
+RCT_EXPORT_METHOD(getUpdateInterval:(RCTResponseSenderBlock) cb) {
+    NSLog(@"getUpdateInterval is not meaningul for a barometer sensor");
+    cb(@[[NSNull null], [NSNumber numberWithDouble:0.0]]);
+}
+
+RCT_EXPORT_METHOD(getData:(RCTResponseSenderBlock) cb) {
+    CMAltitudeData * _Nullable altitudeData = self->_altimeter;
+    if (altitudeData) {
+        if (self->logLevel > 0) {
+            NSLog(@"getData: %f, %f, %f", altitudeData.pressure.doubleValue, altitudeData.timestamp, [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:altitudeData.timestamp]);
+        }
+
+        cb(@[[NSNull null], @{
+                @"pressure" : @(altitudeData.pressure.doubleValue * 10.0),
+                @"timestamp" : [NSNumber numberWithDouble:[ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:altitudeData.timestamp]]
+            }]
+           );
+    }
+    else {
+        cb(@[[NSNull null], @{}]);
+    }
+}
+
+
+RCT_EXPORT_METHOD(startUpdates) {
+    if (self->logLevel > 0) {
+        NSLog(@"startUpdates/startRelativeAltitudeUpdates");
+    }
+
+    [self->_altimeter startRelativeAltitudeUpdatesToQueue:[NSOperationQueue mainQueue] withHandler:^(CMAltitudeData * _Nullable altitudeData, NSError * _Nullable error) {
+        if (error) {
+            NSLog(@"error while getting sensor data");
+        }
+
+        if (altitudeData) {
+            if (self->logLevel > 1) {
+                NSLog(@"Updated altitue value: %f, %f, %f", altitudeData.pressure.doubleValue, altitudeData.timestamp, [ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:altitudeData.timestamp]);
+            }
+
+            [self sendEventWithName:@"ShakebugSDKRNSensorsBarometer" body:@{
+                @"pressure" : @(altitudeData.pressure.doubleValue * 10.0),
+                @"timestamp" : [NSNumber numberWithDouble:[ShakebugSDKRNSensorsUtils sensorTimestampToEpochMilliseconds:altitudeData.timestamp]]
+            }];
+        }
+
+    }];
+}
+
+RCT_EXPORT_METHOD(stopUpdates) {
+    if(self->logLevel > 0) {
+        NSLog(@"stopUpdates");
+    }
+
+    [self->_altimeter stopRelativeAltitudeUpdates];
+}
+
+// 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->_altimeter) {
+        [self stopUpdates];
+    }
+}
+
+@end

package/ios/Senors/RNSensorsGravity.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 ShakebugSDKRNSensorsGravity : 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