shakebug-react-native 1.0.14

package/ios/GetLocals/ShakebugSDKRNLocalize.h

@@ -0,0 +1,21 @@
+//
+//  RNLocalize.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <RNLocalizeSpec/RNLocalizeSpec.h>
+@interface ShakebugSDKRNLocalize : NSObject <NativeRNLocalizeSpec>
+
+#else
+
+#import <React/RCTBridgeModule.h>
+@interface ShakebugSDKRNLocalize : NSObject <RCTBridgeModule>
+
+#endif
+
+@end

package/ios/GetLocals/ShakebugSDKRNLocalize.m

@@ -0,0 +1,296 @@
+//
+//  RNLocalize.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import "ShakebugSDKRNLocalize.h"
+
+@implementation ShakebugSDKRNLocalize
+
+RCT_EXPORT_MODULE();
+
+// Internal
+
+- (NSString * _Nullable)getCountryCodeForLocale:(NSLocale *)locale {
+  NSString *countryCode = [locale objectForKey:NSLocaleCountryCode];
+
+  if ([countryCode isEqualToString:@"419"])
+    return @"UN";
+
+  return countryCode != nil ? [countryCode uppercaseString] : nil;
+}
+
+- (NSString * _Nullable)getCurrencyCodeForLocale:(NSLocale *)locale {
+  NSString *currencyCode = [locale objectForKey:NSLocaleCurrencyCode];
+  return currencyCode != nil ? [currencyCode uppercaseString] : nil;
+}
+
+- (NSString *)getLanguageTagForLanguageCode:(NSString *)languageCode
+                                          scriptCode:(NSString * _Nullable)scriptCode
+                                         countryCode:(NSString *)countryCode {
+  NSString *languageTag = [languageCode copy];
+
+  if (scriptCode != nil)
+    languageTag = [languageTag stringByAppendingFormat:@"-%@", scriptCode];
+
+  return [languageTag stringByAppendingFormat:@"-%@", countryCode];
+}
+
+// Implementation
+
+- (NSString *)getCalendarImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+  NSString *calendar = [[currentLocale objectForKey:NSLocaleCalendar] calendarIdentifier];
+
+  if ([calendar isEqualToString:NSCalendarIdentifierGregorian])
+    return @"gregorian";
+  if ([calendar isEqualToString:NSCalendarIdentifierBuddhist])
+    return @"buddhist";
+  if ([calendar isEqualToString:NSCalendarIdentifierCoptic])
+    return @"coptic";
+  if ([calendar isEqualToString:NSCalendarIdentifierEthiopicAmeteMihret])
+    return @"ethiopic";
+  if ([calendar isEqualToString:NSCalendarIdentifierEthiopicAmeteAlem])
+    return @"ethiopic-amete-alem";
+  if ([calendar isEqualToString:NSCalendarIdentifierHebrew])
+    return @"hebrew";
+  if ([calendar isEqualToString:NSCalendarIdentifierIndian])
+    return @"indian";
+  if ([calendar isEqualToString:NSCalendarIdentifierIslamic])
+    return @"islamic";
+  if ([calendar isEqualToString:NSCalendarIdentifierIslamicUmmAlQura])
+    return @"islamic-umm-al-qura";
+  if ([calendar isEqualToString:NSCalendarIdentifierIslamicCivil])
+    return @"islamic-civil";
+  if ([calendar isEqualToString:NSCalendarIdentifierIslamicTabular])
+    return @"islamic-tabular";
+  if ([calendar isEqualToString:NSCalendarIdentifierISO8601])
+    return @"iso8601";
+  if ([calendar isEqualToString:NSCalendarIdentifierJapanese])
+    return @"japanese";
+  if ([calendar isEqualToString:NSCalendarIdentifierPersian])
+    return @"persian";
+
+  return @"gregorian";
+}
+
+- (NSString *)getCountryImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+  NSString *currentCountryCode = [self getCountryCodeForLocale:currentLocale];
+
+  if (currentCountryCode == nil)
+    return @"US"; // Only happen in the simulator
+
+  return currentCountryCode;
+}
+
+- (NSArray *)getCurrenciesImpl {
+  NSMutableArray<NSString *> *currencies = [NSMutableArray array];
+  NSString *currentCurrencyCode = [self getCurrencyCodeForLocale:[NSLocale currentLocale]];
+
+  if (currentCurrencyCode != nil)
+    [currencies addObject:currentCurrencyCode];
+
+  for (NSString *identifier in [NSLocale preferredLanguages]) {
+    NSLocale *systemLocale = [[NSLocale alloc] initWithLocaleIdentifier:identifier];
+    NSString *currencyCode = [self getCurrencyCodeForLocale:systemLocale];
+
+    if (currencyCode != nil && ![currencies containsObject:currencyCode])
+      [currencies addObject:currencyCode];
+  }
+
+  if ([currencies count] == 0)
+    [currencies addObject:@"USD"];
+
+  return currencies;
+}
+
+- (NSArray *)getLocalesImpl {
+  NSMutableArray<NSString *> *languageTags = [NSMutableArray array];
+  NSMutableArray<NSDictionary *> *locales = [NSMutableArray array];
+
+  for (NSString *identifier in [NSLocale preferredLanguages]) {
+    NSLocale *systemLocale = [[NSLocale alloc] initWithLocaleIdentifier:identifier];
+    NSString *systemLanguageCode = [systemLocale objectForKey:NSLocaleLanguageCode];
+
+    NSString *languageCode = [systemLanguageCode lowercaseString];
+    NSString *scriptCode = [systemLocale objectForKey:NSLocaleScriptCode];
+    NSString *countryCode = [self getCountryCodeForLocale:systemLocale];
+    bool isRTL = [NSLocale characterDirectionForLanguage:languageCode] == NSLocaleLanguageDirectionRightToLeft;
+
+    if (countryCode == nil)
+      countryCode = [self getCountryImpl];
+
+    NSString *languageTag = [self getLanguageTagForLanguageCode:languageCode
+                                                     scriptCode:scriptCode
+                                                    countryCode:countryCode];
+
+    NSMutableDictionary *locale = [[NSMutableDictionary alloc] initWithDictionary:@{
+      @"languageCode": languageCode,
+      @"countryCode": countryCode,
+      @"languageTag": languageTag,
+      @"isRTL": @(isRTL),
+    }];
+
+    if (scriptCode != nil)
+      [locale setObject:scriptCode forKey:@"scriptCode"];
+
+    if (![languageTags containsObject:languageTag]) {
+      [locales addObject:locale];
+      [languageTags addObject:languageTag];
+    }
+  }
+
+  return locales;
+}
+
+- (NSDictionary *)getNumberFormatSettingsImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+
+  return @{
+    @"decimalSeparator": [currentLocale objectForKey:NSLocaleDecimalSeparator],
+    @"groupingSeparator": [currentLocale objectForKey:NSLocaleGroupingSeparator],
+  };
+}
+
+- (NSString *)getTemperatureUnitImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+  NSMeasurementFormatter *formatter = [NSMeasurementFormatter new];
+
+  [formatter setLocale:currentLocale];
+
+  NSMeasurement *temperature = [[NSMeasurement alloc] initWithDoubleValue:42.0 unit:[NSUnitTemperature celsius]];
+  NSString *formatted = [formatter stringFromMeasurement:temperature];
+  NSString *unitCharacter = [formatted substringFromIndex:[formatted length] - 1];
+
+  return [unitCharacter isEqualToString:@"C"] ? @"celsius" : @"fahrenheit";
+}
+
+- (NSString *)getTimeZoneImpl {
+  return [[NSTimeZone localTimeZone] name];
+}
+
+- (bool)uses24HourClockImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+  NSDateFormatter* formatter = [NSDateFormatter new];
+
+  [formatter setLocale:currentLocale];
+  [formatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]];
+  [formatter setDateStyle:NSDateFormatterNoStyle];
+  [formatter setTimeStyle:NSDateFormatterShortStyle];
+
+  NSDate *date = [NSDate dateWithTimeIntervalSince1970:72000];
+  return [[formatter stringFromDate:date] containsString:@"20"];
+}
+
+- (bool)usesMetricSystemImpl {
+  NSLocale *currentLocale = [NSLocale currentLocale];
+  return [[currentLocale objectForKey:NSLocaleUsesMetricSystem] boolValue];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// New architecture
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeRNLocalizeSpecJSI>(params);
+}
+
+- (NSString *)getCalendar {
+  return [self getCalendarImpl];
+}
+
+- (NSString *)getCountry {
+  return [self getCountryImpl];
+}
+
+- (NSArray<NSString *> *)getCurrencies {
+  return [self getCurrenciesImpl];
+}
+
+- (NSArray<NSDictionary *> *)getLocales {
+  return [self getLocalesImpl];
+}
+
+- (NSDictionary *)getNumberFormatSettings {
+  return [self getNumberFormatSettingsImpl];
+}
+
+- (NSString *)getTemperatureUnit {
+  return [self getTemperatureUnitImpl];
+}
+
+- (NSString *)getTimeZone {
+  return [self getTimeZoneImpl];
+}
+
+- (NSNumber *)uses24HourClock {
+  return @([self uses24HourClockImpl]);
+}
+
+- (NSNumber *)usesMetricSystem {
+  return @([self usesMetricSystemImpl]);
+}
+
+- (NSNumber * _Nullable)usesAutoDateAndTime {
+  return nil;
+}
+
+- (NSNumber * _Nullable)usesAutoTimeZone {
+  return nil;
+}
+
+#else
+
+// Old architecture
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getCalendar) {
+  return [self getCalendarImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getCountry) {
+  return [self getCountryImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getCurrencies) {
+  return [self getCurrenciesImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getLocales) {
+  return [self getLocalesImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getNumberFormatSettings) {
+  return [self getNumberFormatSettingsImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getTemperatureUnit) {
+  return [self getTemperatureUnitImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getTimeZone) {
+  return [self getTimeZoneImpl];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(uses24HourClock) {
+  return @([self uses24HourClockImpl]);
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(usesMetricSystem) {
+  return @([self usesMetricSystemImpl]);
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(usesAutoDateAndTime) {
+  return nil;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(usesAutoTimeZone) {
+  return nil;
+}
+
+#endif
+
+@end

package/ios/GetLocation/SettingsUtil.h

@@ -0,0 +1,16 @@
+//
+//  SettingsUtil.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@interface SettingsUtil : NSObject
+
++ (void) openAppSettings;
+
+@end

package/ios/GetLocation/SettingsUtil.m

@@ -0,0 +1,21 @@
+//
+//  SettingsUtil.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import "SettingsUtil.h"
+
+@implementation SettingsUtil
+
++ (void) openAppSettings {
+  if ([[[UIDevice currentDevice] systemVersion] floatValue] < 10.0) {
+    [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
+  } else {
+    [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString] options:@{} completionHandler:nil];
+  }
+}
+
+@end

package/ios/GetLocation/ShakebugSDKLocationModule.h

@@ -0,0 +1,17 @@
+//
+//  LocationModule.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConvert.h>
+#import <CoreLocation/CoreLocation.h>
+#import "SettingsUtil.h"
+
+@interface ShakebugSDKLocationModule : NSObject <RCTBridgeModule, CLLocationManagerDelegate>
+
+@end

package/ios/GetLocation/ShakebugSDKLocationModule.m

@@ -0,0 +1,218 @@
+//
+//  LocationModule.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+
+#import "ShakebugSDKLocationModule.h"
+#import <React/RCTLog.h>
+
+@implementation ShakebugSDKLocationModule
+
+RCT_EXPORT_MODULE(ShakebugSDKReactNativeGetLocation);
+
+NSTimer* mTimer;
+CLLocationManager* mLocationManager;
+RCTPromiseResolveBlock mResolve;
+RCTPromiseRejectBlock mReject;
+double mTimeout;
+
+RCT_EXPORT_METHOD(getCurrentPosition: (NSDictionary*) options
+                  promise: (RCTPromiseResolveBlock) resolve
+                  rejecter: (RCTPromiseRejectBlock) reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        @try {
+            [self cancelPreviousRequest];
+            
+            if (@available(iOS 14.0, *)) {
+                // should use locationManagerDidChangeAuthorization
+            } else {
+                if (![CLLocationManager locationServicesEnabled]) {
+                    [[NSException
+                      exceptionWithName:@"Unavailable"
+                      reason:@"Location service is unavailable"
+                      userInfo:nil]
+                     raise];
+                }
+            }
+            
+            bool enableHighAccuracy = [RCTConvert BOOL:options[@"enableHighAccuracy"]];
+            double timeout = [RCTConvert double:options[@"timeout"]];
+            
+            CLLocationManager *locationManager = [[CLLocationManager alloc] init];
+            locationManager.delegate = self;
+            locationManager.distanceFilter = kCLDistanceFilterNone;
+            locationManager.desiredAccuracy = enableHighAccuracy ? kCLLocationAccuracyBest : kCLLocationAccuracyNearestTenMeters;
+            
+            mResolve = resolve;
+            mReject = reject;
+            mLocationManager = locationManager;
+            mTimeout = timeout;
+            
+            [self startUpdatingLocation];
+        }
+        @catch (NSException *exception) {
+            NSMutableDictionary * info = [NSMutableDictionary dictionary];
+            [info setValue:exception.name forKey:@"ExceptionName"];
+            [info setValue:exception.reason forKey:@"ExceptionReason"];
+            [info setValue:exception.callStackReturnAddresses forKey:@"ExceptionCallStackReturnAddresses"];
+            [info setValue:exception.callStackSymbols forKey:@"ExceptionCallStackSymbols"];
+            [info setValue:exception.userInfo forKey:@"ExceptionUserInfo"];
+            
+            NSError *error = [[NSError alloc] initWithDomain:@"Location not available." code:1 userInfo:info];
+            reject(@"UNAVAILABLE", @"Location not available", error);
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(openAppSettings: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        @try {
+            [SettingsUtil openAppSettings];
+            resolve(nil);
+        }
+        @catch (NSException *exception) {
+            NSMutableDictionary * info = [NSMutableDictionary dictionary];
+            [info setValue:exception.name forKey:@"ExceptionName"];
+            [info setValue:exception.reason forKey:@"ExceptionReason"];
+            [info setValue:exception.callStackReturnAddresses forKey:@"ExceptionCallStackReturnAddresses"];
+            [info setValue:exception.callStackSymbols forKey:@"ExceptionCallStackSymbols"];
+            [info setValue:exception.userInfo forKey:@"ExceptionUserInfo"];
+            
+            NSError *error = [[NSError alloc] initWithDomain:@"openAppSettings" code:0 userInfo:info];
+            reject(@"openAppSettings", @"Could not open settings.", error);
+        }
+    });
+}
+
+- (void) locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations {
+    if (locations.count > 0 && mResolve != nil) {
+        CLLocation* location = locations[0];
+        
+        NSDictionary* locationResult = @{
+            @"latitude": @(location.coordinate.latitude),
+            @"longitude": @(location.coordinate.longitude),
+            @"altitude": @(location.altitude),
+            @"speed": @(location.speed),
+            @"accuracy": @(location.horizontalAccuracy),
+            @"time": @(location.timestamp.timeIntervalSince1970 * 1000),
+            @"verticalAccuracy": @(location.verticalAccuracy),
+            @"course": @(location.course),
+        };
+        
+        mResolve(locationResult);
+    }
+    [self clearReferences];
+}
+
+- (void) locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error {
+    if (mReject != nil) {
+        mReject(@"UNAVAILABLE", @"Location not available", error);
+    }
+    [self clearReferences];
+}
+
+- (void) runTimeout:(id)sender {
+    if (mReject != nil) {
+        mReject(@"TIMEOUT", @"Location timed out", nil);
+    }
+    [self clearReferences];
+}
+
+- (void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status {
+    if ([self isAuthorized]) {
+        [self startUpdatingLocation];
+    } else if ([self isAuthorizationDenied]) {
+        mReject(@"UNAUTHORIZED", @"Authorization denied", nil);
+        [self clearReferences];
+    }
+}
+
+- (void) clearReferences {
+    if (mTimer != nil) {
+        [mTimer invalidate];
+    }
+    if (mLocationManager != nil) {
+        [mLocationManager stopUpdatingLocation];
+    }
+    mResolve = nil;
+    mReject = nil;
+    mLocationManager = nil;
+    mTimer = nil;
+    mTimeout = 0;
+}
+
+- (void) cancelPreviousRequest {
+    if (mLocationManager != nil) {
+        mReject(@"CANCELLED", @"Location cancelled by another request", nil);
+    }
+    [self clearReferences];
+}
+
+- (void) startUpdatingLocation {
+    if (![self isAuthorized]) {
+        NSLog(@"[locationManager requestWhenInUseAuthorization]");
+        // [mLocationManager requestWhenInUseAuthorization];
+        return;
+    }
+    
+    NSLog(@"[locationManager startUpdatingLocation]");
+    [mLocationManager startUpdatingLocation];
+    
+    if (mTimeout > 0) {
+        NSTimeInterval timeoutInterval = mTimeout / 1000.0;
+        mTimer = [NSTimer scheduledTimerWithTimeInterval:timeoutInterval
+                                                  target:self
+                                                selector:@selector(runTimeout:)
+                                                userInfo:nil
+                                                 repeats:NO];
+    }
+}
+
+- (void)locationManagerDidChangeAuthorization:(CLLocationManager *)manager {
+    if (@available(iOS 14.0, *)) {
+        if (![CLLocationManager locationServicesEnabled]) {
+            mReject(@"UNAVAILABLE", @"Location not available", nil);
+            [self clearReferences];
+            return;
+        }
+        
+        switch ([manager authorizationStatus]) {
+            case kCLAuthorizationStatusAuthorizedAlways:
+            case kCLAuthorizationStatusAuthorizedWhenInUse: {
+                [self startUpdatingLocation];
+                break;
+            }
+            case kCLAuthorizationStatusNotDetermined: {
+                // do nothing
+                break;
+            }
+            case kCLAuthorizationStatusDenied:
+            case kCLAuthorizationStatusRestricted:
+            default: {
+                mReject(@"UNAUTHORIZED", @"Authorization denied", nil);
+                [self clearReferences];
+                break;
+            }
+        }
+    }
+}
+
+- (BOOL) isAuthorizationDenied {
+    int authorizationStatus = [CLLocationManager authorizationStatus];
+    
+    return authorizationStatus == kCLAuthorizationStatusDenied;
+}
+
+- (BOOL) isAuthorized {
+    int authorizationStatus = [CLLocationManager authorizationStatus];
+    
+    return authorizationStatus == kCLAuthorizationStatusAuthorizedWhenInUse
+    || authorizationStatus == kCLAuthorizationStatusAuthorizedAlways;
+}
+
+@end

package/ios/ImageOrVideoPicker/ShakebugSDKImagePickerManager.h

@@ -0,0 +1,40 @@
+#import <React/RCTBridgeModule.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RNImagePickerTarget) {
+  camera = 1,
+  library
+};
+
+@implementation RCTConvert(PresentationStyle)
+
+// see: https://developer.apple.com/documentation/uikit/uimodalpresentationstyle?language=objc
+RCT_ENUM_CONVERTER(
+    UIModalPresentationStyle,
+    (@{
+      @"currentContext": @(UIModalPresentationCurrentContext),
+      @"fullScreen": @(UIModalPresentationFullScreen),
+      @"pageSheet": @(UIModalPresentationPageSheet),
+      @"formSheet": @(UIModalPresentationFormSheet),
+      @"popover": @(UIModalPresentationPopover),
+      @"overFullScreen": @(UIModalPresentationOverFullScreen),
+      @"overCurrentContext": @(UIModalPresentationOverCurrentContext)
+    }),
+    UIModalPresentationCurrentContext,
+    integerValue)
+
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNImagePickerSpec.h"
+@interface ShakebugSDKImagePickerManager : NSObject <NativeImagePickerSpec>
+@end
+
+#else
+
+@interface ShakebugSDKImagePickerManager : NSObject <RCTBridgeModule>
+@end
+
+#endif