Merge branch 'develop' of github.com:master-atul/react-native-exception-handler into develop

Author: a7ul

README.md

@@ -226,6 +226,34 @@ public class MainApplication extends Application implements ReactApplication {
 
 ```
 
+**Modifying Android Native Exception handler** (NATIVE CODE HAS TO BE WRITTEN) *recommended that you do this in android studio*
+
+- In the `android/app/src/main/java/[...]/MainActivity.java`
+
+```java
+import com.masteratul.exceptionhandler.ReactNativeExceptionHandlerModule;
+import com.masteratul.exceptionhandler.NativeExceptionHandlerIfc
+...
+...
+...
+public class MainApplication extends Application implements ReactApplication {
+...
+...
+  @Override
+  public void onCreate() {
+    ....
+    ....
+    ....
+    ReactNativeExceptionHandlerModule.setNativeExceptionHandler(new NativeExceptionHandlerIfc() {
+      @Override
+      public void handleNativeException(Thread thread, Throwable throwable, Thread.UncaughtExceptionHandler originalHandler) {
+        // Put your error handling code here
+      }
+    }//This will override the default behaviour of displaying the recover activity.
+  }
+
+```
+
 **Modifying iOS Native Exception handler UI** (NATIVE CODE HAS TO BE WRITTEN) *recommended that you do this in XCode*
 
 Unlike Android, in the case of iOS, there is no way to restart the app if it has crashed. Also, during a **Native_Exceptions** the UI becomes quite unstable since the exception occured on the main UI thread. Hence, none of the click or press handlers would work either.
@@ -431,6 +459,10 @@ This is specifically occuring when you use [wix library](http://wix.github.io/re
 setNativeExceptionHandler(nativeErrorCallback, false);
 ```
 
+### Previously defined exception handlers are not executed anymore
+
+A lot of frameworks (especially analytics sdk's) implement global exception handlers. In order to keep these frameworks working while using react-native-exception-hanlder, you can pass a boolean value as third argument to `setNativeExceptionHandler(..., ..., true`) what will trigger the execution of the last global handler registered.
+
 
 ## CONTRIBUTORS
 - [Atul R](https://github.com/master-atul)
@@ -447,6 +479,7 @@ setNativeExceptionHandler(nativeErrorCallback, false);
 - [TomMahle](https://github.com/TomMahle)
 - [Sébastien Krafft](https://github.com/skrafft)
 - [Mark Friedman](https://github.com/mark-friedman)
+- [Damien Solimando](https://github.com/dsolimando)
 
 ## TESTING NATIVE EXCEPTIONS/ERRORS
 

android/src/main/java/com/masteratul/exceptionhandler/NativeExceptionHandlerIfc.java

@@ -0,0 +1,5 @@
+package com.masteratul.exceptionhandler;
+
+public interface NativeExceptionHandlerIfc {
+    void handleNativeException(Thread thread, Throwable throwable, Thread.UncaughtExceptionHandler originalHandler);
+}

android/src/main/java/com/masteratul/exceptionhandler/ReactNativeExceptionHandlerModule.java

@@ -1,19 +1,21 @@
 
 package com.masteratul.exceptionhandler;
+
 import android.app.Activity;
 import android.content.Intent;
 import android.util.Log;
 
+import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.Callback;
 
 public class ReactNativeExceptionHandlerModule extends ReactContextBaseJavaModule {
 
   private ReactApplicationContext reactContext;
     private Activity activity;
     private static Class errorIntentTargetClass = DefaultErrorScreen.class;
+    private static NativeExceptionHandlerIfc nativeExceptionHandler;
     private Callback callbackHolder;
     private Thread.UncaughtExceptionHandler originalHandler;
 
@@ -29,39 +31,52 @@ public String getName() {
 
 
   @ReactMethod
-  public void setHandlerforNativeException(final boolean forceToQuit, Callback customHandler){
+  public void setHandlerforNativeException(
+          final boolean executeOriginalUncaughtExceptionHandler,
+          final boolean forceToQuit,
+          Callback customHandler) {
+
       callbackHolder = customHandler;
       originalHandler = Thread.getDefaultUncaughtExceptionHandler();
 
       Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+
           @Override
           public void uncaughtException(Thread thread, Throwable throwable) {
+
+          String stackTraceString = Log.getStackTraceString(throwable);
+          callbackHolder.invoke(stackTraceString);
+
+          if (nativeExceptionHandler != null) {
+              nativeExceptionHandler.handleNativeException(thread, throwable, originalHandler);
+          } else {
               activity = getCurrentActivity();
-              String stackTraceString = Log.getStackTraceString(throwable);
-              callbackHolder.invoke(stackTraceString);
-              Log.d("ERROR",stackTraceString);
 
-            
               Intent i = new Intent();
               i.setClass(activity, errorIntentTargetClass);
               i.putExtra("stack_trace_string",stackTraceString);
               i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-            
+
               activity.startActivity(i);
               activity.finish();
 
-              if (originalHandler != null) {
+              if (executeOriginalUncaughtExceptionHandler && originalHandler != null) {
                   originalHandler.uncaughtException(thread, throwable);
               }
 
               if (forceToQuit) {
-                System.exit(0);
+                  System.exit(0);
               }
           }
+          }
       });
   }
 
    public static void replaceErrorScreenActivityClass(Class errorScreenActivityClass){
        errorIntentTargetClass = errorScreenActivityClass;
    }
+
+    public static void setNativeExceptionHandler(NativeExceptionHandlerIfc nativeExceptionHandler) {
+        ReactNativeExceptionHandlerModule.nativeExceptionHandler = nativeExceptionHandler;
+    }
 }

index.js

@@ -1,37 +1,66 @@
+import { NativeModules, Platform } from "react-native";
 
-import {NativeModules, Platform} from 'react-native';
+const { ReactNativeExceptionHandler } = NativeModules;
 
-const {ReactNativeExceptionHandler} = NativeModules;
+const noop = () => { };
 
-const noop = () => {};
-
-export const setJSExceptionHandler = (customHandler = noop, allowedInDevMode = false) => {
-  if ((typeof allowedInDevMode !== 'boolean') || (typeof customHandler !== 'function')) {
-    console.log('setJSExceptionHandler is called with wrong argument types.. first argument should be callback function and second argument is optional should be a boolean');
-    console.log('Not setting the JS handler .. please fix setJSExceptionHandler call');
+export const setJSExceptionHandler = (
+  customHandler = noop,
+  allowedInDevMode = false
+) => {
+  if (
+    typeof allowedInDevMode !== "boolean" ||
+    typeof customHandler !== "function"
+  ) {
+    console.log(
+      "setJSExceptionHandler is called with wrong argument types.. first argument should be callback function and second argument is optional should be a boolean"
+    );
+    console.log(
+      "Not setting the JS handler .. please fix setJSExceptionHandler call"
+    );
     return;
   }
   const allowed = allowedInDevMode ? true : !__DEV__;
   if (allowed) {
     global.ErrorUtils.setGlobalHandler(customHandler);
     console.error = (message, error) => global.ErrorUtils.reportError(error); // sending console.error so that it can be caught
   } else {
-    console.log('Skipping setJSExceptionHandler: Reason: In DEV mode and allowedInDevMode = false');
+    console.log(
+      "Skipping setJSExceptionHandler: Reason: In DEV mode and allowedInDevMode = false"
+    );
   }
 };
 
 export const getJSExceptionHandler = () => global.ErrorUtils.getGlobalHandler();
 
-export const setNativeExceptionHandler = (customErrorHandler = noop, forceApplicationToQuit = true) => {
-  if ((typeof customErrorHandler !== 'function') || (typeof forceApplicationToQuit !== 'boolean')) {
-    console.log('setNativeExceptionHandler is called with wrong argument types.. first argument should be callback function and second argument is optional should be a boolean');
-    console.log('Not setting the native handler .. please fix setNativeExceptionHandler call');
+export const setNativeExceptionHandler = (
+  customErrorHandler = noop,
+  forceApplicationToQuit = true,
+  executeDefaultHandler = false
+) => {
+  if (
+    typeof customErrorHandler !== "function" ||
+    typeof forceApplicationToQuit !== "boolean"
+  ) {
+    console.log(
+      "setNativeExceptionHandler is called with wrong argument types.. first argument should be callback function and second argument is optional should be a boolean"
+    );
+    console.log(
+      "Not setting the native handler .. please fix setNativeExceptionHandler call"
+    );
     return;
   }
-  if (Platform.OS === 'ios') {
-    ReactNativeExceptionHandler.setHandlerforNativeException(customErrorHandler);
+  if (Platform.OS === "ios") {
+    ReactNativeExceptionHandler.setHandlerforNativeException(
+      executeDefaultHandler,
+      customErrorHandler
+    );
   } else {
-    ReactNativeExceptionHandler.setHandlerforNativeException(forceApplicationToQuit, customErrorHandler);
+    ReactNativeExceptionHandler.setHandlerforNativeException(
+      executeDefaultHandler,
+      forceApplicationToQuit,
+      customErrorHandler
+    );
   }
 };
 

ios/ReactNativeExceptionHandler.m

@@ -28,45 +28,52 @@ - (dispatch_queue_t)methodQueue
 //variable to hold the custom error handler passed while customizing native handler
 void (^nativeErrorCallbackBlock)(NSException *exception, NSString *readeableException);
 
+// variable to hold the previously defined error handler
+NSUncaughtExceptionHandler* previousNativeErrorCallbackBlock;
+
+BOOL callPreviousNativeErrorCallbackBlock = false;
+
 //variable to hold the js error handler when setting up the error handler in RN.
 void (^jsErrorCallbackBlock)(NSException *exception, NSString *readeableException);
 
 //variable that holds the default native error handler
 void (^defaultNativeErrorCallbackBlock)(NSException *exception, NSString *readeableException) =
 ^(NSException *exception, NSString *readeableException){
-
+    
     UIAlertController* alert = [UIAlertController
                                 alertControllerWithTitle:@"Unexpected error occured"
                                 message:[NSString stringWithFormat:@"%@\n%@",
                                          @"Apologies..The app will close now \nPlease restart the app\n",
                                          readeableException]
                                 preferredStyle:UIAlertControllerStyleAlert];
-
+    
     UIApplication* app = [UIApplication sharedApplication];
     UIViewController * rootViewController = app.delegate.window.rootViewController;
     [rootViewController presentViewController:alert animated:YES completion:nil];
-
+    
     [NSTimer scheduledTimerWithTimeInterval:5.0
                                      target:[ReactNativeExceptionHandler class]
                                    selector:@selector(releaseExceptionHold)
                                    userInfo:nil
                                     repeats:NO];
 };
 
-
 // ====================================
 // REACT NATIVE MODULE EXPOSED METHODS
 // ====================================
 
 RCT_EXPORT_MODULE();
 
 // METHOD TO INITIALIZE THE EXCEPTION HANDLER AND SET THE JS CALLBACK BLOCK
-RCT_EXPORT_METHOD(setHandlerforNativeException:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(setHandlerforNativeException:(BOOL)callPreviouslyDefinedHandler withCallback: (RCTResponseSenderBlock)callback)
 {
     jsErrorCallbackBlock = ^(NSException *exception, NSString *readeableException){
         callback(@[readeableException]);
     };
-
+    
+    previousNativeErrorCallbackBlock = NSGetUncaughtExceptionHandler();
+    callPreviousNativeErrorCallbackBlock = callPreviouslyDefinedHandler;
+    
     NSSetUncaughtExceptionHandler(&HandleException);
     signal(SIGABRT, SignalHandler);
     signal(SIGILL, SignalHandler);
@@ -105,14 +112,19 @@ - (void)handleException:(NSException *)exception
                                  [exception reason],
                                  [[exception userInfo] objectForKey:RNUncaughtExceptionHandlerAddressesKey]];
     dismissApp = false;
-
+    
+    
+    if (callPreviousNativeErrorCallbackBlock && previousNativeErrorCallbackBlock) {
+        previousNativeErrorCallbackBlock(exception);
+    }
+    
     if(nativeErrorCallbackBlock != nil){
         nativeErrorCallbackBlock(exception,readeableError);
     }else{
         defaultNativeErrorCallbackBlock(exception,readeableError);
     }
     jsErrorCallbackBlock(exception,readeableError);
-
+    
     CFRunLoopRef runLoop = CFRunLoopGetCurrent();
     CFArrayRef allModes = CFRunLoopCopyAllModes(runLoop);
     while (!dismissApp)
@@ -127,19 +139,19 @@ - (void)handleException:(NSException *)exception
             i++;
         }
     }
-
+    
     CFRelease(allModes);
-
+    
     NSSetUncaughtExceptionHandler(NULL);
     signal(SIGABRT, SIG_DFL);
     signal(SIGILL, SIG_DFL);
     signal(SIGSEGV, SIG_DFL);
     signal(SIGFPE, SIG_DFL);
     signal(SIGBUS, SIG_DFL);
     signal(SIGPIPE, SIG_DFL);
-
+    
     kill(getpid(), [[[exception userInfo] objectForKey:RNUncaughtExceptionHandlerSignalKey] intValue]);
-
+    
 }
 
 
@@ -154,14 +166,14 @@ void HandleException(NSException *exception)
     {
         return;
     }
-
+    
     NSArray *callStack = [ReactNativeExceptionHandler backtrace];
     NSMutableDictionary *userInfo =
     [NSMutableDictionary dictionaryWithDictionary:[exception userInfo]];
     [userInfo
      setObject:callStack
      forKey:RNUncaughtExceptionHandlerAddressesKey];
-
+    
     [[[ReactNativeExceptionHandler alloc] init]
      performSelectorOnMainThread:@selector(handleException:)
      withObject:
@@ -179,17 +191,17 @@ void SignalHandler(int signal)
     {
         return;
     }
-
+    
     NSMutableDictionary *userInfo =
     [NSMutableDictionary
      dictionaryWithObject:[NSNumber numberWithInt:signal]
      forKey:RNUncaughtExceptionHandlerSignalKey];
-
+    
     NSArray *callStack = [ReactNativeExceptionHandler backtrace];
     [userInfo
      setObject:callStack
      forKey:RNUncaughtExceptionHandlerAddressesKey];
-
+    
     [[[ReactNativeExceptionHandler alloc] init]
      performSelectorOnMainThread:@selector(handleException:)
      withObject:
@@ -216,7 +228,7 @@ + (NSArray *)backtrace
     void* callstack[128];
     int frames = backtrace(callstack, 128);
     char **strs = backtrace_symbols(callstack, frames);
-
+    
     int i;
     NSMutableArray *backtrace = [NSMutableArray arrayWithCapacity:frames];
     for (
@@ -228,8 +240,9 @@ + (NSArray *)backtrace
         [backtrace addObject:[NSString stringWithUTF8String:strs[i]]];
     }
     free(strs);
-
+    
     return backtrace;
 }
 
 @end
+