lifecycle of reactContext fix, refactored the tangled mess in the Application

android/app/src/main/java/com/reactnativenavigation/NavigationApplication.java

 import android.support.annotation.Nullable;
 
 import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.shell.MainReactPackage;
-import com.reactnativenavigation.bridge.NavigationReactPackage;
-import com.reactnativenavigation.react.NavigationReactInstance;
+import com.reactnativenavigation.react.NavigationReactGateway;
+import com.reactnativenavigation.react.ReactGateway;
 
-import java.util.ArrayList;
 import java.util.List;
 
 public abstract class NavigationApplication extends Application {
 
     public static NavigationApplication instance;
-    private NavigationReactInstance navigationReactInstance;
+
+    private ReactGateway reactGateway;
     private Handler handler;
 
     @Override
     public void onCreate() {
         super.onCreate();
         instance = this;
+        reactGateway = new NavigationReactGateway();
         handler = new Handler(getMainLooper());
     }
 
+    public void startReactContext() {
+        reactGateway.startReactContextOnceInBackgroundAndExecuteJS();
+    }
+
     public void runOnMainThread(Runnable runnable) {
         handler.post(runnable);
     }
         handler.postDelayed(runnable, delay);
     }
 
-    public NavigationReactInstance getNavigationReactInstance() {
-        return navigationReactInstance;
+    public ReactGateway getReactGateway() {
+        return reactGateway;
     }
 
-    public final List<ReactPackage> createReactPackages() {
-        List<ReactPackage> list = new ArrayList<>();
-        list.add(new MainReactPackage());
-        list.add(new NavigationReactPackage());
-        addAdditionalReactPackagesIfNeeded(list);
-        return list;
-    }
-
-    private void addAdditionalReactPackagesIfNeeded(List<ReactPackage> list) {
-        List<ReactPackage> additionalReactPackages = createAdditionalReactPackages();
-        if (additionalReactPackages == null) {
-            return;
-        }
-
-        for (ReactPackage reactPackage : additionalReactPackages) {
-            if (reactPackage instanceof MainReactPackage)
-                throw new RuntimeException("Do not create a new MainReactPackage. This is created for you.");
-            if (reactPackage instanceof NavigationReactPackage)
-                throw new RuntimeException("Do not create a new NavigationReactPackage. This is created for you.");
-        }
-
-        list.addAll(additionalReactPackages);
+    public boolean isReactContextInitialized() {
+        return reactGateway.isInitialized();
     }
 
     public String getJsEntryFileName() {
         return "index.android.bundle";
     }
 
-    public ReactContext getReactContext() {
-        if (navigationReactInstance == null) {
-            return null;
-        }
-        return navigationReactInstance.getReactInstanceManager().getCurrentReactContext();
-    }
+    public abstract boolean isDebug();
 
-    public boolean isReactInstanceManagerInitialized() {
-        return navigationReactInstance != null && navigationReactInstance.getReactInstanceManager() != null;
-    }
+    @Nullable
+    public abstract List<ReactPackage> createAdditionalReactPackages();
 
+    //TODO move all these navigator junk elsewhere
     public void sendNavigatorEvent(String eventId, String navigatorEventId) {
-        if (navigationReactInstance == null) {
+        if (!isReactContextInitialized()) {
             return;
         }
-        navigationReactInstance.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
     }
 
     public void sendNavigatorEvent(String eventId, String navigatorEventId, WritableMap data) {
-        if (navigationReactInstance == null) {
+        if (!isReactContextInitialized()) {
             return;
         }
-        navigationReactInstance.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, data);
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, data);
     }
 
     public void sendEvent(String eventId, String navigatorEventId) {
-        if (navigationReactInstance == null) {
+        if (!isReactContextInitialized()) {
             return;
         }
-        navigationReactInstance.getReactEventEmitter().sendEvent(eventId, navigatorEventId);
+        reactGateway.getReactEventEmitter().sendEvent(eventId, navigatorEventId);
     }
 
     public void sendNavigatorEvent(String eventId, WritableMap arguments) {
-        if (navigationReactInstance == null) {
+        if (!isReactContextInitialized()) {
             return;
         }
-        navigationReactInstance.getReactEventEmitter().sendEvent(eventId, arguments);
-    }
-
-    public void startReactContext() {
-        navigationReactInstance = new NavigationReactInstance();
-        navigationReactInstance.startReactContextOnceInBackgroundAndExecuteJS();
+        reactGateway.getReactEventEmitter().sendEvent(eventId, arguments);
     }
-
-    public abstract boolean isDebug();
-
-    @Nullable
-    public abstract List<ReactPackage> createAdditionalReactPackages();
 }

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

 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 import com.reactnativenavigation.react.JsDevReloadHandler;
-import com.reactnativenavigation.react.NavigationReactInstance;
+import com.reactnativenavigation.react.ReactGateway;
 import com.reactnativenavigation.react.RedboxPermission;
 
 import java.util.List;
 
-public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, NavigationReactInstance.OnJsDevReloadListener {
+public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, ReactGateway.OnJsDevReloadListener {
 
     /**
      * Although we start multiple activities, we make sure to pass Intent.CLEAR_TASK | Intent.NEW_TASK
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            NavigationApplication.instance.startReactContext();
+            finish();
+            return;
+        }
+
         RedboxPermission.permissionToShowRedboxIfNeeded(this);
 
-        activityParams = NavigationCommandsHandler.getActivityParams(getIntent());
+        activityParams = NavigationCommandsHandler.parseActivityParams(getIntent());
 
         createLayout();
         createModalController();
     @Override
     protected void onResume() {
         super.onResume();
+        if (isFinishing()) {
+            return;
+        }
+
         currentActivity = this;
-        getNavigationReactInstance().onResume(this, this, this);
+        NavigationApplication.instance.getReactGateway().onResume(this, this, this);
     }
 
     @Override
     protected void onPause() {
         super.onPause();
         currentActivity = null;
-        getNavigationReactInstance().onPause();
+        NavigationApplication.instance.getReactGateway().onPause();
     }
 
     @Override
     protected void onDestroy() {
-        modalController.destroy();
-        layout.destroy();
-        super.onDestroy();
+        if (modalController != null) {
+            modalController.destroy();
+        }
+        if (layout != null) {
+            layout.destroy();
+        }
         if (currentActivity == null || currentActivity.isFinishing()) {
-            getNavigationReactInstance().onHostDestroy();
+            if (NavigationApplication.instance.isReactContextInitialized()) {
+                NavigationApplication.instance.getReactGateway().onDestroyApp();
+            }
         }
+        super.onDestroy();
     }
 
     @Override
     public void onJsDevReload() {
+        modalController.destroy();
         layout.destroy();
     }
 
     @Override
     public void onBackPressed() {
         if (!layout.onBackPressed()) {
-            getNavigationReactInstance().onBackPressed();
+            NavigationApplication.instance.getReactGateway().onBackPressed();
         }
     }
 
     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        getNavigationReactInstance().onActivityResult(requestCode, resultCode, data);
+        NavigationApplication.instance.getReactGateway().onActivityResult(requestCode, resultCode, data);
     }
 
     @Override
         return JsDevReloadHandler.onKeyUp(getCurrentFocus(), keyCode) || super.onKeyUp(keyCode, event);
     }
 
-    private NavigationReactInstance getNavigationReactInstance() {
-        return NavigationApplication.instance.getNavigationReactInstance();
-    }
-
     void push(ScreenParams params) {
         if (modalController.isShowing()) {
             modalController.push(params);
         }
     }
 
+    void showModal(ScreenParams screenParams) {
+        modalController.showModal(screenParams);
+    }
+
+    void dismissTopModal() {
+        modalController.dismissTopModal();
+    }
+
+    void dismissAllModals() {
+        modalController.dismissAllModals();
+    }
+
+    //TODO all these setters should be combined to something like setStyle
     void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
         layout.setTopBarVisible(screenInstanceId, hidden, animated);
         modalController.setTopBarVisible(screenInstanceId, hidden, animated);
     }
 
-    public void setBottomTabsVisible(boolean hidden, boolean animated) {
+    void setBottomTabsVisible(boolean hidden, boolean animated) {
         if (layout instanceof BottomTabsLayout) {
             ((BottomTabsLayout) layout).setBottomTabsVisible(hidden, animated);
         }
         modalController.setTitleBarTitle(screenInstanceId, title);
     }
 
-    public void setTitleBarButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+    void setTitleBarButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
         layout.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
         modalController.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
     }
 
-    public void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButton) {
+    void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButton) {
         layout.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
         modalController.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
     }
-
-    void showModal(ScreenParams screenParams) {
-        modalController.showModal(screenParams);
-    }
-
-    void dismissTopModal() {
-        modalController.dismissTopModal();
-    }
-
-    void dismissAllModals() {
-        modalController.dismissAllModals();
-    }
 }

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

 
     private static final String ACTIVITY_PARAMS_BUNDLE = "ACTIVITY_PARAMS_BUNDLE";
 
-    static ActivityParams getActivityParams(Intent intent) {
+    static ActivityParams parseActivityParams(Intent intent) {
         return ActivityParamsParser.parse(intent.getBundleExtra(NavigationCommandsHandler.ACTIVITY_PARAMS_BUNDLE));
     }
 

android/app/src/main/java/com/reactnativenavigation/layouts/LayoutFactory.java

     }
 
     private static Layout createBottomTabsScreenLayout(AppCompatActivity activity, ActivityParams params) {
+        if (params.tabParams.size() > 5) {
+            removeAllButTheFirst5Tabs(params);
+        }
         return new BottomTabsLayout(activity, params);
     }
-//
-//    private static void addContentWithMenuIfNeeded(Activity activity, Params params, LinearLayout root, FrameLayout content) {
-//        if (params.sideMenu.enabled) {
-//            DrawerLayout sideMenu = createSideMenu(activity, content);
-//            root.addView(sideMenu, new LinearLayout.LayoutParams(MATCH_PARENT, 0, 1));
-//        } else {
-//            root.addView(content, new LinearLayout.LayoutParams(MATCH_PARENT, 0, 1));
-//        }
-//    }
-//
-//    private static LinearLayout createRoot(Activity activity) {
-//        LinearLayout root = new LinearLayout(activity);
-//        root.setOrientation(LinearLayout.VERTICAL);
-//        return root;
-//    }
-//
-//    private static DrawerLayout createSideMenu(Activity activity, FrameLayout content) {
-//        DrawerLayout drawerLayout = new DrawerLayout(activity);
-//        FrameLayout drawerContent = new FrameLayout(activity);
-//        drawerLayout.addView(content, new DrawerLayout.LayoutParams(MATCH_PARENT, 0, 1));
-//        DrawerLayout.LayoutParams drawerContentParams = new DrawerLayout.LayoutParams(WRAP_CONTENT, MATCH_PARENT);
-//        drawerContentParams.gravity = Gravity.START;
-//        drawerLayout.addView(drawerContent, drawerContentParams);
-//        return drawerLayout;
-//    }
-//
-//    private static FrameLayout createContent(Activity activity) {
-//        return new FrameLayout(activity);
-//    }
+
+    private static void removeAllButTheFirst5Tabs(ActivityParams params) {
+        android.util.Log.e("LOG", "LayoutFactory:createBottomTabsScreenLayout() does not support more than 5 tabs, currently");
+        while (params.tabParams.size() > 5) {
+            params.tabParams.remove(params.tabParams.size() - 1);
+        }
+    }
 }

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

 
     //TODO yuck.
     public static boolean onKeyUp(View currentFocus, int keyCode) {
-
         ReactInstanceManager reactInstanceManager = NavigationApplication
                 .instance
-                .getNavigationReactInstance()
+                .getReactGateway()
                 .getReactInstanceManager();
 
         if (reactInstanceManager != null &&
                                     shouldRefreshOnRR = false;
                                 }
                             },
-                            200);
+                            500);
                 }
             }
         }

android/app/src/main/java/com/reactnativenavigation/react/NavigationReactInstance.java → android/app/src/main/java/com/reactnativenavigation/react/NavigationReactGateway.java

 package com.reactnativenavigation.react;
 
+import android.app.Activity;
 import android.content.Intent;
 
 import com.facebook.react.LifecycleState;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.bridge.NavigationReactEventEmitter;
-import com.reactnativenavigation.controllers.NavigationActivity;
+import com.reactnativenavigation.bridge.NavigationReactPackage;
 
-public class NavigationReactInstance {
-    private final ReactInstanceManager reactInstanceManager;
-    private NavigationReactEventEmitter reactEventEmitter;
-    private OnJsDevReloadListener onJsDevReloadListener;
+import java.util.ArrayList;
+import java.util.List;
 
-    public interface OnJsDevReloadListener {
-        void onJsDevReload();
-    }
+public class NavigationReactGateway implements ReactGateway {
 
-    public NavigationReactInstance() {
-        reactInstanceManager = createReactInstanceManager();
-
-        if (NavigationApplication.instance.isDebug()) {
-            replaceJsDevReloadListener();
-        }
-    }
+    private OnJsDevReloadListener onJsDevReloadListener;
+    private ReactInstanceManager reactInstanceManager;
+    private NavigationReactEventEmitter reactEventEmitter;
 
-    public ReactInstanceManager getReactInstanceManager() {
-        return reactInstanceManager;
+    public NavigationReactGateway() {
+        reactInstanceManager = createReactInstanceManager();
     }
 
     public void startReactContextOnceInBackgroundAndExecuteJS() {
+        if (reactInstanceManager == null) {
+            reactInstanceManager = createReactInstanceManager();
+        }
         if (!reactInstanceManager.hasStartedCreatingInitialContext()) {
             reactInstanceManager.createReactContextInBackground();
         }
     }
 
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        reactInstanceManager.onActivityResult(requestCode, resultCode, data);
+    public boolean isInitialized() {
+        return reactInstanceManager != null && reactInstanceManager.getCurrentReactContext() != null;
+    }
+
+    public ReactContext getReactContext() {
+        return reactInstanceManager.getCurrentReactContext();
+    }
+
+    public NavigationReactEventEmitter getReactEventEmitter() {
+        return reactEventEmitter;
+    }
+
+    public ReactInstanceManager getReactInstanceManager() {
+        return reactInstanceManager;
     }
 
     public void onBackPressed() {
         reactInstanceManager.onBackPressed();
     }
 
-    public void onResume(NavigationActivity activity, DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler, OnJsDevReloadListener onJsDevReloadListener) {
-        this.onJsDevReloadListener = onJsDevReloadListener;
-        reactInstanceManager.onHostResume(activity, defaultHardwareBackBtnHandler);
-        reactEventEmitter = new NavigationReactEventEmitter(reactInstanceManager.getCurrentReactContext());
+    public void onDestroyApp() {
+        reactInstanceManager.onHostDestroy();
+        reactInstanceManager.destroy();
+        reactInstanceManager = null;
     }
 
     public void onPause() {
+        reactInstanceManager.onHostPause();
         onJsDevReloadListener = null;
         reactEventEmitter = null;
-        reactInstanceManager.onHostPause();
     }
 
-    public void onHostDestroy() {
-        reactInstanceManager.onHostDestroy();
-        reactInstanceManager.destroy();
+    public void onResume(Activity activity, DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler, OnJsDevReloadListener onJsDevReloadListener) {
+        this.onJsDevReloadListener = onJsDevReloadListener;
+        reactInstanceManager.onHostResume(activity, defaultHardwareBackBtnHandler);
+        reactEventEmitter = new NavigationReactEventEmitter(reactInstanceManager.getCurrentReactContext());
     }
 
-    private void replaceJsDevReloadListener() {
-        new JsDevReloadListenerReplacer(reactInstanceManager, new JsDevReloadListenerReplacer.Listener() {
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        reactInstanceManager.onActivityResult(requestCode, resultCode, data);
+    }
+
+    private void replaceJsDevReloadListener(ReactInstanceManager manager) {
+        new JsDevReloadListenerReplacer(manager, new JsDevReloadListenerReplacer.Listener() {
             @Override
             public void onJsDevReload() {
                 if (onJsDevReloadListener != null)
                 .setUseDeveloperSupport(NavigationApplication.instance.isDebug())
                 .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
 
-        for (ReactPackage reactPackage : NavigationApplication.instance.createReactPackages()) {
+        for (ReactPackage reactPackage : createReactPackages()) {
             builder.addPackage(reactPackage);
         }
 
-        return builder.build();
+        ReactInstanceManager manager = builder.build();
+
+        if (NavigationApplication.instance.isDebug()) {
+            replaceJsDevReloadListener(manager);
+        }
+
+        return manager;
     }
 
-    public NavigationReactEventEmitter getReactEventEmitter() {
-        return reactEventEmitter;
+    private List<ReactPackage> createReactPackages() {
+        List<ReactPackage> list = new ArrayList<>();
+        list.add(new MainReactPackage());
+        list.add(new NavigationReactPackage());
+        addAdditionalReactPackagesIfNeeded(list);
+        return list;
+    }
+
+    private void addAdditionalReactPackagesIfNeeded(List<ReactPackage> list) {
+        List<ReactPackage> additionalReactPackages = NavigationApplication.instance.createAdditionalReactPackages();
+        if (additionalReactPackages == null) {
+            return;
+        }
+
+        for (ReactPackage reactPackage : additionalReactPackages) {
+            if (reactPackage instanceof MainReactPackage)
+                throw new RuntimeException("Do not create a new MainReactPackage. This is created for you.");
+            if (reactPackage instanceof NavigationReactPackage)
+                throw new RuntimeException("Do not create a new NavigationReactPackage. This is created for you.");
+        }
+
+        list.addAll(additionalReactPackages);
     }
 }

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

+package com.reactnativenavigation.react;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.reactnativenavigation.bridge.NavigationReactEventEmitter;
+
+public interface ReactGateway {
+
+    interface OnJsDevReloadListener {
+        void onJsDevReload();
+    }
+
+    void startReactContextOnceInBackgroundAndExecuteJS();
+
+    boolean isInitialized();
+
+    ReactContext getReactContext();
+
+    NavigationReactEventEmitter getReactEventEmitter();
+
+    ReactInstanceManager getReactInstanceManager();
+
+    void onResume(Activity activity, DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler, OnJsDevReloadListener onJsDevReloadListener);
+
+    void onPause();
+
+    void onDestroyApp();
+
+    void onBackPressed();
+
+    void onActivityResult(int requestCode, int resultCode, Intent data);
+}

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

 import android.content.Context;
 import android.os.Bundle;
 
-import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactRootView;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.params.ScreenParams;
     }
 
     private void attachToJS() {
-        ReactInstanceManager react = NavigationApplication.instance.getNavigationReactInstance().getReactInstanceManager();
-        startReactApplication(react, screenId, passProps);
+        startReactApplication(NavigationApplication.instance.getReactGateway().getReactInstanceManager(), screenId, passProps);
     }
 
     private Bundle mergePropsAndNavigationParams(ScreenParams screenParams, Bundle passProps) {