[Android] Add backwards compatible support for react-native 0.52.0 (#2580)

Support for react-native 0.52.0

Rename `DevCommandsHandlerProxy` to `DevHelperProxy` so it reflects the changes in RN. See d19afc73f5

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationActivity.java

 import com.reactnativenavigation.screens.NavigationType;
 import com.reactnativenavigation.screens.Screen;
 import com.reactnativenavigation.utils.OrientationHelper;
+import com.reactnativenavigation.utils.ReflectionUtils;
 import com.reactnativenavigation.views.SideMenu.Side;
 
 import java.util.List;
             public void run() {
                 layout.destroy();
                 modalController.destroy();
+
+                Object devSupportManager = ReflectionUtils.getDeclaredField(getReactGateway().getReactInstanceManager(), "mDevSupportManager");
+                if (ReflectionUtils.getDeclaredField(devSupportManager, "mRedBoxDialog") != null) { // RN >= 0.52
+                    ReflectionUtils.setField(devSupportManager, "mRedBoxDialog", null);
+                }
             }
         });
     }

android/app/src/main/java/com/reactnativenavigation/react/JsDevReloadListenerReplacer.java

 package com.reactnativenavigation.react;
 
 import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.bridge.JavaJSExecutor;
-import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
 import com.reactnativenavigation.utils.ReflectionUtils;
 
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
 class JsDevReloadListenerReplacer {
     private final ReactInstanceManager reactInstanceManager;
     private final Listener listener;
     }
 
     void replace() {
-        ReactInstanceDevCommandsHandler originalHandler = getOriginalHandler();
-        DevCommandsHandlerProxy proxy = new DevCommandsHandlerProxy(originalHandler, listener);
-        replaceInReactInstanceManager(proxy);
-        replaceInDevSupportManager(proxy);
-    }
+        Object originalHelper = getOriginalHelper();
 
-    private void replaceInDevSupportManager(DevCommandsHandlerProxy proxy) {
         Object devSupportManager = ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
-        ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", proxy);
-    }
 
-    private ReactInstanceDevCommandsHandler getOriginalHandler() {
-        return (ReactInstanceDevCommandsHandler) ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
+        Object proxy = Proxy.newProxyInstance(
+                originalHelper.getClass().getClassLoader(),
+                originalHelper.getClass().getInterfaces(),
+                new DevHelperProxy(originalHelper, listener));
+
+        if (ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface") == null) { // RN >= 0.52
+            ReflectionUtils.setField(devSupportManager, "mReactInstanceManagerHelper", proxy);
+        } else {                                                                                         // RN <= 0.51
+            ReflectionUtils.setField(reactInstanceManager, "mDevInterface", proxy);
+            ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", proxy);
+        }
     }
 
-    private void replaceInReactInstanceManager(DevCommandsHandlerProxy proxy) {
-        ReflectionUtils.setField(reactInstanceManager, "mDevInterface", proxy);
+
+    private Object getOriginalHelper() {
+        Object devInterface = ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
+
+        if (devInterface == null) { // RN >= 0.52
+            Object devSupportManager = ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
+            return ReflectionUtils.getDeclaredField(devSupportManager, "mReactInstanceManagerHelper");
+        }
+
+        return devInterface;        // RN <= 0.51
     }
 
-    private static class DevCommandsHandlerProxy implements ReactInstanceDevCommandsHandler {
-        private ReactInstanceDevCommandsHandler originalReactHandler;
+
+    private static class DevHelperProxy implements InvocationHandler {
+        private Object originalReactHelper;
         private final Listener listener;
 
-        DevCommandsHandlerProxy(ReactInstanceDevCommandsHandler originalReactHandler, Listener listener) {
-            this.originalReactHandler = originalReactHandler;
+        DevHelperProxy(Object originalReactHelper, Listener listener) {
+            this.originalReactHelper = originalReactHelper;
             this.listener = listener;
         }
 
         @Override
-        public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
-            listener.onJsDevReload();
-            originalReactHandler.onReloadWithJSDebugger(proxyExecutorFactory);
-        }
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            String methodName = method.getName();
 
-        @Override
-        public void onJSBundleLoadedFromServer() {
-            listener.onJsDevReload();
-            originalReactHandler.onJSBundleLoadedFromServer();
-        }
+            if (methodName.equals("onJSBundleLoadedFromServer") || methodName.equals("onReloadWithJSDebugger")) {
+                listener.onJsDevReload();
+            }
 
-        @Override
-        public void toggleElementInspector() {
-            originalReactHandler.toggleElementInspector();
+            return method.invoke(originalReactHelper, args);
         }
     }
 }