work on bridge and react packages with guyc

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

 import com.facebook.common.logging.FLog;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
-import com.facebook.react.ReactRootView;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
 import com.reactnativenavigation.BuildConfig;
+import com.reactnativenavigation.bridge.NavigationReactPackage;
 import com.reactnativenavigation.controllers.ModalController;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Button;
 import com.reactnativenavigation.core.objects.Drawer;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.modal.RnnModal;
-import com.reactnativenavigation.bridge.NavigationReactPackage;
 import com.reactnativenavigation.utils.ContextProvider;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnToolBar;
             "Overlay permissions needs to be granted in order for react native apps to run in dev mode";
 
     @Nullable
-    protected ReactInstanceManager mReactInstanceManager;
-    private boolean mDoRefresh = false;
-    private Menu mMenu;
-    protected RnnToolBar mToolbar;
-    protected ActionBarDrawerToggle mDrawerToggle;
-    protected DrawerLayout mDrawerLayout;
-    protected ScreenStack mDrawerStack;
-
-    /**
-     * Returns the name of the bundle in assets. If this is null, and no file path is specified for
-     * the bundle, the app will only work with {@code getUseDeveloperSupport} enabled and will
-     * always try to load the JS bundle from the packager server.
-     * e.g. "index.android.bundle"
-     */
-    @Nullable
-    public String getBundleAssetName() {
-        return "index.android.bundle";
-    }
-
-    /**
-     * Returns a custom path of the bundle file. This is used in cases the bundle should be loaded
-     * from a custom path. By default it is loaded from Android assets, from a path specified
-     * by {getBundleAssetName}.
-     * e.g. "file://sdcard/myapp_cache/index.android.bundle"
-     */
-    @Nullable
-    public String getJSBundleFile() {
-        return null;
-    }
-
-    /**
-     * Returns the name of the main module. Determines the URL used to fetch the JS bundle
-     * from the packager server. It is only used when dev support is enabled.
-     * This is the first file to be executed once the {@link ReactInstanceManager} is created.
-     * e.g. "index.android"
-     */
-    public String getJSMainModuleName() {
-        return "index.android";
-    }
-
-    /**
-     * Returns the launchOptions which will be passed to the {@link ReactInstanceManager}
-     * when the application is started. By default, this will return null and an empty
-     * object will be passed to your top level component as its initial props.
-     * If your React Native application requires props set outside of JS, override
-     * this method to return the Android.os.Bundle of your desired initial props.
-     */
-    @Nullable
-    protected Bundle getLaunchOptions() {
-        return null;
-    }
-
-    /**
-     * Returns the name of the main component registered from JavaScript.
-     * This is used to schedule rendering of the component.
-     * e.g. "MoviesApp"
-     */
-    protected String getMainComponentName() {
-        return "";
-    }
-
-    /**
-     * Returns whether dev mode should be enabled. This enables e.g. the dev menu.
-     */
-    public boolean getUseDeveloperSupport() {
-        return BuildConfig.DEBUG;
-    }
+    protected ReactInstanceManager reactInstanceManager;
+    private boolean shouldRefreshOnRR = false;
+    private Menu menu;
+    protected RnnToolBar toolbar;
+    protected ActionBarDrawerToggle drawerToggle;
+    protected DrawerLayout drawerLayout;
+    protected ScreenStack drawerStack;
 
     /**
      * Returns a list of {@link ReactPackage} used by the app.
         );
     }
 
-    /**
-     * A subclass may override this method if it needs to use a custom {@link ReactRootView}.
-     */
-    protected ReactRootView createRootView() {
-        return new ReactRootView(this);
-    }
-
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         ContextProvider.setActivityContext(this);
-        mReactInstanceManager = createReactInstanceManager();
+        reactInstanceManager = createReactInstanceManager();
         handleOnCreate();
 
     }
     }
 
     private void permissionToShowRedboxIfNeeded() {
-        if (getUseDeveloperSupport() && Build.VERSION.SDK_INT >= 23 && !Settings.canDrawOverlays(this)) {
+        if (BuildConfig.DEBUG && Build.VERSION.SDK_INT >= 23 && !Settings.canDrawOverlays(this)) {
             Intent serviceIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
             startActivity(serviceIntent);
             FLog.w(ReactConstants.TAG, REDBOX_PERMISSION_MESSAGE);
         super.onResume();
         ContextProvider.setActivityContext(this);
 
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onHostResume(this, this);
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostResume(this, this);
         }
     }
 
     protected void onPause() {
         super.onPause();
 
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onHostPause();
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostPause();
         }
 
         ContextProvider.clearActivityContext();
 
         // Destroy react instance manager only if there are no resumed react activities
         BaseReactActivity activity = ContextProvider.getActivityContext();
-        if (mReactInstanceManager != null && (activity == null || activity.isFinishing())) {
+        if (reactInstanceManager != null && (activity == null || activity.isFinishing())) {
             Log.i(TAG, "Destroying ReactInstanceManager");
-            mReactInstanceManager.onHostDestroy();
+            reactInstanceManager.onHostDestroy();
             RctManager.getInstance().onDestroy();
         } else {
             Log.d(TAG, "Not destroying ReactInstanceManager");
 
     @CallSuper
     public void push(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
-        if (mToolbar != null) {
-            mToolbar.update(screen);
+        StyleHelper.updateStyles(toolbar, screen);
+        if (toolbar != null) {
+            toolbar.update(screen);
 
             if (getCurrentNavigatorId().equals(screen.navigatorId) &&
                     getScreenStackSize() >= 1) {
-                mToolbar.setNavUpButton(screen);
+                toolbar.setNavUpButton(screen);
             }
         }
     }
 
     @CallSuper
     public Screen pop(String navigatorId) {
-        if (mToolbar != null &&
+        if (toolbar != null &&
                 getCurrentNavigatorId().equals(navigatorId) &&
                 getScreenStackSize() <= 2) {
-            mToolbar.setNavUpButton();
+            toolbar.setNavUpButton();
         }
 
         return null;
 
     @CallSuper
     public Screen popToRoot(String navigatorId) {
-        if (mToolbar != null) {
-            mToolbar.setNavUpButton();
+        if (toolbar != null) {
+            toolbar.setNavUpButton();
         }
 
         return null;
 
     @CallSuper
     public Screen resetTo(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
-        if (mToolbar != null) {
-            mToolbar.setNavUpButton();
+        StyleHelper.updateStyles(toolbar, screen);
+        if (toolbar != null) {
+            toolbar.setNavUpButton();
         }
 
         return null;
     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
-        if (mDrawerToggle != null) {
-            mDrawerToggle.onConfigurationChanged(newConfig);
+        if (drawerToggle != null) {
+            drawerToggle.onConfigurationChanged(newConfig);
         }
     }
 
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
-        mMenu = menu;
+        this.menu = menu;
         Screen currentScreen = getCurrentScreen();
-        if (mToolbar != null && currentScreen != null && !isFinishing()) {
-            mToolbar.setupToolbarButtonsAsync(currentScreen);
+        if (toolbar != null && currentScreen != null && !isFinishing()) {
+            toolbar.setupToolbarButtonsAsync(currentScreen);
         }
         return super.onCreateOptionsMenu(menu);
     }
 
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
-        if (mDrawerToggle != null &&
+        if (drawerToggle != null &&
                 getScreenStackSize() == 1 &&
-                mDrawerToggle.onOptionsItemSelected(item)) {
+                drawerToggle.onOptionsItemSelected(item)) {
             return true;
         }
 
     @Override
     public void onPostCreate(Bundle savedInstanceState) {
         super.onPostCreate(savedInstanceState);
-        if (mDrawerToggle != null) {
-            mDrawerToggle.syncState();
+        if (drawerToggle != null) {
+            drawerToggle.syncState();
         }
     }
 
     public Menu getMenu() {
-        return mMenu;
+        return menu;
     }
 
     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onActivityResult(requestCode, resultCode, data);
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onActivityResult(requestCode, resultCode, data);
         }
     }
 
     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (mReactInstanceManager != null &&
-                mReactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
+        if (reactInstanceManager != null &&
+                reactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
             if (keyCode == KeyEvent.KEYCODE_MENU) {
-                mReactInstanceManager.showDevOptionsDialog();
+                reactInstanceManager.showDevOptionsDialog();
                 return true;
             }
             if (keyCode == KeyEvent.KEYCODE_R && !(getCurrentFocus() instanceof EditText)) {
                 // Enable double-tap-R-to-reload
-                if (mDoRefresh) {
-                    mReactInstanceManager.getDevSupportManager().handleReloadJS();
-                    mDoRefresh = false;
+                if (shouldRefreshOnRR) {
+                    reactInstanceManager.getDevSupportManager().handleReloadJS();
+                    shouldRefreshOnRR = false;
                 } else {
-                    mDoRefresh = true;
+                    shouldRefreshOnRR = true;
                     new Handler().postDelayed(
                             new Runnable() {
                                 @Override
                                 public void run() {
-                                    mDoRefresh = false;
+                                    shouldRefreshOnRR = false;
                                 }
                             },
                             200);
 
         if (getScreenStackSize() > 1) {
             pop(getCurrentNavigatorId());
-        } else if (mReactInstanceManager != null) {
-            mReactInstanceManager.onBackPressed();
+        } else if (reactInstanceManager != null) {
+            reactInstanceManager.onBackPressed();
         } else {
             super.onBackPressed();
         }
             return;
         }
 
-        mDrawerStack = new ScreenStack(this);
+        drawerStack = new ScreenStack(this);
         FrameLayout drawerFrame = (FrameLayout) findViewById(drawerFrameId);
-        drawerFrame.addView(mDrawerStack);
-        mDrawerStack.push(drawer.left);
+        drawerFrame.addView(drawerStack);
+        drawerStack.push(drawer.left);
 
-        mDrawerLayout = (DrawerLayout) findViewById(drawerLayoutId);
-        mDrawerToggle = mToolbar.setupDrawer(mDrawerLayout, drawer.left, screen);
+        drawerLayout = (DrawerLayout) findViewById(drawerLayoutId);
+        drawerToggle = toolbar.setupDrawer(drawerLayout, drawer.left, screen);
     }
 
     public void setNavigationButtons(ReadableMap buttons) {
-        if (mToolbar == null) {
+        if (toolbar == null) {
             return;
         }
         getCurrentScreen().setButtons(buttons);
-        mToolbar.setupToolbarButtonsAsync(getCurrentScreen());
+        toolbar.setupToolbarButtonsAsync(getCurrentScreen());
     }
 
     public void setNavigationTitle(ReadableMap title) {
-        if (mToolbar == null) {
+        if (toolbar == null) {
             return;
         }
 
-        mToolbar.setTitle(title.getString(KEY_TITLE));
+        toolbar.setTitle(title.getString(KEY_TITLE));
     }
 
     public void toggleNavigationBar(ReadableMap params) {
-        if (mToolbar == null) {
+        if (toolbar == null) {
             return;
         }
 
         boolean hide = params.getBoolean(KEY_HIDDEN);
         boolean animated = params.getBoolean(KEY_ANIMATED);
         if (hide) {
-            mToolbar.hideToolbar(animated);
+            toolbar.hideToolbar(animated);
         } else {
-            mToolbar.showToolbar(animated);
+            toolbar.showToolbar(animated);
         }
     }
 
     public void toggleDrawer(ReadableMap params) {
-        if (mToolbar == null || mDrawerToggle == null) {
+        if (toolbar == null || drawerToggle == null) {
             return;
         }
 
         String to = params.getString(KEY_TO);
         switch (to) {
             case "open":
-                mToolbar.showDrawer(animated);
+                toolbar.showDrawer(animated);
                 break;
             case "closed":
-                mToolbar.hideDrawer(animated);
+                toolbar.hideDrawer(animated);
                 break;
             default:
-                mToolbar.toggleDrawer(animated);
+                toolbar.toggleDrawer(animated);
                 break;
         }
     }

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

 import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Drawer;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.utils.StyleHelper;
     @Override
     protected void handleOnCreate() {
         super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
+        reactInstanceManager = RctManager.getInstance().getReactInstanceManager();
 
         setContentView(R.layout.bottom_tab_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
+        toolbar = (RnnToolBar) findViewById(R.id.toolbar);
         mBottomNavigation = (AHBottomNavigation) findViewById(R.id.bottom_tab_bar);
         mContentFrame = (CoordinatorLayout) findViewById(R.id.contentFrame);
 
     }
 
     private void setupPages(ArrayList<Screen> screens) {
-        new SetupTabsTask(this, mToolbar, screens).execute();
+        new SetupTabsTask(this, toolbar, screens).execute();
     }
 
     private void setupToolbar(ArrayList<Screen> screens) {
-        mToolbar.setScreens(screens);
+        toolbar.setScreens(screens);
         Screen initialScreen = screens.get(0);
-        mToolbar.update(initialScreen);
-        StyleHelper.updateStyles(mToolbar, initialScreen);
+        toolbar.update(initialScreen);
+        StyleHelper.updateStyles(toolbar, initialScreen);
     }
 
     @Override
     protected void onResume() {
         super.onResume();
         if (mScreenStacks != null) {
-            StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+            StyleHelper.updateStyles(toolbar, getCurrentScreen());
         }
     }
 
                 stack.push(screen);
             }
         }
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+        StyleHelper.updateStyles(toolbar, getCurrentScreen());
 
         if (shouldToggleTabs(screen)) {
             toggleTabs(screen.bottomTabsHidden, false);
             if (stack.peek().navigatorId.equals(navigatorId)) {
                 Screen popped = stack.pop();
                 Screen currentScreen = getCurrentScreen();
-                StyleHelper.updateStyles(mToolbar, currentScreen);
+                StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
                     toggleTabs(currentScreen.bottomTabsHidden, false);
             if (stack.peek().navigatorId.equals(navigatorId)) {
                 Screen popped = stack.popToRoot();
                 Screen currentScreen = getCurrentScreen();
-                StyleHelper.updateStyles(mToolbar, currentScreen);
+                StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
                     toggleTabs(currentScreen.bottomTabsHidden, false);
 
     public Screen resetTo(Screen screen) {
         super.resetTo(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
+        StyleHelper.updateStyles(toolbar, screen);
         return mScreenStacks.get(mCurrentStackPosition).resetTo(screen);
     }
 
         mScreenStacks.get(position).addToScreen(mContentFrame);
 
         mCurrentStackPosition = position;
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+        StyleHelper.updateStyles(toolbar, getCurrentScreen());
 
         // Hide or show back button if needed
         if (getScreenStackSize() > 1) {
-            mToolbar.setNavUpButton(getCurrentScreen());
+            toolbar.setNavUpButton(getCurrentScreen());
         } else {
-            mToolbar.setNavUpButton();
+            toolbar.setNavUpButton();
         }
     }
 

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

+package com.reactnativenavigation.activities;
+
+import android.os.Bundle;
+
+public class NavigationActivity extends BaseReactActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        startReactContextOnceInBackgroundAndExecuteJS();
+    }
+
+    private void startReactContextOnceInBackgroundAndExecuteJS() {
+        if (!getReactInstanceManager().hasStartedCreatingInitialContext()) {
+            getReactInstanceManager().createReactContextInBackground();
+        }
+    }
+
+    @Override
+    protected String getCurrentNavigatorId() {
+        return null;
+    }
+
+    @Override
+    public int getScreenStackSize() {
+        return 0;
+    }
+
+    @Override
+    protected void removeAllReactViews() {
+
+    }
+}

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

-package com.reactnativenavigation.activities;
-
-import android.view.ViewGroup;
-
-import com.facebook.react.ReactRootView;
-import com.reactnativenavigation.core.objects.Screen;
-
-/**
- * This activity is used to start the JS execution where we load our actual app/screens (index.android.js)
- * Triggering react context initialization execute global code before any {@link ReactRootView}
- * are displayed.
- * <p>Only your MainActivity or activities with {@code action.MAIN} and {@code category.LAUNCHER}
- * should extend this activity.
- * Created by guyc on 13/04/16.
- */
-public class RootActivity extends BaseReactActivity {
-
-    @Override
-    protected void handleOnCreate() {
-        super.handleOnCreate();
-        if (!getReactInstanceManager().hasStartedCreatingInitialContext()) {
-            // Trigger react context initialization, global javascript code will now execute
-            getReactInstanceManager().createReactContextInBackground();
-        }
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        finish();
-    }
-
-    // No need to implement stack interface since this activity is only used to start other
-    // activities such as TabActivity or SingleScreenActivity.
-    @Override
-    public Screen getCurrentScreen() {
-        return null;
-    }
-
-    @Override
-    public String getCurrentNavigatorId() {
-        return null;
-    }
-
-    @Override
-    public int getScreenStackSize() {
-        return 0;
-    }
-
-    @Override
-    public void removeAllReactViews() {
-
-    }
-}

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

 
 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Drawer;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.utils.StyleHelper;
     @Override
     protected void handleOnCreate() {
         super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
+        reactInstanceManager = RctManager.getInstance().getReactInstanceManager();
 
         setContentView(R.layout.single_screen_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
+        toolbar = (RnnToolBar) findViewById(R.id.toolbar);
 
         final Screen screen = (Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
         final Drawer drawer = (Drawer) getIntent().getSerializableExtra(DRAWER_PARAMS);
     }
 
     protected void setupToolbar(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
+        StyleHelper.updateStyles(toolbar, screen);
     }
 
     @Override
     public void push(Screen screen) {
         super.push(screen);
         mScreenStack.push(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
+        StyleHelper.updateStyles(toolbar, screen);
     }
 
     @Override
     public Screen pop(String navigatorId) {
         super.pop(navigatorId);
         Screen popped = mScreenStack.pop();
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+        StyleHelper.updateStyles(toolbar, getCurrentScreen());
         return popped;
     }
 
     public Screen popToRoot(String navigatorId) {
         super.popToRoot(navigatorId);
         Screen screen = mScreenStack.popToRoot();
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+        StyleHelper.updateStyles(toolbar, getCurrentScreen());
         return screen;
     }
 
     public Screen resetTo(Screen screen) {
         super.resetTo(screen);
         Screen popped = mScreenStack.resetTo(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
+        StyleHelper.updateStyles(toolbar, screen);
         return popped;
     }
 

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

 
 import android.support.v4.view.ViewPager;
 import android.view.Menu;
-import android.view.ViewGroup;
 
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.adapters.ViewPagerAdapter;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnTabLayout;
     @Override
     protected void handleOnCreate() {
         super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
+        reactInstanceManager = RctManager.getInstance().getReactInstanceManager();
 
         setContentView(R.layout.tab_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
+        toolbar = (RnnToolBar) findViewById(R.id.toolbar);
         mTabLayout = (RnnTabLayout) findViewById(R.id.tabLayout);
         mViewPager = (ViewPager) findViewById(R.id.viewPager);
 
 
     private void setupToolbar(ArrayList<Screen> screens) {
         Screen initialScreen = screens.get(0);
-        mToolbar.setScreens(screens);
-        mToolbar.update(initialScreen);
+        toolbar.setScreens(screens);
+        toolbar.update(initialScreen);
         setNavigationStyle(initialScreen);
     }
 
     }
 
     private void setupViewPager(ArrayList<Screen> screens) {
-        mAdapter = new ViewPagerAdapter(this, mViewPager, mToolbar, screens);
+        mAdapter = new ViewPagerAdapter(this, mViewPager, toolbar, screens);
         mViewPager.setAdapter(mAdapter);
         mTabLayout.setupWithViewPager(mViewPager);
         mTabLayout.setOnTabSelectedListener(mAdapter);
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         boolean ret = super.onCreateOptionsMenu(menu);
-        mToolbar.handleOnCreateOptionsMenuAsync();
+        toolbar.handleOnCreateOptionsMenuAsync();
         return ret;
     }
 
     @Override
     public void push(Screen screen) {
         super.push(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
+        StyleHelper.updateStyles(toolbar, screen);
         mAdapter.push(screen);
     }
 

android/app/src/main/java/com/reactnativenavigation/adapters/ViewPagerAdapter.java

 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnToolBar;

android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactEventEmitter.java

+package com.reactnativenavigation.bridge;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.reactnativenavigation.core.objects.Screen;
+
+public class NavigationReactEventEmitter {
+
+    private static final String KEY_EVENT_ID = "id";
+    private static final String KEY_EVENT_TYPE = "type";
+    private static final String EVENT_TYPE = "NavBarButtonPress";
+
+    public void sendEvent(String eventName, String navigatorEventId, WritableMap params) {
+        DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = getEventEmitter();
+        if (eventEmitter == null) {
+            return;
+        }
+
+        params.putString(KEY_EVENT_TYPE, EVENT_TYPE);
+        params.putString(KEY_EVENT_ID, eventName);
+        params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, navigatorEventId);
+        eventEmitter.emit(navigatorEventId, params);
+    }
+}

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 final String KEY_EVENT_TYPE = "type";
-    private static final String EVENT_TYPE = "NavBarButtonPress";
-    private static RctManager sInstance;
-
-    private ReactInstanceManager mReactManager;
-
-    private RctManager() {
-        // Singleton
-    }
-
-    public static synchronized RctManager getInstance() {
-        if (sInstance == null) {
-            sInstance = new RctManager();
-        }
-        return sInstance;
-    }
-
-    public ReactInstanceManager getReactInstanceManager() {
-        return mReactManager;
-    }
-
-    public boolean isInitialized() {
-        return mReactManager != null;
-    }
-
-    public void init(BaseReactActivity context) {
-        createReactInstanceManager(context);
-    }
-
-    /**
-     * Creates a React Instance Manager associated with this component name
-     */
-    public ReactInstanceManager createReactInstanceManager(BaseReactActivity reactActivity) {
-        ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
-                .setApplication((Application) reactActivity.getApplicationContext())
-                .setJSMainModuleName(reactActivity.getJSMainModuleName())
-                .setUseDeveloperSupport(reactActivity.getUseDeveloperSupport())
-                .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
-
-        for (ReactPackage reactPackage : reactActivity.getPackages()) {
-            builder.addPackage(reactPackage);
-        }
-
-        String jsBundleFile = reactActivity.getJSBundleFile();
-
-        if (jsBundleFile != null) {
-            builder.setJSBundleFile(jsBundleFile);
-        } else {
-            builder.setBundleAssetName(reactActivity.getBundleAssetName());
-        }
-
-        mReactManager = builder.build();
-        if (reactActivity.getUseDeveloperSupport()) {
-            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);
-        boolean success = ReflectionUtils.setField(reactInstanceManager, "mDevInterface", customDevCommandsHandler);
-        if (!success) {
-            Log.e(TAG, "Could not set field mDevInterface");
-            return;
-        }
-
-        // Set customDevCommandsHandler in devSupportManager. Fun =).
-        DevSupportManager devSupportManager = (DevSupportManager)
-                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
-        if (devSupportManager == null) {
-            Log.e(TAG, "Could not get field mDevSupportManager");
-            return;
-        }
-
-        success = ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", customDevCommandsHandler);
-        if (!success) {
-            Log.e(TAG, "Could not set field mReactInstanceCommandsHandler");
-        }
-    }
-
-    public <T extends ReactContextBaseJavaModule> T getNativeModule(Class<T> nativeModuleClass) {
-        if (mReactManager == null || mReactManager.getCurrentReactContext() == null) {
-            return null;
-        }
-
-        return mReactManager.getCurrentReactContext().getNativeModule(nativeModuleClass);
-    }
-
-    /**
-     * Sends an event to JavaScript using <a href="https://facebook.github.io/react-native/docs/native-modules-android.html#sending-events-to-javascript">RCTDeviceEventEmitter</a>
-     * @param eventName Name of the event
-     * @param params Event params
-     * @param screen screen which should receive the event
-     */
-    public void sendEvent(String eventName, Screen screen, WritableMap params) {
-        RCTDeviceEventEmitter eventEmitter = getEventEmitter();
-        if (eventEmitter == null) {
-            return;
-        }
-
-        params.putString(KEY_EVENT_TYPE, EVENT_TYPE);
-        params.putString(KEY_EVENT_ID, eventName);
-        params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
-        eventEmitter.emit(screen.navigatorEventId, params);
-    }
-
-    private RCTDeviceEventEmitter getEventEmitter() {
-        if (mReactManager == null) {
-            return null;
-        }
-
-        ReactContext currentReactContext = mReactManager.getCurrentReactContext();
-        if (currentReactContext == null) {
-            return null;
-        }
-
-        return currentReactContext.getJSModule(RCTDeviceEventEmitter.class);
-    }
-
-    public void onDestroy() {
-        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/react/JsDevReloadListenerReplacer.java

+package com.reactnativenavigation.react;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
+import com.reactnativenavigation.utils.ReflectionUtils;
+
+public class JsDevReloadListenerReplacer {
+    private final ReactInstanceManager reactInstanceManager;
+    private final Listener listener;
+
+    public interface Listener {
+        void onJsDevReload();
+    }
+
+    public JsDevReloadListenerReplacer(ReactInstanceManager reactInstanceManager, Listener listener) {
+        this.reactInstanceManager = reactInstanceManager;
+        this.listener = listener;
+    }
+
+    public void replace() {
+        ReactInstanceDevCommandsHandler originalHandler = getOriginalHandler();
+        DevCommandsHandlerProxy proxy = new DevCommandsHandlerProxy(originalHandler, listener);
+        replaceInReactInstanceManager(proxy);
+        replaceInDevSupportManager(proxy);
+    }
+
+    private void replaceInDevSupportManager(DevCommandsHandlerProxy proxy) {
+        DevSupportManager devSupportManager = (DevSupportManager)
+                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
+        ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", proxy);
+    }
+
+    private ReactInstanceDevCommandsHandler getOriginalHandler() {
+        return (ReactInstanceDevCommandsHandler) ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
+    }
+
+    private void replaceInReactInstanceManager(DevCommandsHandlerProxy proxy) {
+        ReflectionUtils.setField(reactInstanceManager, "mDevInterface", proxy);
+    }
+
+    private static class DevCommandsHandlerProxy implements ReactInstanceDevCommandsHandler {
+        private ReactInstanceDevCommandsHandler originalReactHandler;
+        private final Listener listener;
+
+        public DevCommandsHandlerProxy(ReactInstanceDevCommandsHandler originalReactHandler, Listener listener) {
+            this.originalReactHandler = originalReactHandler;
+            this.listener = listener;
+        }
+
+        @Override
+        public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
+            listener.onJsDevReload();
+            originalReactHandler.onReloadWithJSDebugger(proxyExecutorFactory);
+        }
+
+        @Override
+        public void onJSBundleLoadedFromServer() {
+            listener.onJsDevReload();
+            originalReactHandler.onJSBundleLoadedFromServer();
+        }
+
+        @Override
+        public void toggleElementInspector() {
+            originalReactHandler.toggleElementInspector();
+        }
+    }
+}

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

+package com.reactnativenavigation.react;
+
+import android.app.Application;
+
+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.DeviceEventManagerModule.RCTDeviceEventEmitter;
+import com.reactnativenavigation.BuildConfig;
+
+import java.util.List;
+
+public class NavigationReactInstance {
+
+    private final ReactInstanceManager reactInstanceManager;
+
+    public interface ReactContextCreator {
+        Application getApplication();
+
+        List<ReactPackage> createReactPackages();
+
+        void onJsDevReload();
+    }
+
+    public NavigationReactInstance(final ReactContextCreator reactContextCreator) {
+        reactInstanceManager = createReactInstanceManager(reactContextCreator);
+
+        if (BuildConfig.DEBUG) {
+            replaceJsDevReloadListener(reactContextCreator);
+        }
+    }
+
+    private RCTDeviceEventEmitter getEventEmitter() {
+        ReactContext currentReactContext = reactInstanceManager.getCurrentReactContext();
+        if (currentReactContext == null) {
+            return null;
+        }
+
+        return currentReactContext.getJSModule(RCTDeviceEventEmitter.class);
+    }
+
+    private void replaceJsDevReloadListener(final ReactContextCreator reactContextCreator) {
+        new JsDevReloadListenerReplacer(reactInstanceManager, new JsDevReloadListenerReplacer.Listener() {
+            @Override
+            public void onJsDevReload() {
+                reactContextCreator.onJsDevReload();
+            }
+        }).replace();
+    }
+
+    private ReactInstanceManager createReactInstanceManager(final ReactContextCreator reactContextCreator) {
+        ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
+                .setApplication(reactContextCreator.getApplication())
+                .setJSMainModuleName("index.android")
+                .setBundleAssetName("index.android.bundle")
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
+
+        for (ReactPackage reactPackage : reactContextCreator.createReactPackages()) {
+            builder.addPackage(reactPackage);
+        }
+
+        return builder.build();
+    }
+}

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

 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.RctManager;
 import com.reactnativenavigation.core.objects.Screen;
 
 import java.util.Stack;