shakebug-react-native 1.0.14

package/ios/ImageOrVideoPicker/ShakebugSDKImagePickerUtils.m

@@ -0,0 +1,194 @@
+#import "ShakebugSDKImagePickerUtils.h"
+#import <CoreServices/CoreServices.h>
+#import <PhotosUI/PhotosUI.h>
+
+@implementation ShakebugSDKImagePickerUtils
+
++ (void) setupPickerFromOptions:(UIImagePickerController *)picker options:(NSDictionary *)options target:(RNImagePickerTarget)target
+{
+    if ([[options objectForKey:@"mediaType"] isEqualToString:@"video"]) {
+
+        if ([[options objectForKey:@"videoQuality"] isEqualToString:@"high"]) {
+            picker.videoQuality = UIImagePickerControllerQualityTypeHigh;
+        }
+        else if ([[options objectForKey:@"videoQuality"] isEqualToString:@"low"]) {
+            picker.videoQuality = UIImagePickerControllerQualityTypeLow;
+        }
+        else {
+            picker.videoQuality = UIImagePickerControllerQualityTypeMedium;
+        }
+    }
+    
+    if (target == camera) {
+        picker.sourceType = UIImagePickerControllerSourceTypeCamera;
+
+        if ([options[@"durationLimit"] doubleValue] > 0) {
+            picker.videoMaximumDuration = [options[@"durationLimit"] doubleValue];
+        }
+
+        if ([options[@"cameraType"] isEqualToString:@"front"]) {
+            picker.cameraDevice = UIImagePickerControllerCameraDeviceFront;
+        } else {
+            picker.cameraDevice = UIImagePickerControllerCameraDeviceRear;
+        }
+    } else {
+        picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
+    }
+
+    if ([options[@"mediaType"] isEqualToString:@"video"]) {
+        picker.mediaTypes = @[(NSString *)kUTTypeMovie];
+    } else if ([options[@"mediaType"] isEqualToString:@"photo"]) {
+        picker.mediaTypes = @[(NSString *)kUTTypeImage];
+    } else if ([options[@"mediaType"] isEqualToString:@"mixed"]) {
+        picker.mediaTypes = @[(NSString *)kUTTypeImage, (NSString *)kUTTypeMovie];
+    }
+
+    picker.modalPresentationStyle = [RCTConvert UIModalPresentationStyle:options[@"presentationStyle"]];
+}
+
++ (PHPickerConfiguration *)makeConfigurationFromOptions:(NSDictionary *)options target:(RNImagePickerTarget)target API_AVAILABLE(ios(14))
+{
+#if __has_include(<PhotosUI/PHPicker.h>)
+    PHPickerConfiguration *configuration;
+    
+    if(options[@"includeExtra"]) {
+        PHPhotoLibrary *photoLibrary = [PHPhotoLibrary sharedPhotoLibrary];
+        configuration = [[PHPickerConfiguration alloc] initWithPhotoLibrary:photoLibrary];
+    } else {
+        configuration = [[PHPickerConfiguration alloc] init];
+    }
+
+    if ([[options objectForKey:@"assetRepresentationMode"] isEqualToString:@"current"]) {
+        configuration.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeCurrent;
+    }
+    else if ([[options objectForKey:@"assetRepresentationMode"] isEqualToString:@"compatible"]) {
+        configuration.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeCompatible;
+    }
+    else {
+       configuration.preferredAssetRepresentationMode = PHPickerConfigurationAssetRepresentationModeAutomatic;
+    }
+    
+    configuration.selectionLimit = [options[@"selectionLimit"] integerValue];
+
+    if ([options[@"mediaType"] isEqualToString:@"video"]) {
+        configuration.filter = [PHPickerFilter videosFilter];
+    } else if ([options[@"mediaType"] isEqualToString:@"photo"]) {
+        configuration.filter = [PHPickerFilter imagesFilter];
+    } else if ((target == library) && ([options[@"mediaType"] isEqualToString:@"mixed"])) {
+        configuration.filter = [PHPickerFilter anyFilterMatchingSubfilters: @[PHPickerFilter.imagesFilter, PHPickerFilter.videosFilter]];
+    }
+    return configuration;
+#else
+    return nil;
+#endif
+}
+
+
++ (BOOL) isSimulator
+{
+    #if TARGET_OS_SIMULATOR
+        return YES;
+    #endif
+    return NO;
+}
+
++ (NSString*) getFileType:(NSData *)imageData
+{
+    const uint8_t firstByteJpg = 0xFF;
+    const uint8_t firstBytePng = 0x89;
+    const uint8_t firstByteGif = 0x47;
+    
+    uint8_t firstByte;
+    [imageData getBytes:&firstByte length:1];
+    switch (firstByte) {
+      case firstByteJpg:
+        return @"jpg";
+      case firstBytePng:
+        return @"png";
+      case firstByteGif:
+        return @"gif";
+      default:
+        return @"jpg";
+    }
+}
+
++ (NSString *) getFileTypeFromUrl:(NSURL *)url {
+    CFStringRef fileExtension = (__bridge CFStringRef)[url pathExtension];
+    CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, fileExtension, NULL);
+    CFStringRef MIMEType = UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType);
+    CFRelease(UTI);
+    return (__bridge_transfer NSString *)MIMEType;
+}
+
++ (NSNumber *) getFileSizeFromUrl:(NSURL *)url {
+    NSError *attributesError;
+    NSDictionary *fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:[url path] error:&attributesError];
+    NSNumber *fileSizeNumber = [fileAttributes objectForKey:NSFileSize];
+    long fileSize = [fileSizeNumber longLongValue];
+
+    if (attributesError) {
+        return nil;
+    }
+
+    return [NSNumber numberWithLong:fileSize];
+}
+
++ (CGSize)getVideoDimensionsFromUrl:(NSURL *)url {
+    AVURLAsset *asset = [AVURLAsset URLAssetWithURL:url options:nil];
+    NSArray *tracks = [asset tracksWithMediaType:AVMediaTypeVideo];
+    
+    if ([tracks count] > 0) {
+        AVAssetTrack *track = [tracks objectAtIndex:0];
+        return track.naturalSize;
+    }
+    
+    return CGSizeMake(0, 0);
+}
+
++ (UIImage*)resizeImage:(UIImage*)image maxWidth:(float)maxWidth maxHeight:(float)maxHeight
+{
+    if ((maxWidth == 0) || (maxHeight == 0)) {
+        return image;
+    }
+    
+    if (image.size.width <= maxWidth && image.size.height <= maxHeight) {
+        return image;
+    }
+
+    CGSize newSize = CGSizeMake(image.size.width, image.size.height);
+    if (maxWidth < newSize.width) {
+        newSize = CGSizeMake(maxWidth, (maxWidth / newSize.width) * newSize.height);
+    }
+    if (maxHeight < newSize.height) {
+        newSize = CGSizeMake((maxHeight / newSize.height) * newSize.width, maxHeight);
+    }
+    
+    newSize.width = (int)newSize.width;
+    newSize.height = (int)newSize.height;
+
+    UIGraphicsBeginImageContext(newSize);
+    [image drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
+    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
+    if (newImage == nil) {
+        NSLog(@"could not scale image");
+    }
+    UIGraphicsEndImageContext();
+
+    return newImage;
+}
+
++ (PHAsset *)fetchPHAssetOnIOS13:(NSDictionary<NSString *,id> *)info
+{
+    NSURL *referenceURL = [info objectForKey:UIImagePickerControllerReferenceURL];
+
+    if(!referenceURL) {
+      return nil;
+    }
+
+    // We fetch the asset like this to support iOS 10 and lower
+    // see: https://stackoverflow.com/a/52529904/4177049
+    PHFetchResult* fetchResult = [PHAsset fetchAssetsWithALAssetURLs:@[referenceURL] options:nil];
+    return fetchResult.firstObject;
+}
+
+@end

package/ios/MicrophonePermissionManager.h

@@ -0,0 +1,14 @@
+//
+//  MicrophonePermissionManager.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 28/02/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <AVFoundation/AVFoundation.h>
+
+@interface RCT_EXTERN_MODULE(MicrophonePermissionManager, NSObject)
+RCT_EXTERN_METHOD(requestMicrophonePermission:(RCTResponseSenderBlock)callback)
+@end

package/ios/MicrophonePermissionManager.m

@@ -0,0 +1,35 @@
+// MicrophonePermissionManager.m
+
+#import <React/RCTBridgeModule.h>
+#import <AVFoundation/AVFoundation.h>
+
+@interface MicrophonePermissionManager : NSObject <RCTBridgeModule>
+@end
+
+@implementation MicrophonePermissionManager
+
+RCT_EXPORT_MODULE();
+
+RCT_EXPORT_METHOD(requestMicrophonePermission:(RCTResponseSenderBlock)callback) {
+  AVAudioSession *audioSession = [AVAudioSession sharedInstance];
+
+  if (!audioSession) {
+    callback(@[@"AVAudioSession is not available", @(NO)]);
+    return;
+  }
+
+  NSError *error = nil;
+  [audioSession requestRecordPermission:^(BOOL granted) {
+    if (granted) {
+      callback(@[[NSNull null], @(YES)]);
+    } else {
+      callback(@[[NSNull null], @(NO)]);
+    }
+  }];
+
+  if (error) {
+    callback(@[error.localizedDescription, @(NO)]);
+  }
+}
+
+@end

package/ios/NetInfo/RNCConnectionState.h

@@ -0,0 +1,42 @@
+//
+//  RNCConnectionState.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <SystemConfiguration/SystemConfiguration.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Based on the ConnectionType enum described in the W3C Network Information API spec
+// (https://wicg.github.io/netinfo/).
+static NSString *const RNCConnectionTypeUnknown = @"unknown";
+static NSString *const RNCConnectionTypeNone = @"none";
+static NSString *const RNCConnectionTypeWifi = @"wifi";
+static NSString *const RNCConnectionTypeCellular = @"cellular";
+static NSString *const RNCConnectionTypeEthernet = @"ethernet";
+
+// Based on the EffectiveConnectionType enum described in the W3C Network Information API spec
+// (https://wicg.github.io/netinfo/).
+static NSString *const RNCCellularGeneration2g = @"2g";
+static NSString *const RNCCellularGeneration3g = @"3g";
+static NSString *const RNCCellularGeneration4g = @"4g";
+static NSString *const RNCCellularGeneration5g = @"5g";
+
+@interface ShakebugSDKRNCConnectionState : NSObject
+
+- (instancetype)init;
+- (instancetype)initWithReachabilityFlags:(SCNetworkReachabilityFlags)flags;
+- (BOOL)isEqualToConnectionState:(ShakebugSDKRNCConnectionState *)otherState;
+
+@property (nonatomic, strong, readonly) NSString *type;
+@property (nullable, nonatomic, strong, readonly) NSString *cellularGeneration;
+@property (nonatomic, readonly) BOOL connected;
+@property (nonatomic, readonly) BOOL expensive;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NetInfo/RNCConnectionState.m

@@ -0,0 +1,119 @@
+//
+//  RNCConnectionState.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+
+#import "RNCConnectionState.h"
+#if !TARGET_OS_TV && !TARGET_OS_MACCATALYST && !TARGET_OS_VISION
+#import <CoreTelephony/CTTelephonyNetworkInfo.h>
+#endif
+
+#if TARGET_OS_TV || TARGET_OS_OSX || TARGET_OS_MACCATALYST || TARGET_OS_VISION
+#include <ifaddrs.h>
+#endif
+
+@implementation ShakebugSDKRNCConnectionState
+
+// Creates a new "blank" state
+- (instancetype)init
+{
+    self = [super init];
+    if (self) {
+        _type = RNCConnectionTypeUnknown;
+        _cellularGeneration = nil;
+        _expensive = false;
+    }
+    return self;
+}
+
+// Creates the state from the given reachability references
+- (instancetype)initWithReachabilityFlags:(SCNetworkReachabilityFlags)flags
+{
+    self = [self init];
+    if (self) {
+        _type = RNCConnectionTypeUnknown;
+        _cellularGeneration = nil;
+        _expensive = false;
+
+        if ((flags & kSCNetworkReachabilityFlagsReachable) == 0 ||
+            (flags & kSCNetworkReachabilityFlagsConnectionRequired) != 0) {
+            _type = RNCConnectionTypeNone;
+        }
+#if !TARGET_OS_TV && !TARGET_OS_OSX && !TARGET_OS_MACCATALYST && !TARGET_OS_VISION
+        else if ((flags & kSCNetworkReachabilityFlagsIsWWAN) != 0) {
+            _type = RNCConnectionTypeCellular;
+            _expensive = true;
+
+            CTTelephonyNetworkInfo *netinfo = [[CTTelephonyNetworkInfo alloc] init];
+            if (netinfo) {
+                if ([netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyGPRS] ||
+                    [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyEdge] ||
+                    [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyCDMA1x]) {
+                    _cellularGeneration = RNCCellularGeneration2g;
+                } else if ([netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyWCDMA] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyHSDPA] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyHSUPA] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyCDMAEVDORev0] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyCDMAEVDORevA] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyCDMAEVDORevB] ||
+                           [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyeHRPD]) {
+                    _cellularGeneration = RNCCellularGeneration3g;
+                } else if ([netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyLTE]) {
+                    _cellularGeneration = RNCCellularGeneration4g;
+                } else if (@available(iOS 14.1, *)) {
+                    if ([netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyNRNSA] ||
+                        [netinfo.currentRadioAccessTechnology isEqualToString:CTRadioAccessTechnologyNR]) {
+                        _cellularGeneration = RNCCellularGeneration5g;
+                    }
+                }
+            }
+        }
+#endif
+        else {
+            _type = RNCConnectionTypeWifi;
+#if TARGET_OS_TV || TARGET_OS_OSX || TARGET_OS_MACCATALYST || TARGET_OS_VISION
+            struct ifaddrs *interfaces = NULL;
+            struct ifaddrs *temp_addr = NULL;
+            int success = 0;
+            // retrieve the current interfaces - returns 0 on success
+            success = getifaddrs(&interfaces);
+            if (success == 0) {
+                // Loop through linked list of interfaces
+                temp_addr = interfaces;
+                while (temp_addr != NULL) {
+                    if (temp_addr->ifa_addr->sa_family == AF_INET) {
+                        // Check if interface is en0 which is the ethernet connection on the Apple TV
+                        NSString* ifname = [NSString stringWithUTF8String:temp_addr->ifa_name];
+                        if ([ifname isEqualToString:@"en0"]) {
+                            _type = RNCConnectionTypeEthernet;
+                        }
+                    }
+                    temp_addr = temp_addr->ifa_next;
+                }
+            }
+            // Free memory
+            freeifaddrs(interfaces);
+#endif
+        }
+    }
+    return self;
+}
+
+// Checks if two states are equal
+- (BOOL)isEqualToConnectionState:(ShakebugSDKRNCConnectionState *)otherState
+{
+    return [self.type isEqualToString:otherState.type]
+            && [self.cellularGeneration isEqualToString:otherState.cellularGeneration]
+            && self.expensive == otherState.expensive;
+}
+
+- (BOOL)connected
+{
+    return ![self.type isEqualToString:RNCConnectionTypeNone] && ![self.type isEqualToString:RNCConnectionTypeUnknown];
+}
+
+@end

package/ios/NetInfo/RNCConnectionStateWatcher.h

@@ -0,0 +1,31 @@
+//
+//  RNCConnectionStateWatcher.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+
+#import <Foundation/Foundation.h>
+#import "RNCConnectionState.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class ShakebugSDKRNCConnectionStateWatcher;
+
+
+@protocol RNCConnectionStateWatcherDelegate
+
+- (void)connectionStateWatcher:(ShakebugSDKRNCConnectionStateWatcher *)connectionStateWatcher didUpdateState:(ShakebugSDKRNCConnectionState *)state;
+
+@end
+
+@interface ShakebugSDKRNCConnectionStateWatcher : NSObject
+
+- (instancetype)initWithDelegate:(id<RNCConnectionStateWatcherDelegate>)delegate;
+- (ShakebugSDKRNCConnectionState *)currentState;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NetInfo/RNCConnectionStateWatcher.m

@@ -0,0 +1,136 @@
+//
+//  RNCConnectionStateWatcher.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import "RNCConnectionStateWatcher.h"
+#import <SystemConfiguration/SystemConfiguration.h>
+#import <netinet/in.h>
+
+@interface ShakebugSDKRNCConnectionStateWatcher () <NSURLSessionDataDelegate>
+
+@property (nonatomic) SCNetworkReachabilityRef reachabilityRef;
+@property (nullable, weak, nonatomic) id<RNCConnectionStateWatcherDelegate> delegate;
+@property (nonatomic) SCNetworkReachabilityFlags lastFlags;
+@property (nonnull, strong, nonatomic) ShakebugSDKRNCConnectionState *state;
+
+@end
+
+@implementation ShakebugSDKRNCConnectionStateWatcher
+
+#pragma mark - Lifecycle
+
+- (instancetype)initWithDelegate:(id<RNCConnectionStateWatcherDelegate>)delegate
+{
+    self = [self init];
+    if (self) {
+        _delegate = delegate;
+        _state = [[ShakebugSDKRNCConnectionState alloc] init];
+        _reachabilityRef = [self createReachabilityRef];
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    self.delegate = nil;
+
+    if (self.reachabilityRef != nil) {
+        SCNetworkReachabilityUnscheduleFromRunLoop(self.reachabilityRef, CFRunLoopGetMain(), kCFRunLoopCommonModes);
+        CFRelease(self.reachabilityRef);
+        self.reachabilityRef = nil;
+    }
+}
+
+#pragma mark - Public methods
+
+- (ShakebugSDKRNCConnectionState *)currentState
+{
+    return self.state;
+}
+
+#pragma mark - Callback
+
+typedef void (^RNCConnectionStateUpdater)(SCNetworkReachabilityFlags);
+
+static void RNCReachabilityCallback(__unused SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info)
+{
+    RNCConnectionStateUpdater block = (__bridge id)info;
+    if (block != nil) {
+        block(flags);
+    }
+}
+
+static void RNCReachabilityContextRelease(const void *info)
+{
+    Block_release(info);
+}
+
+static const void *RNCReachabilityContextRetain(const void *info)
+{
+    return Block_copy(info);
+}
+
+- (void)update:(SCNetworkReachabilityFlags)flags
+{
+    self.lastFlags = flags;
+    self.state = [[ShakebugSDKRNCConnectionState alloc] initWithReachabilityFlags:flags];
+}
+
+#pragma mark - Setters
+
+- (void)setState:(ShakebugSDKRNCConnectionState *)state
+{
+    if (![state isEqualToConnectionState:_state]) {
+        _state = state;
+
+        [self updateDelegate];
+    }
+}
+
+#pragma mark - Utilities
+
+- (void)updateDelegate
+{
+    [self.delegate connectionStateWatcher:self didUpdateState:self.state];
+}
+
+- (SCNetworkReachabilityRef)createReachabilityRef
+{
+    struct sockaddr_in zeroAddress;
+    bzero(&zeroAddress, sizeof(zeroAddress));
+    zeroAddress.sin_len = sizeof(zeroAddress);
+    zeroAddress.sin_family = AF_INET;
+
+    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr *) &zeroAddress);
+
+    __weak typeof(self) weakSelf = self;
+    RNCConnectionStateUpdater callback = ^(SCNetworkReachabilityFlags flags) {
+        __strong __typeof(weakSelf) strongSelf = weakSelf;
+        if (strongSelf != nil) {
+            [strongSelf update:flags];
+        }
+    };
+
+    SCNetworkReachabilityContext context = {
+        0,
+        (__bridge void *)callback,
+        RNCReachabilityContextRetain,
+        RNCReachabilityContextRelease,
+        NULL
+    };
+    SCNetworkReachabilitySetCallback(reachability, RNCReachabilityCallback, &context);
+    SCNetworkReachabilityScheduleWithRunLoop(reachability, CFRunLoopGetMain(), kCFRunLoopCommonModes);
+
+    // Set the state the first time
+    SCNetworkReachabilityFlags flags;
+    SCNetworkReachabilityGetFlags(reachability, &flags);
+    [self update:flags];
+
+    return reachability;
+}
+
+@end

package/ios/NetInfo/RNCNetInfo.h

@@ -0,0 +1,13 @@
+//
+//  RNCNetInfo.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <React/RCTEventEmitter.h>
+
+@interface ShakebugSDKRNCNetInfo : RCTEventEmitter
+
+@end