@react-native-firebase/crashlytics 26.4.0 → 27.1.0

package/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.h

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+
+// Plain Objective-C helper (see docs/ios-spm.mdx and
+// okf-bundle/ios-spm-native-imports.md) that owns every call touching
+// `FIRCrashlytics` / exception models for RNFBCrashlyticsModule, plus the
+// Swift debugger probe. This keeps RNFBCrashlyticsModule.mm free of Firebase
+// Crashlytics imports and `*-Swift.h`: under SPM an Objective-C++ (.mm)
+// TurboModule cannot `@import` Firebase (or parse a Swift-generated header
+// that uses module imports) when C++ modules are disabled (required by React
+// Native's JSI headers).
+@interface RNFBCrashlyticsHelper : NSObject
+
+/** Cached `sysctl` debugger-attach probe (Swift `RNFBCrashlyticsDebuggerProbe`). */
++ (BOOL)isDebuggerAttached;
+
++ (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion;
+
++ (void)deleteUnsentReports;
+
++ (BOOL)didCrashDuringPreviousExecution;
+
++ (void)log:(NSString *)message;
+
++ (void)sendUnsentReports;
+
++ (void)setCustomValue:(NSString *)value forKey:(NSString *)key;
+
+/** Applies each entry via `setCustomValue:forKey:` (Module setAttributes path). */
++ (void)setCustomKeysAndValues:(NSDictionary *)attributes;
+
++ (void)setUserID:(NSString *)userId;
+
+/**
+ * Records a JS exception model.
+ * Each frame dictionary uses keys: `fn` (symbol), `file`, `line` (number).
+ */
++ (void)recordJavaScriptErrorWithMessage:(NSString *)message
+                                  frames:(NSArray<NSDictionary *> *)frames
+             isUnhandledPromiseRejection:(BOOL)isUnhandledPromiseRejection;
+
+@end
+
+/** Upper bound (seconds) a JS fatal waits for its record to save before the process exits. */
+FOUNDATION_EXPORT const NSTimeInterval RNFBCrashlyticsFatalExitWatchdogTimeout;
+
+/**
+ * Records a JS fatal, then terminates the process once the record has had a chance to save.
+ *
+ * `-[FIRCrashlytics recordExceptionModel:]` saves asynchronously: once Crashlytics' context-init
+ * promise is fulfilled, the save block is dispatched to the main queue. Terminating on the
+ * calling queue right after recording usually loses that save. Instead the terminator is
+ * enqueued on `terminateQueue` (the main queue in production), so it runs FIFO after the save
+ * block. A watchdog on `watchdogQueue` terminates after `watchdogTimeout` if `terminateQueue`
+ * is hung. The terminator runs at most once.
+ *
+ * Known limit: a JS fatal recorded before Crashlytics finished initialising queues its save as a
+ * promise observer instead of a main-queue block, so it can still be lost.
+ * The FIFO ordering also relies on FBLPromise's default dispatch queue being the main queue; if an
+ * app changes it, the save runs off the main queue and the terminator can run first, losing the
+ * report. The watchdog only covers a hung `terminateQueue`.
+ */
+@interface RNFBCrashlyticsFatalExit : NSObject
+
+/** Production instance: terminates with `exit(0)` on the main queue, 2 s watchdog. */
++ (instancetype)shared;
+
+- (instancetype)initWithTerminator:(dispatch_block_t)terminator
+                    terminateQueue:(dispatch_queue_t)terminateQueue
+                     watchdogQueue:(dispatch_queue_t)watchdogQueue
+                   watchdogTimeout:(NSTimeInterval)watchdogTimeout NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/**
+ * Runs `record` synchronously, then schedules termination, even when `record` raises. Returns NO
+ * without running `record` when an earlier call already started terminating (a second fatal
+ * while waiting).
+ */
+- (BOOL)recordThenTerminate:(dispatch_block_t)record;
+
+@end

package/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.m

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#if __has_include(<Firebase/Firebase.h>)
+#import <Firebase/Firebase.h>
+#elif __has_include(<FirebaseCrashlytics/FirebaseCrashlytics.h>)
+#import <FirebaseCore/FirebaseCore.h>
+#import <FirebaseCrashlytics/FirebaseCrashlytics.h>
+#else
+@import FirebaseCore;
+@import FirebaseCrashlytics;
+#endif
+
+#if __has_include(<RNFBCrashlytics/RNFBCrashlytics-Swift.h>)
+#import <RNFBCrashlytics/RNFBCrashlytics-Swift.h>
+#elif __has_include("RNFBCrashlytics-Swift.h")
+#import "RNFBCrashlytics-Swift.h"
+#elif __has_include("RNFBCrashlyticsDebuggerProbe-Swift.inc")
+#import "RNFBCrashlyticsDebuggerProbe-Swift.inc"
+#else
+#error "RNFBCrashlyticsDebuggerProbe Swift interface not found"
+#endif
+
+#import <stdatomic.h>
+
+#import "RNFBCrashlyticsHelper.h"
+
+@implementation RNFBCrashlyticsHelper
+
++ (BOOL)isDebuggerAttached {
+  return [RNFBCrashlyticsDebuggerProbe isDebuggerAttached];
+}
+
++ (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion {
+  [[FIRCrashlytics crashlytics] checkForUnsentReportsWithCompletion:^(BOOL unsentReports) {
+    if (completion != nil) {
+      completion(unsentReports);
+    }
+  }];
+}
+
++ (void)deleteUnsentReports {
+  [[FIRCrashlytics crashlytics] deleteUnsentReports];
+}
+
++ (BOOL)didCrashDuringPreviousExecution {
+  return [[FIRCrashlytics crashlytics] didCrashDuringPreviousExecution];
+}
+
++ (void)log:(NSString *)message {
+  [[FIRCrashlytics crashlytics] log:message];
+}
+
++ (void)sendUnsentReports {
+  [[FIRCrashlytics crashlytics] sendUnsentReports];
+}
+
++ (void)setCustomValue:(NSString *)value forKey:(NSString *)key {
+  [[FIRCrashlytics crashlytics] setCustomValue:value forKey:key];
+}
+
++ (void)setCustomKeysAndValues:(NSDictionary *)attributes {
+  NSArray *keys = [attributes allKeys];
+  for (NSString *key in keys) {
+    [[FIRCrashlytics crashlytics] setCustomValue:attributes[key] forKey:key];
+  }
+}
+
++ (void)setUserID:(NSString *)userId {
+  [[FIRCrashlytics crashlytics] setUserID:userId];
+}
+
++ (void)recordJavaScriptErrorWithMessage:(NSString *)message
+                                  frames:(NSArray<NSDictionary *> *)frames
+             isUnhandledPromiseRejection:(BOOL)isUnhandledPromiseRejection {
+  NSMutableArray *stackTrace = [[NSMutableArray alloc] init];
+  for (NSDictionary *stackFrame in frames) {
+    NSString *symbol = stackFrame[@"fn"];
+    NSString *file = stackFrame[@"file"];
+    uint32_t line = (uint32_t)[stackFrame[@"line"] unsignedIntValue];
+    FIRStackFrame *customFrame = [FIRStackFrame stackFrameWithSymbol:symbol file:file line:line];
+    [stackTrace addObject:customFrame];
+  }
+
+  NSString *name = @"JavaScriptError";
+  if (isUnhandledPromiseRejection) {
+    name = @"UnhandledPromiseRejection";
+  }
+
+  FIRExceptionModel *exceptionModel = [FIRExceptionModel exceptionModelWithName:name
+                                                                         reason:message];
+  exceptionModel.stackTrace = stackTrace;
+
+  [[FIRCrashlytics crashlytics] recordExceptionModel:exceptionModel];
+}
+
+@end
+
+const NSTimeInterval RNFBCrashlyticsFatalExitWatchdogTimeout = 2.0;
+
+@implementation RNFBCrashlyticsFatalExit {
+  dispatch_block_t _terminator;
+  dispatch_queue_t _terminateQueue;
+  dispatch_queue_t _watchdogQueue;
+  NSTimeInterval _watchdogTimeout;
+  atomic_bool _exiting;
+  atomic_bool _terminated;
+}
+
++ (instancetype)shared {
+  static RNFBCrashlyticsFatalExit *shared;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    shared = [[RNFBCrashlyticsFatalExit alloc]
+        initWithTerminator:^{
+          // Coverage exception: ends the process, so no test can run it.
+          exit(0);
+        }
+            terminateQueue:dispatch_get_main_queue()
+             watchdogQueue:dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
+           watchdogTimeout:RNFBCrashlyticsFatalExitWatchdogTimeout];
+  });
+  return shared;
+}
+
+- (instancetype)initWithTerminator:(dispatch_block_t)terminator
+                    terminateQueue:(dispatch_queue_t)terminateQueue
+                     watchdogQueue:(dispatch_queue_t)watchdogQueue
+                   watchdogTimeout:(NSTimeInterval)watchdogTimeout {
+  if (self = [super init]) {
+    _terminator = [terminator copy];
+    _terminateQueue = terminateQueue;
+    _watchdogQueue = watchdogQueue;
+    _watchdogTimeout = watchdogTimeout;
+    atomic_init(&_exiting, false);
+    atomic_init(&_terminated, false);
+  }
+  return self;
+}
+
+- (BOOL)recordThenTerminate:(dispatch_block_t)record {
+  if (atomic_exchange(&_exiting, true)) {
+    return NO;
+  }
+  @try {
+    record();
+  } @catch (NSException *exception) {
+    // The guard is already set, so terminate anyway rather than leave the app running with every
+    // later fatal ignored.
+    NSLog(@"RNFBCrashlytics: recording JS fatal failed: %@", exception);
+  }
+  dispatch_block_t terminateOnce = ^{
+    [self terminateOnce];
+  };
+  // FIFO behind the Crashlytics save block that recordExceptionModel: enqueued on main.
+  dispatch_async(_terminateQueue, terminateOnce);
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_watchdogTimeout * NSEC_PER_SEC)),
+                 _watchdogQueue, terminateOnce);
+  return YES;
+}
+
+- (void)terminateOnce {
+  if (!atomic_exchange(&_terminated, true)) {
+    _terminator();
+  }
+}
+
+@end

package/ios/RNFBCrashlytics/RNFBCrashlyticsModule.mm

@@ -15,23 +15,17 @@
  *
  */
 
-#include <Foundation/Foundation.h>
-#include <sys/sysctl.h>
-
+// This module intentionally has no Firebase imports and no `*-Swift.h` —
+// see RNFBCrashlyticsHelper.h. Every Firebase Crashlytics SDK call (and the
+// Swift debugger probe) is routed through the plain Objective-C
+// RNFBCrashlyticsHelper class instead, which can safely `@import`
+// FirebaseCrashlytics / import the generated Swift interface because it
+// compiles as ObjC, not ObjC++.
 #import <React/RCTConvert.h>
 #import <React/RCTLog.h>
-#import <React/RCTUtils.h>
-
-#if __has_include(<Firebase/Firebase.h>)
-#import <Firebase/Firebase.h>
-#elif __has_include(<FirebaseCrashlytics/FirebaseCrashlytics.h>)
-#import <FirebaseCore/FirebaseCore.h>
-#import <FirebaseCrashlytics/FirebaseCrashlytics.h>
-#else
-@import FirebaseCore;
-@import FirebaseCrashlytics;
-#endif
+
 #import "RNFBApp/RNFBSharedUtils.h"
+#import "RNFBCrashlyticsHelper.h"
 #import "RNFBCrashlyticsInitProvider.h"
 #import "RNFBCrashlyticsModule.h"
 #import "RNFBPreferences.h"
@@ -58,7 +52,7 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
   constants[@"isCrashlyticsJavascriptExceptionHandlerChainingEnabled"] =
       @([RCTConvert BOOL:@([RNFBCrashlyticsInitProvider
                              isCrashlyticsJavascriptExceptionHandlerChainingEnabled])]);
-  if ([self isDebuggerAttached]) {
+  if ([RNFBCrashlyticsHelper isDebuggerAttached]) {
     RCTLog(
         @"Crashlytics - WARNING: Debugger detected. Crashlytics will not receive crash reports.");
   }
@@ -74,14 +68,15 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 }
 
 - (void)checkForUnsentReports:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
-  [[FIRCrashlytics crashlytics] checkForUnsentReportsWithCompletion:^(BOOL unsentReports) {
+  (void)reject;
+  [RNFBCrashlyticsHelper checkForUnsentReportsWithCompletion:^(BOOL unsentReports) {
     resolve([NSNumber numberWithBool:unsentReports]);
   }];
 }
 
 - (void)crash {
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
-    if ([self isDebuggerAttached]) {
+    if ([RNFBCrashlyticsHelper isDebuggerAttached]) {
       RCTLog(
           @"Crashlytics - WARNING: Debugger detected. Crashlytics will not receive crash reports.");
     }
@@ -96,15 +91,21 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 - (void)crashWithStackPromise:(JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict
                       resolve:(RCTPromiseResolveBlock)resolve
                        reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
-    if ([self isDebuggerAttached]) {
+    if ([RNFBCrashlyticsHelper isDebuggerAttached]) {
       RCTLog(
           @"Crashlytics - WARNING: Debugger detected. Crashlytics will not receive crash reports.");
     }
-    [self recordJavaScriptError:jsErrorDict];
-
-    ELog(@"Crashlytics - Crash logged. Terminating app.");
-    exit(0);
+    // Coverage exception: this branch ends the process, so neither XCTest nor e2e can observe it.
+    // Keep it a thin delegate; ordering, watchdog and the second-fatal guard live in
+    // RNFBCrashlyticsFatalExit (unit-tested). The promise is intentionally never resolved: that
+    // keeps the JS global handler suspended (no chaining to the previous handler, no
+    // fall-through) until termination.
+    ELog(@"Crashlytics - Logging crash and terminating app.");
+    [[RNFBCrashlyticsFatalExit shared]
+        recordThenTerminate:[self javaScriptErrorRecorder:jsErrorDict]];
+    return;
   } else {
     RCTLog(@"Crashlytics - INFO: crashlytics collection is not enabled, not crashing.");
   }
@@ -112,37 +113,41 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 }
 
 - (void)deleteUnsentReports:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
-  [[FIRCrashlytics crashlytics] deleteUnsentReports];
+  (void)reject;
+  [RNFBCrashlyticsHelper deleteUnsentReports];
   resolve([NSNull null]);
 }
 
 - (void)didCrashOnPreviousExecution:(RCTPromiseResolveBlock)resolve
                              reject:(RCTPromiseRejectBlock)reject {
-  BOOL didCrash = [[FIRCrashlytics crashlytics] didCrashDuringPreviousExecution];
+  (void)reject;
+  BOOL didCrash = [RNFBCrashlyticsHelper didCrashDuringPreviousExecution];
   resolve([NSNumber numberWithBool:didCrash]);
 }
 
 - (void)log:(NSString *)message {
-  [[FIRCrashlytics crashlytics] log:message];
+  [RNFBCrashlyticsHelper log:message];
 }
 
 - (void)logPromise:(NSString *)message
            resolve:(RCTPromiseResolveBlock)resolve
             reject:(RCTPromiseRejectBlock)reject {
-  [[FIRCrashlytics crashlytics] log:message];
+  (void)reject;
+  [RNFBCrashlyticsHelper log:message];
   resolve([NSNull null]);
 }
 
 - (void)sendUnsentReports {
-  [[FIRCrashlytics crashlytics] sendUnsentReports];
+  [RNFBCrashlyticsHelper sendUnsentReports];
 }
 
 - (void)setAttribute:(NSString *)key
                value:(NSString *)value
              resolve:(RCTPromiseResolveBlock)resolve
               reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
-    [[FIRCrashlytics crashlytics] setCustomValue:value forKey:key];
+    [RNFBCrashlyticsHelper setCustomValue:value forKey:key];
   }
   resolve([NSNull null]);
 }
@@ -150,12 +155,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 - (void)setAttributes:(NSDictionary *)attributes
               resolve:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
-    NSArray *keys = [attributes allKeys];
-
-    for (NSString *key in keys) {
-      [[FIRCrashlytics crashlytics] setCustomValue:attributes[key] forKey:key];
-    }
+    [RNFBCrashlyticsHelper setCustomKeysAndValues:attributes];
   }
   resolve([NSNull null]);
 }
@@ -163,8 +165,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 - (void)setUserId:(NSString *)userId
           resolve:(RCTPromiseResolveBlock)resolve
            reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
-    [[FIRCrashlytics crashlytics] setUserID:userId];
+    [RNFBCrashlyticsHelper setUserID:userId];
   }
   resolve([NSNull null]);
 }
@@ -178,6 +181,7 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 - (void)recordErrorPromise:(JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   if ([RNFBCrashlyticsInitProvider isCrashlyticsCollectionEnabled]) {
     [self recordJavaScriptError:jsErrorDict];
   }
@@ -187,60 +191,38 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 - (void)setCrashlyticsCollectionEnabled:(BOOL)enabled
                                 resolve:(RCTPromiseResolveBlock)resolve
                                  reject:(RCTPromiseRejectBlock)reject {
+  (void)reject;
   [[RNFBPreferences shared] setBooleanValue:@"crashlytics_auto_collection_enabled"
                                   boolValue:enabled];
   resolve([NSNull null]);
 }
 
 - (void)recordJavaScriptError:(JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict {
+  [self javaScriptErrorRecorder:jsErrorDict]();
+}
+
+// Converts the codegen struct to Foundation values up front, so the returned block captures no
+// C++ references and can be handed to RNFBCrashlyticsFatalExit.
+- (dispatch_block_t)javaScriptErrorRecorder:
+    (JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict {
   NSString *message = jsErrorDict.message();
   auto stackFrames = jsErrorDict.frames();
-  NSMutableArray *stackTrace = [[NSMutableArray alloc] init];
+  NSMutableArray *frames = [[NSMutableArray alloc] init];
   BOOL isUnhandledPromiseRejection = jsErrorDict.isUnhandledRejection();
 
   for (const auto &stackFrame : stackFrames) {
-    FIRStackFrame *customFrame = [FIRStackFrame stackFrameWithSymbol:stackFrame.fn()
-                                                                file:stackFrame.file()
-                                                                line:(uint32_t)stackFrame.line()];
-    [stackTrace addObject:customFrame];
-  }
-
-  NSString *name = @"JavaScriptError";
-  if (isUnhandledPromiseRejection) {
-    name = @"UnhandledPromiseRejection";
+    [frames addObject:@{
+      @"fn" : stackFrame.fn() ?: @"",
+      @"file" : stackFrame.file() ?: @"",
+      @"line" : @((NSUInteger)stackFrame.line()),
+    }];
   }
 
-  FIRExceptionModel *exceptionModel = [FIRExceptionModel exceptionModelWithName:name
-                                                                         reason:message];
-  exceptionModel.stackTrace = stackTrace;
-
-  [[FIRCrashlytics crashlytics] recordExceptionModel:exceptionModel];
-}
-
-- (BOOL)isDebuggerAttached {
-  static BOOL debuggerIsAttached = NO;
-
-  static dispatch_once_t debuggerPredicate;
-  dispatch_once(&debuggerPredicate, ^{
-    struct kinfo_proc info;
-    size_t info_size = sizeof(info);
-    int name[4];
-
-    name[0] = CTL_KERN;
-    name[1] = KERN_PROC;
-    name[2] = KERN_PROC_PID;
-    name[3] = getpid();
-
-    if (sysctl(name, 4, &info, &info_size, NULL, 0) == -1) {
-      ELog(@"Crashlytics ERROR: Checking for a running debugger via sysctl() failed: %s",
-           strerror(errno));
-      debuggerIsAttached = false;
-    }
-
-    if (!debuggerIsAttached && (info.kp_proc.p_flag & P_TRACED) != 0) debuggerIsAttached = true;
-  });
-
-  return debuggerIsAttached;
+  return ^{
+    [RNFBCrashlyticsHelper recordJavaScriptErrorWithMessage:message
+                                                     frames:frames
+                                isUnhandledPromiseRejection:isUnhandledPromiseRejection];
+  };
 }
 
 @end

package/ios/RNFBCrashlytics.xcodeproj/project.pbxproj

@@ -10,6 +10,8 @@
 		2744B98621F45429004F8E3F /* RNFBCrashlyticsModule.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2744B98521F45429004F8E3F /* RNFBCrashlyticsModule.mm */; };
 		2748D82422371C1C00FC8DC8 /* RNFBCrashlyticsInitProvider.m in Sources */ = {isa = PBXBuildFile; fileRef = 2748D82322371C1C00FC8DC8 /* RNFBCrashlyticsInitProvider.m */; };
 		C66637BB25FA560700DCAA51 /* RNFBCrashlyticsNativeHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = C66637BA25FA560700DCAA51 /* RNFBCrashlyticsNativeHelper.m */; };
+		RNFBCL000000000000000001 /* RNFBCrashlyticsDebuggerProbe.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBCL000000000000000002 /* RNFBCrashlyticsDebuggerProbe.swift */; };
+		RNFBCL000000000000000003 /* RNFBCrashlyticsHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = RNFBCL000000000000000005 /* RNFBCrashlyticsHelper.m */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -32,6 +34,9 @@
 		2748D82322371C1C00FC8DC8 /* RNFBCrashlyticsInitProvider.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBCrashlyticsInitProvider.m; sourceTree = "<group>"; };
 		C66637BA25FA560700DCAA51 /* RNFBCrashlyticsNativeHelper.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBCrashlyticsNativeHelper.m; sourceTree = "<group>"; };
 		C66637BD25FA561D00DCAA51 /* RNFBCrashlyticsNativeHelper.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBCrashlyticsNativeHelper.h; sourceTree = "<group>"; };
+		RNFBCL000000000000000002 /* RNFBCrashlyticsDebuggerProbe.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBCrashlyticsDebuggerProbe.swift; path = RNFBCrashlytics/RNFBCrashlyticsDebuggerProbe.swift; sourceTree = SOURCE_ROOT; };
+		RNFBCL000000000000000004 /* RNFBCrashlyticsHelper.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBCrashlyticsHelper.h; path = RNFBCrashlytics/RNFBCrashlyticsHelper.h; sourceTree = SOURCE_ROOT; };
+		RNFBCL000000000000000005 /* RNFBCrashlyticsHelper.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBCrashlyticsHelper.m; path = RNFBCrashlytics/RNFBCrashlyticsHelper.m; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -58,6 +63,9 @@
 			children = (
 				2744B98421F45429004F8E3F /* RNFBCrashlyticsModule.h */,
 				2744B98521F45429004F8E3F /* RNFBCrashlyticsModule.mm */,
+				RNFBCL000000000000000004 /* RNFBCrashlyticsHelper.h */,
+				RNFBCL000000000000000005 /* RNFBCrashlyticsHelper.m */,
+				RNFBCL000000000000000002 /* RNFBCrashlyticsDebuggerProbe.swift */,
 				2748D82222371C0900FC8DC8 /* RNFBCrashlyticsInitProvider.h */,
 				2748D82322371C1C00FC8DC8 /* RNFBCrashlyticsInitProvider.m */,
 				C66637BD25FA561D00DCAA51 /* RNFBCrashlyticsNativeHelper.h */,
@@ -133,8 +141,10 @@
 			buildActionMask = 2147483647;
 			files = (
 				C66637BB25FA560700DCAA51 /* RNFBCrashlyticsNativeHelper.m in Sources */,
+				RNFBCL000000000000000003 /* RNFBCrashlyticsHelper.m in Sources */,
 				2748D82422371C1C00FC8DC8 /* RNFBCrashlyticsInitProvider.m in Sources */,
 				2744B98621F45429004F8E3F /* RNFBCrashlyticsModule.mm in Sources */,
+				RNFBCL000000000000000001 /* RNFBCrashlyticsDebuggerProbe.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -160,6 +170,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
+				DEFINES_MODULE = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
@@ -176,6 +187,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
@@ -199,6 +211,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DEFINES_MODULE = YES;
 				ENABLE_NS_ASSERTIONS = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
@@ -210,6 +223,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 				VALIDATE_PRODUCT = YES;
 			};