Unmount screens before handling bundle reload

When ever bundle was reloaded, all currently registered screens
where recreated since they were still attached to the react context.
This commit adds, in a very hacky way, means to respond to bundle
reload events.

android/app/src/main/java/com/reactnativenavigation/activities/BaseReactActivity.java

 package com.reactnativenavigation.activities;
 
+import android.content.BroadcastReceiver;
+import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.devsupport.DevServerHelper;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
 import com.reactnativenavigation.BuildConfig;
         return super.onKeyUp(keyCode, event);
     }
 
+    /**
+     * Called after bundle was reloaded. This is a good chance to clean up previously connected react views.
+     */
+    public void onJSBundleReloaded() {
+        removeAllReactViews();
+    }
+
+    protected abstract void removeAllReactViews();
+
     @Override
     public void onBackPressed() {
         if (getScreenStackSize() > 1) {

android/app/src/main/java/com/reactnativenavigation/activities/BottomTabActivity.java

         }
         this.onTabSelected(0, false);
     }
+
+    @Override
+    protected void removeAllReactViews() {
+        for (ScreenStack screenStack : mScreenStacks) {
+            screenStack.removeAllReactViews();
+        }
+    }
 }

android/app/src/main/java/com/reactnativenavigation/activities/RootActivity.java

         return 0;
     }
 
+    @Override
+    public void removeAllReactViews() {
+
+    }
 }

android/app/src/main/java/com/reactnativenavigation/activities/SingleScreenActivity.java

     public int getScreenStackSize() {
         return mScreenStack.getStackSize();
     }
+
+    @Override
+    protected void removeAllReactViews() {
+        mScreenStack.removeAllReactViews();
+    }
 }

android/app/src/main/java/com/reactnativenavigation/activities/TabActivity.java

 package com.reactnativenavigation.activities;
 
-import android.support.design.widget.CoordinatorLayout;
 import android.support.v4.view.ViewPager;
 import android.view.Menu;
 import android.view.ViewGroup;
         return ret;
     }
 
+    @Override
+    public void removeAllReactViews() {
+
+    }
+
     @Override
     public void push(Screen screen) {
         super.push(screen);

android/app/src/main/java/com/reactnativenavigation/core/RctManager.java

 package com.reactnativenavigation.core;
 
 import android.app.Application;
+import android.util.Log;
 
 import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaJSExecutor;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
 import com.reactnativenavigation.activities.BaseReactActivity;
 import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.utils.ContextProvider;
+import com.reactnativenavigation.utils.ReflectionUtils;
 
 import static com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
 
  * Created by guyc on 22/02/16.
  */
 public class RctManager {
+    private static final String TAG = "RctManager";
     private static final String KEY_EVENT_ID = "id";
     private static RctManager sInstance;
 
         }
 
         mReactManager = builder.build();
+        setupDevSupportHandler(mReactManager);
+
         return mReactManager;
     }
 
+    /**
+     * Inject our CustomDevCommandsHandler to {@code reactInstanceManager} so we can detect when the bundle was
+     * parsed and is about to load.
+     * @param reactInstanceManager
+     */
+    private void setupDevSupportHandler(ReactInstanceManager reactInstanceManager) {
+        final ReactInstanceDevCommandsHandler devInterface = (ReactInstanceDevCommandsHandler)
+                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
+        if (devInterface == null) {
+            Log.e(TAG, "Could not get field: mDevInterface");
+            return;
+        }
+
+        // Create customDevCommandsHandler
+        CustomDevCommandsHandler customDevCommandsHandler = new CustomDevCommandsHandler(devInterface);
+        ReflectionUtils.setField(reactInstanceManager, "mDevInterface", customDevCommandsHandler);
+
+        // Set customDevCommandsHandler in devSupportManager. Fun =).
+        DevSupportManager devSupportManager = (DevSupportManager)
+                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
+        ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", customDevCommandsHandler);
+    }
+
     public <T extends ReactContextBaseJavaModule> T getNativeModule(Class<T> nativeModuleClass) {
         if (mReactManager == null || mReactManager.getCurrentReactContext() == null) {
             return null;
         mReactManager = null;
         sInstance = null;
     }
+
+    /**
+     * Proxy for {@link ReactInstanceDevCommandsHandler} used by {@link DevSupportManager} for requesting React
+     * instance recreation. Used to notify {@link BaseReactActivity} that the bundle has been reloaded.
+     */
+    private static class CustomDevCommandsHandler implements ReactInstanceDevCommandsHandler {
+        private ReactInstanceDevCommandsHandler mCommandsHandler;
+
+        public CustomDevCommandsHandler(ReactInstanceDevCommandsHandler commandsHandler) {
+            mCommandsHandler = commandsHandler;
+        }
+
+        @Override
+        public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
+            onJSBundleReloaded();
+            mCommandsHandler.onReloadWithJSDebugger(proxyExecutorFactory);
+        }
+
+        @Override
+        public void onJSBundleLoadedFromServer() {
+            onJSBundleReloaded();
+            mCommandsHandler.onJSBundleLoadedFromServer();
+        }
+
+        /**
+         * Detach previously added ReactRootViews before handling bundle.
+         */
+        private void onJSBundleReloaded() {
+            BaseReactActivity context = ContextProvider.getActivityContext();
+            if (context != null) {
+                context.onJSBundleReloaded();
+            }
+        }
+
+        @Override
+        public void toggleElementInspector() {
+            mCommandsHandler.toggleElementInspector();
+        }
+    }
 }
 

android/app/src/main/java/com/reactnativenavigation/utils/IconUtils.java

 package com.reactnativenavigation.utils;
 
 import android.content.Context;
-import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
-import android.util.DisplayMetrics;
 
 import com.reactnativenavigation.BuildConfig;
 

android/app/src/main/java/com/reactnativenavigation/utils/ReflectionUtils.java

 package com.reactnativenavigation.utils;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 
 /**
  * Created by guyc on 14/04/16.
  */
 public class ReflectionUtils {
 
-    public static boolean setBooleanField(Object obj, String name, Boolean value) {
+    public static boolean setField(Object obj, String name, Object value) {
         Field field;
         try {
             field = obj.getClass().getDeclaredField(name);
             field.setAccessible(true);
             field.set(obj, value);
             return true;
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        } catch (IllegalAccessException e) {
+        } catch (Exception e) {
             e.printStackTrace();
         }
         return false;
     }
+
+    public static Object getDeclaredField(Object obj, String fieldName) {
+        try {
+            Field f = obj.getClass().getDeclaredField(fieldName);
+            f.setAccessible(true);
+            return f.get(obj); //IllegalAccessException
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Object invoke(Object object, String methodName) {
+        try {
+            Method method = object.getClass().getDeclaredMethod(methodName);
+            method.setAccessible(true);
+            return method.invoke(object);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
 }

android/app/src/main/java/com/reactnativenavigation/views/RctView.java

      */
     public void onTemporallyRemovedFromScreen() {
         // Hack in order to prevent the react view from getting unmounted
-        ReflectionUtils.setBooleanField(mReactRootView, "mAttachScheduled", true);
+        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", true);
     }
 
     /**
      * executed and componentWillUnmount is called
      */
     public void onRemoveFromScreen() {
-        ReflectionUtils.setBooleanField(mReactRootView, "mAttachScheduled", false);
+        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", false);
     }
 
     /**
      * executed and componentWillUnmount is called
      */
     public void onReAddToScreen() {
-        ReflectionUtils.setBooleanField(mReactRootView, "mAttachScheduled", false);
+        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", false);
+    }
+
+    public void detachFromScreen() {
+        ReflectionUtils.invoke(mReactRootView, "onDetachedFromWindow");
     }
 }
 

android/app/src/main/java/com/reactnativenavigation/views/ScreenStack.java

 
         parent.addView(this, new FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
     }
+
+    public void removeAllReactViews() {
+        while (!mStack.empty()) {
+            RctView view = mStack.pop().view;
+            // Ensure view will be properly detached and unmounted
+            view.onRemoveFromScreen();
+            // Unmount the view
+            view.detachFromScreen();
+        }
+        removeAllViews();
+    }
 }