Unmount react views when bundle load completes (#3487)

Unmount react views when bundle load completes

Users providing their own ReactNativeHost implementations should implement BundleDownloadListenerProvider
and make sure they set DevBundleDownloadListener when ReactInstanceManager.

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

 package com.reactnativenavigation;
 
 import android.annotation.TargetApi;
-import android.support.annotation.NonNull;
-
 import android.content.Intent;
-import android.os.Bundle;
 import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v7.app.AppCompatActivity;
 import android.view.KeyEvent;
 import android.view.View;
 
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
 import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.react.JsDevReloadHandler;
 import com.reactnativenavigation.react.ReactGateway;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.Navigator;
 
-import com.facebook.react.modules.core.PermissionAwareActivity;
-import com.facebook.react.modules.core.PermissionListener;
-
-public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, PermissionAwareActivity {
+public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, PermissionAwareActivity, JsDevReloadHandler.ReloadListener {
     @Nullable
     private PermissionListener mPermissionListener;
     
         super.onCreate(savedInstanceState);
         navigator = new Navigator(this, new ChildControllersRegistry(), new OverlayManager());
         getReactGateway().onActivityCreated(this);
-        getReactGateway().addReloadListener(navigator);
         navigator.getView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
         setContentView(navigator.getView());
     }
     protected void onDestroy() {
         super.onDestroy();
         navigator.destroy();
-        getReactGateway().removeReloadListener(navigator);
         getReactGateway().onActivityDestroyed(this);
     }
 
             mPermissionListener = null;
         }
     }
+
+    @Override
+    public void onReload() {
+        navigator.destroyViews();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/BundleDownloadListenerProvider.java

+package com.reactnativenavigation.react;
+
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+
+public interface BundleDownloadListenerProvider {
+    void setBundleLoaderListener(DevBundleDownloadListener listener);
+}

lib/android/app/src/main/java/com/reactnativenavigation/react/DevBundleDownloadListenerAdapter.java

+package com.reactnativenavigation.react;
+
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+
+import javax.annotation.Nullable;
+
+public class DevBundleDownloadListenerAdapter implements DevBundleDownloadListener {
+    @Override
+    public void onSuccess() {
+
+    }
+
+    @Override
+    public void onProgress(@Nullable String status, @Nullable Integer done, @Nullable Integer total) {
+
+    }
+
+    @Override
+    public void onFailure(Exception cause) {
+
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/react/JsDevReloadHandler.java

 import android.content.IntentFilter;
 import android.view.KeyEvent;
 
-import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.reactnativenavigation.utils.UiUtils;
+
+import javax.annotation.Nullable;
+
+public class JsDevReloadHandler implements DevBundleDownloadListener {
+    private static final String RELOAD_BROADCAST = "com.reactnativenavigation.broadcast.RELOAD";
 
-public class JsDevReloadHandler {
     public interface ReloadListener {
         void onReload();
     }
 
-	private static final String RELOAD_BROADCAST = "com.reactnativenavigation.broadcast.RELOAD";
 	private final BroadcastReceiver reloadReceiver = new BroadcastReceiver() {
 		@Override
 		public void onReceive(final Context context, final Intent intent) {
 			reloadReactNative();
 		}
 	};
-	private final ReactInstanceManager reactInstanceManager;
-	private long firstRTimestamp = 0;
-    private ReloadListener reloadListener;
+    private final DevSupportManager devSupportManager;
 
-    JsDevReloadHandler(final ReactInstanceManager reactInstanceManager) {
-		this.reactInstanceManager = reactInstanceManager;
-	}
+    private long firstRTimestamp = 0;
+    private ReloadListener reloadListener = () -> {};
+
+    JsDevReloadHandler(DevSupportManager devSupportManager) {
+        this.devSupportManager = devSupportManager;
+    }
+
+    @Override
+    public void onSuccess() {
+        UiUtils.runOnMainThread(reloadListener::onReload);
+    }
+
+    @Override
+    public void onProgress(@Nullable String status, @Nullable Integer done, @Nullable Integer total) {
+
+    }
+
+    @Override
+    public void onFailure(Exception cause) {
+
+    }
 
-    public void addReloadListener(ReloadListener listener) {
+    public void setReloadListener(ReloadListener listener) {
         reloadListener = listener;
     }
 
 	}
 
 	public boolean onKeyUp(int keyCode) {
-		if (!reactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
+		if (!devSupportManager.getDevSupportEnabled()) {
 			return false;
 		}
 
 		if (keyCode == KeyEvent.KEYCODE_MENU) {
-			reactInstanceManager.getDevSupportManager().showDevOptionsDialog();
+			devSupportManager.showDevOptionsDialog();
 			return true;
 		}
 
 
 	private void reloadReactNative() {
         reloadListener.onReload();
-		reactInstanceManager.getDevSupportManager().handleReloadJS();
+		devSupportManager.handleReloadJS();
 	}
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationReactNativeHost.java

 package com.reactnativenavigation.react;
 
 import android.app.Application;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactInstanceManagerBuilder;
 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.ReactPackage;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
 import com.facebook.react.shell.MainReactPackage;
 import com.reactnativenavigation.NavigationApplication;
 
  * Default implementation of {@link ReactNativeHost} that includes {@link NavigationPackage}
  * and user-defined additional packages.
  */
-public class NavigationReactNativeHost extends ReactNativeHost {
+public class NavigationReactNativeHost extends ReactNativeHost implements BundleDownloadListenerProvider {
+
+    private final boolean isDebug;
+    private final List<ReactPackage> additionalReactPackages;
+    private @Nullable DevBundleDownloadListener bundleListener;
+    private final DevBundleDownloadListener bundleListenerMediator = new DevBundleDownloadListenerAdapter() {
+        @Override
+        public void onSuccess() {
+            if (bundleListener != null) {
+                bundleListener.onSuccess();
+            }
+        }
+    };
 
-	private final boolean isDebug;
-	private final List<ReactPackage> additionalReactPackages;
 
     public NavigationReactNativeHost(NavigationApplication application) {
         this(application, application.isDebug(), application.createAdditionalReactPackages());
     }
 
-	@SuppressWarnings("WeakerAccess")
+    @SuppressWarnings("WeakerAccess")
     public NavigationReactNativeHost(Application application, boolean isDebug, final List<ReactPackage> additionalReactPackages) {
-		super(application);
-		this.isDebug = isDebug;
-		this.additionalReactPackages = additionalReactPackages;
-	}
+        super(application);
+        this.isDebug = isDebug;
+        this.additionalReactPackages = additionalReactPackages;
+    }
 
-	@Override
-	public boolean getUseDeveloperSupport() {
-		return isDebug;
-	}
+    @Override
+    public void setBundleLoaderListener(DevBundleDownloadListener listener) {
+        bundleListener = listener;
+    }
 
     @Override
-	protected List<ReactPackage> getPackages() {
-		List<ReactPackage> packages = new ArrayList<>();
-		boolean hasMainReactPackage = false;
-		packages.add(new NavigationPackage(this));
-		if (additionalReactPackages != null) {
-			for (ReactPackage p : additionalReactPackages) {
-				if (!(p instanceof NavigationPackage)) {
-					packages.add(p);
-				}
-				if (p instanceof MainReactPackage) hasMainReactPackage = true;
-			}
-		}
+    public boolean getUseDeveloperSupport() {
+        return isDebug;
+    }
+
+    @Override
+    protected List<ReactPackage> getPackages() {
+        List<ReactPackage> packages = new ArrayList<>();
+        boolean hasMainReactPackage = false;
+        packages.add(new NavigationPackage(this));
+        if (additionalReactPackages != null) {
+            for (ReactPackage p : additionalReactPackages) {
+                if (!(p instanceof NavigationPackage)) {
+                    packages.add(p);
+                }
+                if (p instanceof MainReactPackage) hasMainReactPackage = true;
+            }
+        }
         if (!hasMainReactPackage) {
             packages.add(new MainReactPackage());
         }
-		return packages;
-	}
+        return packages;
+    }
+
+    protected ReactInstanceManager createReactInstanceManager() {
+        ReactInstanceManagerBuilder builder = ReactInstanceManager.builder()
+                .setApplication(getApplication())
+                .setJSMainModulePath(getJSMainModuleName())
+                .setUseDeveloperSupport(getUseDeveloperSupport())
+                .setRedBoxHandler(getRedBoxHandler())
+                .setJavaScriptExecutorFactory(getJavaScriptExecutorFactory())
+                .setUIImplementationProvider(getUIImplementationProvider())
+                .setInitialLifecycleState(LifecycleState.BEFORE_CREATE)
+                .setDevBundleDownloadListener(getDevBundleDownloadListener());
+
+        for (ReactPackage reactPackage : getPackages()) {
+            builder.addPackage(reactPackage);
+        }
+
+        String jsBundleFile = getJSBundleFile();
+        if (jsBundleFile != null) {
+            builder.setJSBundleFile(jsBundleFile);
+        } else {
+            builder.setBundleAssetName(Assertions.assertNotNull(getBundleAssetName()));
+        }
+        return builder.build();
+    }
+
+    @SuppressWarnings("WeakerAccess")
+    @NonNull
+    protected DevBundleDownloadListener getDevBundleDownloadListener() {
+        return bundleListenerMediator;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactGateway.java

 
 public class ReactGateway {
 
-	private final ReactNativeHost reactNativeHost;
+	private final ReactNativeHost host;
 	private final NavigationReactInitializer initializer;
 	private final JsDevReloadHandler jsDevReloadHandler;
 
-	public ReactGateway(final Application application, final boolean isDebug, final List<ReactPackage> additionalReactPackages) {
+    @SuppressWarnings("unused")
+    public ReactGateway(final Application application, final boolean isDebug, final List<ReactPackage> additionalReactPackages) {
 		this(application, isDebug, new NavigationReactNativeHost(application, isDebug, additionalReactPackages));
 	}
 
-	public ReactGateway(final Application application, final boolean isDebug, final ReactNativeHost reactNativeHost) {
-		SoLoader.init(application, false);
-		this.reactNativeHost = reactNativeHost;
-		initializer = new NavigationReactInitializer(reactNativeHost.getReactInstanceManager(), isDebug);
-		jsDevReloadHandler = new JsDevReloadHandler(reactNativeHost.getReactInstanceManager());
+	public ReactGateway(final Application application, final boolean isDebug, final ReactNativeHost host) {
+        SoLoader.init(application, false);
+		this.host = host;
+		initializer = new NavigationReactInitializer(host.getReactInstanceManager(), isDebug);
+		jsDevReloadHandler = new JsDevReloadHandler(host.getReactInstanceManager().getDevSupportManager());
+        if (host instanceof BundleDownloadListenerProvider) {
+            ((BundleDownloadListenerProvider) host).setBundleLoaderListener(jsDevReloadHandler);
+        }
 	}
 
 	public ReactNativeHost getReactNativeHost() {
-		return reactNativeHost;
+		return host;
 	}
 
 	public void onActivityCreated(NavigationActivity activity) {
 		initializer.onActivityCreated(activity);
+        jsDevReloadHandler.setReloadListener(activity);
 	}
 
 	public void onActivityResumed(NavigationActivity activity) {
 	}
 
 	public void onActivityDestroyed(NavigationActivity activity) {
+        jsDevReloadHandler.removeReloadListener(activity);
 		initializer.onActivityDestroyed(activity);
 	}
 
-    public void addReloadListener(JsDevReloadHandler.ReloadListener reloadListener) {
-	    jsDevReloadHandler.addReloadListener(reloadListener);
-    }
-
-    public void removeReloadListener(JsDevReloadHandler.ReloadListener reloadListener) {
-	    jsDevReloadHandler.removeReloadListener(reloadListener);
-    }
-
 	public boolean onKeyUp(final int keyCode) {
 		return jsDevReloadHandler.onKeyUp(keyCode);
 	}
 
     public void onBackPressed() {
-	    reactNativeHost.getReactInstanceManager().onBackPressed();
+	    host.getReactInstanceManager().onBackPressed();
     }
 
     public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
-        reactNativeHost.getReactInstanceManager().onActivityResult(activity, requestCode, resultCode, data);
+        host.getReactInstanceManager().onActivityResult(activity, requestCode, resultCode, data);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/ReloadHandler.java

+package com.reactnativenavigation.react;
+
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+
+import javax.annotation.Nullable;
+
+public class ReloadHandler implements JsDevReloadHandler.ReloadListener, DevBundleDownloadListener {
+
+    private Runnable onReloadListener = () -> {};
+
+    public void setOnReloadListener(Runnable onReload) {
+        this.onReloadListener = onReload;
+    }
+
+    /**
+     * Called on RR and adb reload events
+     */
+    @Override
+    public void onReload() {
+        onReloadListener.run();
+    }
+
+    /**
+     * Called when the bundle was successfully reloaded
+     */
+    @Override
+    public void onSuccess() {
+        onReloadListener.run();
+    }
+
+    /**
+     * Bundle progress updates
+     */
+    @Override
+    public void onProgress(@Nullable String status, @Nullable Integer done, @Nullable Integer total) {
+
+    }
+
+    /**
+     * Bundle load failure
+     */
+    @Override
+    public void onFailure(Exception cause) {
+
+    }
+
+    public void destroy() {
+        onReloadListener = null;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.presentation.OverlayManager;
-import com.reactnativenavigation.react.JsDevReloadHandler;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import java.util.Collection;
 import java.util.Collections;
 
-public class Navigator extends ParentController implements JsDevReloadHandler.ReloadListener {
+public class Navigator extends ParentController {
 
     private final ModalStack modalStack;
     private ViewController root;
         return root;
     }
 
-    @Override
-    public void onReload() {
-        destroyViews();
-    }
-
     @Override
     public void destroy() {
         destroyViews();
         super.destroy();
     }
 
-    private void destroyViews() {
+    public void destroyViews() {
         modalStack.dismissAllModals(new CommandListenerAdapter(), root);
         overlayManager.destroy();
         destroyRoot();

lib/android/app/src/test/java/com/reactnativenavigation/react/ReloadListenerTest.java

+package com.reactnativenavigation.react;
+
+import com.reactnativenavigation.BaseTest;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class ReloadListenerTest extends BaseTest {
+    private ReloadHandler uut;
+    private Runnable handler;
+
+    @Override
+    public void beforeEach() {
+        handler = Mockito.mock(Runnable.class);
+        uut = new ReloadHandler();
+    }
+
+    @Test
+    public void onSuccess_viewsAreDestroyed() {
+        uut.setOnReloadListener(handler);
+        uut.onSuccess();
+        Mockito.verify(handler).run();
+    }
+}

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/NavigatorTest.java

         uut.destroy();
         assertThat(childRegistry.size()).isZero();
     }
-
-    @Test
-    public void reload_navigatorIsDestroyedOnReload() {
-        StackController spy = spy(parentController);
-        uut.setRoot(spy, new CommandListenerAdapter());
-        uut.onReload();
-        verify(spy, times(1)).destroy();
-        verify(overlayManager, times(1)).destroy();
-    }
 }

playground/src/screens/PushedScreen.js

 
   listeners = [];
 
-  componentWillMount() {
+  componentDidMount() {
     this.listeners.push(
       Navigation.events().registerNativeEventListener((name, params) => {
         if (name === 'previewContext') {