Merge branch 'sideMenu' into v2.0

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

     }
 
     @ReactMethod
-    public void toggleSideMenuVisible(final ReadableMap params) {
+    public void toggleSideMenuVisible(boolean animated) {
+        NavigationCommandsHandler.toggleSideMenuVisible(animated);
+    }
+
+    @ReactMethod
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        NavigationCommandsHandler.setSideMenuVisible(animated, visible);
     }
 
     @ReactMethod

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

     }
 
     @Override
-    public boolean onTitleBarBackPress() {
+    public boolean onTitleBarBackButtonClick() {
         if (!layout.onBackPressed()) {
             onBackPressed();
         }
         return true;
     }
 
+    public void onSideMenuButtonClick() {
+    }
+
     public interface OnModalDismissedListener {
         void onModalDismissed(Modal modal);
     }

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

     }
 
     @Override
-    public boolean onTitleBarBackPress() {
-        // Do nothing and let the layout handle the back press
+    public boolean onTitleBarBackButtonClick() {
+        // Do nothing and let the layout handle the back button click
         return false;
     }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        // Do nothing and let the layout handle the click
+    }
 }

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

         layout.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
         modalController.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
     }
+
+    public void toggleSideMenuVisible(boolean animated) {
+        layout.toggleSideMenuVisible(animated);
+    }
+
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        layout.setSideMenuVisible(animated, visible);
+    }
 }

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

             }
         });
     }
+
+    public static void toggleSideMenuVisible(final boolean animated) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.toggleSideMenuVisible(animated);
+            }
+        });
+    }
+
+    public static void setSideMenuVisible(final boolean animated, final boolean visible) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setSideMenuVisible(animated, visible);
+            }
+        });
+    }
 }

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

 package com.reactnativenavigation.layouts;
 
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.widget.RelativeLayout;
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
 import com.reactnativenavigation.params.ActivityParams;
 import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.SideMenuParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 import com.reactnativenavigation.screens.ScreenStack;
 import com.reactnativenavigation.views.BottomTabs;
+import com.reactnativenavigation.views.SideMenu;
 
 import java.util.List;
 
     private ActivityParams params;
     private BottomTabs bottomTabs;
     private ScreenStack[] screenStacks;
+    private final SideMenuParams sideMenuParams;
+    private @Nullable SideMenu sideMenu;
     private int currentStackIndex = 0;
 
     public BottomTabsLayout(AppCompatActivity activity, ActivityParams params) {
         super(activity);
         this.activity = activity;
         this.params = params;
+        this.sideMenuParams = params.sideMenuParams;
         screenStacks = new ScreenStack[params.tabParams.size()];
         createLayout();
     }
 
     private void createLayout() {
+        createSideMenu();
         createBottomTabs();
-        addBottomTabsToScreen();
+        addBottomTabs();
         addScreenStacks();
         showInitialScreenStack();
     }
 
+    private void createSideMenu() {
+        if (sideMenuParams == null) {
+            return;
+        }
+        sideMenu = new SideMenu(getContext(), sideMenuParams);
+        RelativeLayout.LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        addView(sideMenu, lp);
+    }
+
     private void addScreenStacks() {
         for (int i = 0; i < screenStacks.length; i++) {
             createAndAddScreens(i);
     }
 
     private void createAndAddScreens(int position) {
-        ScreenStack newStack = new ScreenStack(activity, this, this);
         ScreenParams screenParams = params.tabParams.get(position);
+        ScreenStack newStack = new ScreenStack(activity, getScreenStackParent(), screenParams.navigatorId, this);
         newStack.pushInitialScreen(screenParams, createScreenLayoutParams(screenParams));
         screenStacks[position] = newStack;
     }
 
+    private RelativeLayout getScreenStackParent() {
+        return sideMenu == null ? this : sideMenu.getContentContainer();
+    }
+
     @NonNull
     private LayoutParams createScreenLayoutParams(ScreenParams params) {
         LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
         bottomTabs.addTabs(params.tabParams, this);
     }
 
-    private void addBottomTabsToScreen() {
+    private void addBottomTabs() {
         LayoutParams lp = new LayoutParams(MATCH_PARENT, WRAP_CONTENT);
         lp.addRule(ALIGN_PARENT_BOTTOM);
-        addView(bottomTabs, lp);
+        getScreenStackParent().addView(bottomTabs, lp);
     }
 
     private void showInitialScreenStack() {
         }
     }
 
+    @Override
+    public void toggleSideMenuVisible(boolean animated) {
+        if (sideMenu != null) {
+            sideMenu.toggleVisible(animated);
+        }
+    }
+
+    @Override
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        if (sideMenu != null) {
+            sideMenu.setVisible(visible, animated);
+        }
+    }
+
     @Override
     public void push(ScreenParams screenParams) {
-        getCurrentScreenStack().push(screenParams, createScreenLayoutParams(screenParams));
-        bottomTabs.setStyleFromScreen(screenParams.styleParams);
+        ScreenStack screenStack = getScreenStack(screenParams.navigatorId);
+        if (screenStack == null) {
+            return;
+        }
+
+        if (isCurrentStack(screenStack)) {
+            screenStack.push(screenParams, createScreenLayoutParams(screenParams));
+            bottomTabs.setStyleFromScreen(screenParams.styleParams);
+        } else {
+            screenStack.push(screenParams, createScreenLayoutParams(screenParams));
+        }
     }
 
     @Override
         currentScreenStack.destroy();
         removeView(currentScreenStack.peek());
 
-        ScreenStack newStack = new ScreenStack(activity, this, this);
+        ScreenStack newStack = new ScreenStack(activity, getScreenStackParent(), params.navigatorId, this);
         LayoutParams lp = createScreenLayoutParams(params);
         newStack.pushInitialScreen(params, lp);
         screenStacks[currentStackIndex] = newStack;
         for (ScreenStack screenStack : screenStacks) {
             screenStack.destroy();
         }
+
+        if (sideMenu != null) {
+            sideMenu.destroy();
+        }
     }
 
     @Override
     }
 
     private void showStackAndUpdateStyle(ScreenStack newStack) {
-        newStack.showFirstScreen();
+        newStack.show();
         bottomTabs.setStyleFromScreen(newStack.getCurrentScreenStyleParams());
     }
 
     private void hideCurrentStack() {
         ScreenStack currentScreenStack = getCurrentScreenStack();
-        currentScreenStack.hideScreen();
+        currentScreenStack.hide();
     }
 
     private ScreenStack getCurrentScreenStack() {
         return screenStacks[currentStackIndex];
     }
 
+    private @Nullable ScreenStack getScreenStack(String navigatorId) {
+        for (ScreenStack screenStack : screenStacks) {
+            if (screenStack.getNavigatorId().equals(navigatorId)) {
+                return screenStack;
+            }
+        }
+        return null;
+    }
+
+    private boolean isCurrentStack(ScreenStack screenStack) {
+        return getCurrentScreenStack() == screenStack;
+    }
+
     private void setBottomTabsStyleFromCurrentScreen() {
         bottomTabs.setStyleFromScreen(getCurrentScreenStack().getCurrentScreenStyleParams());
     }
 
     @Override
-    public boolean onTitleBarBackPress() {
+    public boolean onTitleBarBackButtonClick() {
         if (getCurrentScreenStack().canPop()) {
             getCurrentScreenStack().pop(true, new ScreenStack.OnScreenPop() {
                 @Override
             });
             return true;
         }
-
         return false;
     }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        if (sideMenu != null) {
+            sideMenu.openDrawer();
+        }
+    }
 }

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

     void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons);
 
     void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButtonParams);
+
+    void toggleSideMenuVisible(boolean animated);
+
+    void setSideMenuVisible(boolean animated, boolean visible);
 }

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

 package com.reactnativenavigation.layouts;
 
 import android.support.v7.app.AppCompatActivity;
+import android.util.Log;
 
 import com.reactnativenavigation.params.ActivityParams;
 
     }
 
     private static Layout createSingleScreenLayout(AppCompatActivity activity, ActivityParams params) {
-        return new SingleScreenLayout(activity, params.screenParams);
+        return new SingleScreenLayout(activity, params.sideMenuParams, params.screenParams);
     }
 
     private static Layout createBottomTabsScreenLayout(AppCompatActivity activity, ActivityParams params) {
     }
 
     private static void removeAllButTheFirst5Tabs(ActivityParams params) {
-        android.util.Log.e("LOG", "LayoutFactory:createBottomTabsScreenLayout() does not support more than 5 tabs, currently");
+        Log.e("Navigation", "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/layouts/ScreenStackContainer.java

 package com.reactnativenavigation.layouts;
 
 import com.reactnativenavigation.params.ScreenParams;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
-public interface ScreenStackContainer extends TitleBarBackButtonListener {
+public interface ScreenStackContainer extends LeftButtonOnClickListener {
     void push(ScreenParams screenParams);
 
     void pop(ScreenParams screenParams);

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

 package com.reactnativenavigation.layouts;
 
+import android.support.annotation.Nullable;
 import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.SideMenuParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
-import com.reactnativenavigation.screens.ScreenAnimator;
 import com.reactnativenavigation.screens.ScreenStack;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+import com.reactnativenavigation.views.SideMenu;
 
 import java.util.List;
 
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
 public class SingleScreenLayout extends RelativeLayout implements Layout {
 
     private final AppCompatActivity activity;
     private final ScreenParams screenParams;
+    private final SideMenuParams sideMenuParams;
     private ScreenStack stack;
-    private ScreenAnimator screenAnimator;
-    private TitleBarBackButtonListener titleBarBackButtonListener;
+    private LeftButtonOnClickListener leftButtonOnClickListener;
+    private @Nullable SideMenu sideMenu;
 
-    public SingleScreenLayout(AppCompatActivity activity, ScreenParams screenParams, TitleBarBackButtonListener titleBarBackButtonListener) {
-        this(activity, screenParams);
-        this.titleBarBackButtonListener = titleBarBackButtonListener;
+    public SingleScreenLayout(AppCompatActivity activity, ScreenParams screenParams,
+                              LeftButtonOnClickListener leftButtonOnClickListener) {
+        this(activity, null, screenParams);
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
     }
 
-    public SingleScreenLayout(AppCompatActivity activity, ScreenParams screenParams) {
+    public SingleScreenLayout(AppCompatActivity activity, @Nullable SideMenuParams sideMenuParams, ScreenParams screenParams) {
         super(activity);
         this.activity = activity;
         this.screenParams = screenParams;
-        createStack();
+        this.sideMenuParams = sideMenuParams;
+        createLayout();
+    }
+
+    private void createLayout() {
+        if (sideMenuParams == null) {
+            createStack(this);
+        } else {
+            sideMenu = createSideMenu();
+            createStack(sideMenu.getContentContainer());
+        }
     }
 
-    private void createStack() {
+    private SideMenu createSideMenu() {
+        SideMenu sideMenu = new SideMenu(getContext(), sideMenuParams);
+        RelativeLayout.LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        addView(sideMenu, lp);
+        return sideMenu;
+    }
+
+    private void createStack(RelativeLayout parent) {
         if (stack != null) {
             stack.destroy();
         }
-        stack = new ScreenStack(activity, this, this);
-        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+        stack = new ScreenStack(activity, parent, screenParams.navigatorId, this);
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
         stack.pushInitialScreen(screenParams, lp);
-        stack.showFirstScreen();
+        stack.show();
     }
 
     @Override
     @Override
     public void destroy() {
         stack.destroy();
+        if (sideMenu != null) {
+            sideMenu.destroy();
+        }
     }
 
     @Override
     public void push(ScreenParams params) {
-        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
         stack.push(params, lp);
     }
 
 
     @Override
     public void newStack(ScreenParams params) {
-        createStack();
+        RelativeLayout parent = sideMenu == null ? this : sideMenu.getContentContainer();
+        createStack(parent);
     }
 
     @Override
     }
 
     @Override
-    public boolean onTitleBarBackPress() {
-        if (titleBarBackButtonListener != null) {
-            return titleBarBackButtonListener.onTitleBarBackPress();
+    public void toggleSideMenuVisible(boolean animated) {
+        if (sideMenu != null) {
+            sideMenu.toggleVisible(animated);
+        }
+    }
+
+    @Override
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        if (sideMenu != null) {
+            sideMenu.setVisible(visible, animated);
+        }
+    }
+
+    @Override
+    public boolean onTitleBarBackButtonClick() {
+        if (leftButtonOnClickListener != null) {
+            return leftButtonOnClickListener.onTitleBarBackButtonClick();
         }
 
         return onBackPressed();
     }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        if (sideMenu != null) {
+            sideMenu.openDrawer();
+        }
+    }
 }

android/app/src/main/java/com/reactnativenavigation/params/ActivityParams.java

     public Type type;
     public ScreenParams screenParams;
     public List<ScreenParams> tabParams;
+    public SideMenuParams sideMenuParams;
 }

android/app/src/main/java/com/reactnativenavigation/params/ScreenParams.java

 
     public String screenInstanceId;
     public String navigatorEventId;
+    public String navigatorId;
     public Bundle navigationParams;
 
     public boolean hasTopTabs() {

android/app/src/main/java/com/reactnativenavigation/params/SideMenuParams.java

+package com.reactnativenavigation.params;
+
+import android.os.Bundle;
+
+public class SideMenuParams {
+    public String screenId;
+    public Bundle navigationParams;
+    public boolean disableOpenGesture;
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/ActivityParamsParser.java

             result.tabParams = ScreenParamsParser.parseTabs(params.getBundle("tabs"));
         }
 
+        if (hasKey(params, "sideMenu")) {
+            result.sideMenuParams = SideMenuParamsParser.parse(params.getBundle("sideMenu"));
+        }
+
         return result;
     }
 }

android/app/src/main/java/com/reactnativenavigation/params/parsers/ScreenParamsParser.java

     private static final String KEY_SCREEN_ID = "screenId";
     private static final String KEY_SCREEN_INSTANCE_ID = "screenInstanceID";
     private static final String KEY_NAVIGATOR_EVENT_ID = "navigatorEventID";
+    private static final String KEY_NAVIGATOR_ID = "navigatorID";
     private static final String KEY_NAVIGATION_PARAMS = "navigationParams";
     private static final String KEY_RIGHT_BUTTONS = "rightButtons";
     private static final String KEY_LEFT_BUTTON = "leftButton";
         assertKeyExists(params, KEY_NAVIGATION_PARAMS);
         result.navigationParams = params.getBundle(KEY_NAVIGATION_PARAMS);
         result.navigatorEventId = result.navigationParams.getString(KEY_NAVIGATOR_EVENT_ID);
+        result.navigatorId = result.navigationParams.getString(KEY_NAVIGATOR_ID);
         result.screenInstanceId = result.navigationParams.getString(KEY_SCREEN_INSTANCE_ID);
 
         result.styleParams = new StyleParamsParser(params.getBundle(STYLE_PARAMS)).parse();

android/app/src/main/java/com/reactnativenavigation/params/parsers/SideMenuParamsParser.java

+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.SideMenuParams;
+
+public class SideMenuParamsParser extends Parser {
+
+    public static SideMenuParams parse(Bundle sideMenu) {
+        SideMenuParams result = new SideMenuParams();
+        result.screenId = sideMenu.getString("screenId");
+        result.navigationParams = sideMenu.getBundle("navigationParams");
+        result.disableOpenGesture = sideMenu.getBoolean("disableOpenGesture", false);
+        return result;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/TitleBarLeftButtonParamsParser.java

 public class TitleBarLeftButtonParamsParser extends TitleBarButtonParamsParser {
 
     public TitleBarLeftButtonParams parseSingleButton(Bundle params) {
-        TitleBarLeftButtonParams backButtonParams = new TitleBarLeftButtonParams(super.parseSingleButton(params));
-        backButtonParams.iconState = getIconStateFromId(backButtonParams.eventId);
-        return backButtonParams;
+        TitleBarLeftButtonParams leftButtonParams = new TitleBarLeftButtonParams(super.parseSingleButton(params));
+        leftButtonParams.iconState = getIconStateFromId(leftButtonParams.eventId);
+        return leftButtonParams;
     }
 
     private MaterialMenuDrawable.IconState getIconStateFromId(String id) {

android/app/src/main/java/com/reactnativenavigation/screens/FragmentScreen.java

 import com.reactnativenavigation.R;
 import com.reactnativenavigation.params.ScreenParams;
 import com.reactnativenavigation.views.ContentView;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
     private static final String CONTRACT_GET_SUPPORT_FRAGMENT = "getSupportFragment";
     private FrameLayout content;
 
-    public FragmentScreen(AppCompatActivity activity, ScreenParams screenParams, TitleBarBackButtonListener titleBarBackButtonListener) {
-        super(activity, screenParams, titleBarBackButtonListener);
+    public FragmentScreen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener leftButtonOnClickListener) {
+        super(activity, screenParams, leftButtonOnClickListener);
     }
 
     @Override
     private void addContent() {
         ContentView contentView = new ContentView(getContext(),
                 screenParams.screenId,
-                screenParams.navigatorEventId,
                 screenParams.navigationParams);
         addView(contentView, 0, 0);
         LayoutParams params = new LayoutParams(MATCH_PARENT, MATCH_PARENT);

android/app/src/main/java/com/reactnativenavigation/screens/Screen.java

 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 import com.reactnativenavigation.views.TopBar;
 
 import java.util.List;
     protected final AppCompatActivity activity;
     protected final ScreenParams screenParams;
     protected TopBar topBar;
-    private final TitleBarBackButtonListener titleBarBackButtonListener;
+    private final LeftButtonOnClickListener leftButtonOnClickListener;
     private VisibilityAnimator topBarVisibilityAnimator;
     private ScreenAnimator screenAnimator;
 
-    public Screen(AppCompatActivity activity, ScreenParams screenParams, TitleBarBackButtonListener titleBarBackButtonListener) {
+    public Screen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener leftButtonOnClickListener) {
         super(activity);
         this.activity = activity;
         this.screenParams = screenParams;
-        this.titleBarBackButtonListener = titleBarBackButtonListener;
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
 
         screenAnimator = new ScreenAnimator(this);
         createViews();
             screenParams.leftButton.setColorFromScreenStyle(screenParams.styleParams.titleBarButtonColor);
         }
         topBar.addTitleBarAndSetButtons(screenParams.rightButtons, screenParams.leftButton,
-                titleBarBackButtonListener, screenParams.navigatorEventId);
+                leftButtonOnClickListener, screenParams.navigatorEventId);
     }
 
     private void createTopBar() {
         topBar.setTitleBarRightButtons(navigatorEventId, titleBarButtons);
     }
 
-    public void setTitleBarLeftButton(String navigatorEventId, TitleBarBackButtonListener backButtonListener,
+    public void setTitleBarLeftButton(String navigatorEventId, LeftButtonOnClickListener backButtonListener,
                                       TitleBarLeftButtonParams titleBarLeftButtonParams) {
         topBar.setTitleBarRightButton(navigatorEventId, backButtonListener, titleBarLeftButtonParams);
     }

android/app/src/main/java/com/reactnativenavigation/screens/ScreenFactory.java

 import android.support.v7.app.AppCompatActivity;
 
 import com.reactnativenavigation.params.ScreenParams;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
 public class ScreenFactory {
     public static Screen create(AppCompatActivity activity,
                                 ScreenParams screenParams,
-                                TitleBarBackButtonListener titleBarBackButtonListener) {
+                                LeftButtonOnClickListener leftButtonOnClickListener) {
         if (screenParams.isFragmentScreen()) {
-            return new FragmentScreen(activity, screenParams, titleBarBackButtonListener);
+            return new FragmentScreen(activity, screenParams, leftButtonOnClickListener);
         } else if (screenParams.hasTopTabs()) {
-            return new ViewPagerScreen(activity, screenParams, titleBarBackButtonListener);
+            return new ViewPagerScreen(activity, screenParams, leftButtonOnClickListener);
         } else {
-            return new SingleScreen(activity, screenParams, titleBarBackButtonListener);
+            return new SingleScreen(activity, screenParams, leftButtonOnClickListener);
         }
     }
 }

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

 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 import com.reactnativenavigation.utils.KeyboardVisibilityDetector;
 import com.reactnativenavigation.utils.Task;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
 import java.util.List;
 import java.util.Stack;
 
     private final AppCompatActivity activity;
     private RelativeLayout parent;
-    private TitleBarBackButtonListener titleBarBackButtonListener;
+    private LeftButtonOnClickListener leftButtonOnClickListener;
     private Stack<Screen> stack = new Stack<>();
     private final KeyboardVisibilityDetector keyboardVisibilityDetector;
+    private boolean isStackVisible = false;
+    private final String navigatorId;
+
+    public String getNavigatorId() {
+        return navigatorId;
+    }
 
     public ScreenStack(AppCompatActivity activity,
                        RelativeLayout parent,
-                       TitleBarBackButtonListener titleBarBackButtonListener) {
+                       String navigatorId,
+                       LeftButtonOnClickListener leftButtonOnClickListener) {
         this.activity = activity;
         this.parent = parent;
-        this.titleBarBackButtonListener = titleBarBackButtonListener;
+        this.navigatorId = navigatorId;
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
         keyboardVisibilityDetector = new KeyboardVisibilityDetector(parent);
     }
 
     public void pushInitialScreen(ScreenParams initialScreenParams, RelativeLayout.LayoutParams params) {
-        Screen initialScreen = ScreenFactory.create(activity, initialScreenParams, titleBarBackButtonListener);
+        Screen initialScreen = ScreenFactory.create(activity, initialScreenParams, leftButtonOnClickListener);
         initialScreen.setVisibility(View.INVISIBLE);
         addScreen(initialScreen, params);
     }
 
     public void push(final ScreenParams params, RelativeLayout.LayoutParams layoutParams) {
-        Screen nextScreen = ScreenFactory.create(activity, params, titleBarBackButtonListener);
+        Screen nextScreen = ScreenFactory.create(activity, params, leftButtonOnClickListener);
         final Screen previousScreen = stack.peek();
+        if (isStackVisible) {
+            pushScreenToVisibleStack(params, layoutParams, nextScreen, previousScreen);
+        } else {
+            pushScreenToInvisibleStack(layoutParams, nextScreen, previousScreen);
+        }
+    }
+
+    private void pushScreenToVisibleStack(ScreenParams params, RelativeLayout.LayoutParams layoutParams,
+                                          Screen nextScreen, final Screen previousScreen) {
         addScreen(nextScreen, layoutParams);
         nextScreen.show(params.animateScreenTransitions, new Runnable() {
             @Override
         });
     }
 
+    private void pushScreenToInvisibleStack(RelativeLayout.LayoutParams layoutParams, Screen nextScreen,
+                                            Screen previousScreen) {
+        nextScreen.setVisibility(View.INVISIBLE);
+        addScreen(nextScreen, layoutParams);
+        removePreviousWithoutUnmount(previousScreen);
+    }
+
     private void addScreen(Screen screen, RelativeLayout.LayoutParams layoutParams) {
         parent.addView(screen, layoutParams);
         stack.push(screen);
     }
 
     private void readdPrevious(Screen previous) {
+        previous.setVisibility(View.VISIBLE);
         parent.addView(previous, 0);
         previous.preventMountAfterReattachedToWindow();
     }
         performOnScreen(screenInstanceId, new Task<Screen>() {
             @Override
             public void run(Screen param) {
-                param.setTitleBarLeftButton(navigatorEventId, titleBarBackButtonListener, titleBarLeftButtonParams);
+                param.setTitleBarLeftButton(navigatorEventId, leftButtonOnClickListener, titleBarLeftButtonParams);
             }
         });
     }
         }
     }
 
-    public void showFirstScreen() {
+    public void show() {
+        isStackVisible = true;
         stack.peek().setVisibility(View.VISIBLE);
     }
 
-    public void hideScreen() {
+    public void hide() {
+        isStackVisible = false;
         stack.peek().setVisibility(View.INVISIBLE);
     }
 }

android/app/src/main/java/com/reactnativenavigation/screens/SingleScreen.java

 
 import com.reactnativenavigation.params.ScreenParams;
 import com.reactnativenavigation.views.ContentView;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 
     private ContentView contentView;
 
     public SingleScreen(AppCompatActivity activity, ScreenParams screenParams,
-                        TitleBarBackButtonListener titleBarBarBackButtonListener) {
+                        LeftButtonOnClickListener titleBarBarBackButtonListener) {
         super(activity, screenParams, titleBarBarBackButtonListener);
     }
 
     @Override
     protected void createContent() {
-        contentView = new ContentView(getContext(), screenParams.screenId, screenParams.navigatorEventId, screenParams.navigationParams);
+        contentView = new ContentView(getContext(), screenParams.screenId, screenParams.navigationParams);
         LayoutParams params = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
         if (screenParams.styleParams.drawScreenBelowTopBar) {
             params.addRule(BELOW, topBar.getId());

android/app/src/main/java/com/reactnativenavigation/screens/ViewPagerScreen.java

 import com.reactnativenavigation.params.ScreenParams;
 import com.reactnativenavigation.params.TopTabParams;
 import com.reactnativenavigation.views.ContentView;
-import com.reactnativenavigation.views.TitleBarBackButtonListener;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
 import java.util.ArrayList;
 import java.util.List;
     private List<ContentView> contentViews;
     private ViewPager viewPager;
 
-    public ViewPagerScreen(AppCompatActivity activity, ScreenParams screenParams, TitleBarBackButtonListener backButtonListener) {
+    public ViewPagerScreen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener backButtonListener) {
         super(activity, screenParams, backButtonListener);
     }
 
     private void addPages() {
         contentViews = new ArrayList<>();
         for (TopTabParams tab : screenParams.topTabParams) {
-            ContentView contentView = new ContentView(getContext(), tab.screenId, screenParams.navigatorEventId, tab.navigationParams);
+            ContentView contentView = new ContentView(getContext(), tab.screenId, tab.navigationParams, screenParams.navigatorEventId);
             addContent(contentView);
             contentViews.add(contentView);
         }

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

 public class ContentView extends ReactRootView {
 
     private final String screenId;
-    private final String navigatorEventId;
+    private String navigatorEventId;
     private final Bundle navigationParams;
 
-    public ContentView(Context context, String screenId, String navigatorEventId, Bundle navigationParams) {
+    public ContentView(Context context, String screenId, Bundle navigationParams) {
+        this(context, screenId, navigationParams, null);
+    }
+
+    public ContentView(Context context, String screenId, Bundle navigationParams, String navigatorEventId) {
         super(context);
         this.screenId = screenId;
         this.navigatorEventId = navigatorEventId;

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

     }
 
     private TitleBarLeftButtonParams params;
-    private final TitleBarBackButtonListener titleBarBackButtonListener;
+    private final LeftButtonOnClickListener onClickListener;
     private final String navigatorEventId;
 
     public LeftButton(Context context,
                       TitleBarLeftButtonParams params,
-                      TitleBarBackButtonListener titleBarBackButtonListener,
+                      LeftButtonOnClickListener onClickListener,
                       String navigatorEventId) {
         super(context, getColor(params), Stroke.THIN);
         this.params = params;
-        this.titleBarBackButtonListener = titleBarBackButtonListener;
+        this.onClickListener = onClickListener;
         this.navigatorEventId = navigatorEventId;
         setInitialState();
     }
     @Override
     public void onClick(View v) {
         if (isBackButton()) {
-            titleBarBackButtonListener.onTitleBarBackPress();
+            onClickListener.onTitleBarBackButtonClick();
+        } else if (isSideMenuButton()) {
+            onClickListener.onSideMenuButtonClick();
         } else {
             sendClickEvent();
         }
         return getIconState() == IconState.ARROW;
     }
 
+    private boolean isSideMenuButton() {
+        return getIconState() == IconState.BURGER;
+    }
+
     private void sendClickEvent() {
         NavigationApplication.instance.sendNavigatorEvent(params.eventId, navigatorEventId);
     }

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

+package com.reactnativenavigation.views;
+
+public interface LeftButtonOnClickListener {
+    boolean onTitleBarBackButtonClick();
+
+    void onSideMenuButtonClick();
+}

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

+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.support.v4.widget.DrawerLayout;
+import android.view.Gravity;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.params.SideMenuParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+public class SideMenu extends DrawerLayout {
+
+    private ContentView sideMenuView;
+    private RelativeLayout contentContainer;
+
+    public RelativeLayout getContentContainer() {
+        return contentContainer;
+    }
+
+    public void destroy() {
+        sideMenuView.ensureUnmountOnDetachedFromWindow();
+        removeView(sideMenuView);
+    }
+
+    public void setVisible(boolean visible, boolean animated) {
+        if (!isShown() && visible) {
+            openDrawer(animated);
+        }
+
+        if (isShown() && !visible) {
+            closeDrawer(animated);
+        }
+    }
+
+    public void openDrawer() {
+        openDrawer(Gravity.LEFT);
+    }
+
+    public void openDrawer(boolean animated) {
+        openDrawer(Gravity.LEFT, animated);
+    }
+
+    public void closeDrawer(boolean animated) {
+        closeDrawer(Gravity.LEFT, animated);
+    }
+
+    public void toggleVisible(boolean animated) {
+        if (isShown()) {
+            closeDrawer(animated);
+        } else {
+            openDrawer(animated);
+        }
+    }
+
+    public SideMenu(Context context, SideMenuParams sideMenuParams) {
+        super(context);
+        createContentContainer();
+        createSideMenu(sideMenuParams);
+    }
+
+    private void createContentContainer() {
+        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+        contentContainer = new RelativeLayout(getContext());
+        contentContainer.setId(ViewUtils.generateViewId());
+        addView(contentContainer, lp);
+    }
+
+    private void createSideMenu(SideMenuParams sideMenuParams) {
+        sideMenuView = new ContentView(getContext(), sideMenuParams.screenId, sideMenuParams.navigationParams);
+        LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
+        lp.gravity = Gravity.START;
+        addView(sideMenuView, lp);
+    }
+}

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

     }
 
     public void setLeftButton(TitleBarLeftButtonParams leftButtonParams,
-                               TitleBarBackButtonListener titleBarBackButtonListener, String navigatorEventId) {
+                              LeftButtonOnClickListener leftButtonOnClickListener, String navigatorEventId) {
         if (shouldSetLeftButton(leftButtonParams)) {
-            createAndSetLeftButton(leftButtonParams, titleBarBackButtonListener, navigatorEventId);
+            createAndSetLeftButton(leftButtonParams, leftButtonOnClickListener, navigatorEventId);
         } else if (hasLeftButton()) {
             updateLeftButton(leftButtonParams);
         }
         return leftButton == null && leftButtonParams != null;
     }
 
-    private void createAndSetLeftButton(TitleBarLeftButtonParams leftButtonParams, TitleBarBackButtonListener titleBarBackButtonListener, String navigatorEventId) {
-        leftButton = new LeftButton(getContext(), leftButtonParams, titleBarBackButtonListener, navigatorEventId);
+    private void createAndSetLeftButton(TitleBarLeftButtonParams leftButtonParams, LeftButtonOnClickListener leftButtonOnClickListener, String navigatorEventId) {
+        leftButton = new LeftButton(getContext(), leftButtonParams, leftButtonOnClickListener, navigatorEventId);
         setNavigationOnClickListener(leftButton);
         setNavigationIcon(leftButton);
     }

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

-package com.reactnativenavigation.views;
-
-public interface TitleBarBackButtonListener {
-    boolean onTitleBarBackPress();
-}

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

 
     public void addTitleBarAndSetButtons(List<TitleBarButtonParams> rightButtons,
                                          TitleBarLeftButtonParams leftButton,
-                                         TitleBarBackButtonListener titleBarBackButtonListener,
+                                         LeftButtonOnClickListener leftButtonOnClickListener,
                                          String navigatorEventId) {
         titleBar = new TitleBar(getContext());
         addView(titleBar);
         titleBar.setRightButtons(rightButtons, navigatorEventId);
-        titleBar.setLeftButton(leftButton, titleBarBackButtonListener, navigatorEventId);
+        titleBar.setLeftButton(leftButton, leftButtonOnClickListener, navigatorEventId);
     }
 
     public void setTitle(String title) {
     }
 
     public void setTitleBarRightButton(String navigatorEventId,
-                                       TitleBarBackButtonListener titleBarBackButtonListener,
+                                       LeftButtonOnClickListener leftButtonOnClickListener,
                                        TitleBarLeftButtonParams titleBarLeftButtonParams) {
-        titleBar.setLeftButton(titleBarLeftButtonParams, titleBarBackButtonListener, navigatorEventId);
+        titleBar.setLeftButton(titleBarLeftButtonParams, leftButtonOnClickListener, navigatorEventId);
     }
 
     private void setTopTabsStyle(StyleParams style) {

example-redux/src/app.js

   startApp(root) {
     switch (root) {
       case 'login':
-        //Navigation.startSingleScreenApp({
-        //  screen: {
-        //    screen: 'example.LoginScreen',
-        //    title: 'Login',
-        //    navigatorStyle: {}
-        //  },
-        //  passProps: {
-        //    str: 'This is a prop passed in \'startSingleScreenApp()\'!',
-        //    obj: {
-        //      str: 'This is a prop passed in an object!',
-        //      arr: [
-        //        {
-        //          str: 'This is a prop in an object in an array in an object!'
-        //        }
-        //      ],
-        //      arr2: [
-        //        [
-        //          'array of strings',
-        //          'with two strings'
-        //        ],
-        //        [
-        //          1, 2, 3
-        //        ]
-        //      ]
-        //    },
-        //    num: 1234,
-        //    fn: function() {
-        //      return 'Hello from a function!';
-        //    }
-        //  }
-        //});
         Navigation.startSingleScreenApp({
-          screen: {
-            screen: 'example.FirstTabScreen',
-            title: 'Login',
-            topTabs: [
-              {
-                screenId: 'example.ListScreen',
-                title: 'Tab1',
-                passProps: {
-                  str: 'This is a prop passed to Tab1'
-                }
-              },
-              {
-                screenId: 'example.PushedScreen',
-                title: 'Tab2',
-                passProps: {
-                  str: 'This is a prop passed to Tab2'
-                }
-
-              },
-              {
-                screenId: 'example.PushedScreen',
-                title: 'Tab3',
-                passProps: {
-                  str: 'This is a prop passed to Tab3'
-                }
-              },
-              {
-                screenId: 'example.FirstTabScreen',
-                title: 'Tab4',
-                passProps: {
-                  str: 'This is a prop passed to Tab4',
-                  fn: () => 'Hello from a function passed as passProps!'
-                }
-              }
-            ],
-            navigatorStyle: {}
-          }
+         screen: {
+           screen: 'example.LoginScreen',
+           title: 'Login',
+           navigatorStyle: {}
+         },
+         passProps: {
+           str: 'This is a prop passed in \'startSingleScreenApp()\'!',
+           obj: {
+             str: 'This is a prop passed in an object!',
+             arr: [
+               {
+                 str: 'This is a prop in an object in an array in an object!'
+               }
+             ],
+             arr2: [
+               [
+                 'array of strings',
+                 'with two strings'
+               ],
+               [
+                 1, 2, 3
+               ]
+             ]
+           },
+           num: 1234,
+           fn: function() {
+             return 'Hello from a function!';
+           }
+         }
         });
+        // Navigation.startSingleScreenApp({
+        //   screen: {
+        //     screen: 'example.FirstTabScreen',
+        //     title: 'Login',
+        //     topTabs: [
+        //       {
+        //         screenId: 'example.ListScreen',
+        //         title: 'Tab1',
+        //         passProps: {
+        //           str: 'This is a prop passed to Tab1'
+        //         }
+        //       },
+        //       {
+        //         screenId: 'example.PushedScreen',
+        //         title: 'Tab2',
+        //         passProps: {
+        //           str: 'This is a prop passed to Tab2'
+        //         }
+        //
+        //       },
+        //       {
+        //         screenId: 'example.PushedScreen',
+        //         title: 'Tab3',
+        //         passProps: {
+        //           str: 'This is a prop passed to Tab3'
+        //         }
+        //       },
+        //       {
+        //         screenId: 'example.FirstTabScreen',
+        //         title: 'Tab4',
+        //         passProps: {
+        //           str: 'This is a prop passed to Tab4',
+        //           fn: () => 'Hello from a function passed as passProps!'
+        //         }
+        //       }
+        //     ],
+        //     navigatorStyle: {}
+        //   },
+        //   drawer: { // optional, add this if you want a side menu drawer in your app
+        //     left: { // optional, define if you want a drawer from the left
+        //       screen: 'example.SideMenu' // unique ID registered with Navigation.registerScreen
+        //     },
+        //     disableOpenGesture: false // optional, can the drawer be opened with a swipe instead of button
+        //   }
+        // });
         return;
       case 'after-login':
         Navigation.startTabBasedApp({
               icon: require('../img/one.png'),
               selectedIcon: require('../img/one_selected.png'),
               title: 'Screen One',
-              navigatorStyle: {},
+              navigatorStyle: {}
             },
             {
               label: 'Two',
               icon: require('../img/two.png'),
               selectedIcon: require('../img/two_selected.png'),
               title: 'Screen Two',
-              navigatorStyle: {},
+              navigatorStyle: {}
             }
           ],
           passProps: {
             num: 1234
           },
           animationType: 'slide-down',
-          title: 'Redux Example'
+          title: 'Redux Example',
+          drawer: { // optional, add this if you want a side menu drawer in your app
+            left: { // optional, define if you want a drawer from the left
+              screen: 'example.BottomTabsSideMenu' // unique ID registered with Navigation.registerScreen
+            },
+            disableOpenGesture: false, // optional, can the drawer be opened with a swipe instead of button
+            passProps: {
+              title: 'Hello from SideMenu'
+            }
+          }
         });
         return;
       default:

example-redux/src/screens/BottomTabsSideMenu.js

+import React, {Component, PropTypes} from 'react';
+import {
+  Text,
+  View,
+  ScrollView,
+  TouchableOpacity,
+  StyleSheet,
+  Alert
+} from 'react-native';
+import {connect} from 'react-redux';
+import * as counterActions from '../reducers/counter/actions';
+import _ from 'lodash';
+
+class SideMenu extends Component {
+
+  constructor(props) {
+    super(props);
+    // if you want to listen on navigator events, set this up
+    this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
+  }
+
+  onNavigatorEvent(event) {
+      console.log('SideMenu', 'Unhandled event ' + event.id);
+  }
+
+  render() {
+    return (
+      <View style={styles.sideMenu}>
+        <Text style={styles.title}>{this.props.title}</Text>
+
+        <TouchableOpacity onPress={ this.onShowModalPress.bind(this) }>
+          <Text style={styles.button}>Show modal</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onPushScreenToFirstTab.bind(this) }>
+          <Text style={styles.button}>Push screen to first tab</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onPushScreenToSecondTab.bind(this) }>
+          <Text style={styles.button}>Push screen to second tab</Text>
+        </TouchableOpacity>
+      </View>
+    );
+  }
+
+  onShowModalPress() {
+    this.props.navigator.showModal({
+      title: "Modal Screen from SideMenu",
+      screen: "example.PushedScreen",
+      passProps: {
+        str: 'This is a prop passed in \'navigator.showModal()\'!',
+        obj: {
+          str: 'This is a prop passed in an object!',
+          arr: [
+            {
+              str: 'This is a prop in an object in an array in an object!'
+            }
+          ]
+        },
+        num: 1234
+      }
+    });
+  }
+
+  onPushScreenToFirstTab() {
+    this.props.navigator.handleDeepLink({
+      link: 'tab1/pushScreen/example.PushedScreen'
+    });
+  }
+
+  onPushScreenToSecondTab() {
+    console.log('SideMenu', 'onPushScreenToSecondTab ' + 'tab2/pushScreen/example.PushedScreen');
+    this.props.navigator.handleDeepLink({
+      link: 'tab2/pushScreen/example.PushedScreen'
+    });
+  }
+}
+
+const styles = StyleSheet.create({
+  sideMenu: {
+    flex: 1,
+    width: 260,
+    backgroundColor: '#efefef',
+    padding: 20
+  },
+  title: {
+    textAlign: 'center',
+    marginBottom: 15
+  },
+  button: {
+    textAlign: 'center',
+    fontSize: 18,
+    borderBottomWidth: 1,
+    borderColor: 'grey',
+    marginBottom: 10,
+    marginTop:10,
+    color: 'black'
+  }
+});
+
+export default connect()(SideMenu);

example-redux/src/screens/FirstTabScreen.js

   }
 
   onNavigatorEvent(event) {
-    switch (event.id) {
-      case 'edit':
-        Alert.alert('NavBar', 'Edit button pressed');
-        break;
-
-      case 'add':
-        Alert.alert('NavBar', 'Add button pressed');
-        break;
-
-      case 'selectedTabChanged':
-        this.onTabSelected(event.position);
-        break;
+    if (event.type == 'DeepLink') {
+      this.handleDeepLink(event);
+    } else {
+      switch (event.id) {
+        case 'edit':
+          Alert.alert('NavBar', 'Edit button pressed');
+          break;
+
+        case 'add':
+          Alert.alert('NavBar', 'Add button pressed');
+          break;
+
+        case 'selectedTabChanged':
+          this.onTabSelected(event.position);
+          break;
+
+        default:
+          console.log('Unhandled event ' + event.id);
+          break;
+      }
+    }
+  }
 
-      default:
-        console.log('Unhandled event ' + event.id);
-        break;
+  handleDeepLink(event) {
+    const parts = event.link.split('/');
+    if (parts[0] == 'tab1' && parts[1] == 'pushScreen') {
+      this.props.navigator.toggleDrawer({
+        side: 'left',
+        animated: true,
+        to: 'closed'
+      });
+
+      this.props.navigator.push({
+        title: "Pushed from SideMenu",
+        screen: parts[2],
+        passProps: {
+          str: 'This is a prop passed in \'navigator.push()\'!',
+          obj: {
+            str: 'This is a prop passed in an object!',
+            arr: [
+              {
+                str: 'This is a prop in an object in an array in an object!'
+              }
+            ]
+          },
+          num: 1234
+        }
+      });
     }
+    return;
   }
 
   onTabSelected(position) {

example-redux/src/screens/ListScreen.js

 
   constructor(props) {
     super(props);
-
+    this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
+    
     var ds = new ListView.DataSource({rowHasChanged: (r1, r2) => r1 !== r2});
     this.state = {
       dataSource: ds.cloneWithRows(this._genRows({}))
     }
   }
 
-  componentWillMount() {
-    this._pressData = {};
+  onNavigatorEvent(event) {
+    if (event.type == 'DeepLink') {
+      const parts = event.link.split('/');
+      if (parts[0] == 'tab1' && parts[1] == 'pushScreen') {
+        this.props.navigator.toggleDrawer({
+          side: 'left',
+          animated: true,
+          to: 'closed'
+        });
+
+        this.props.navigator.push({
+          title: "Pushed from SideMenu",
+          screen: parts[2],
+          passProps: {
+            str: 'This is a prop passed in \'navigator.push()\'!',
+            obj: {
+              str: 'This is a prop passed in an object!',
+              arr: [
+                {
+                  str: 'This is a prop in an object in an array in an object!'
+                }
+              ]
+            },
+            num: 1234
+          }
+        });
+      }
+    }
+      console.log('ListScreen', 'Unhandled event ' + event.id);
   }
 
   render() {

example-redux/src/screens/SecondTabScreen.js

   constructor(props) {
     super(props);
     this.buttonsCounter = 0;
+    this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
   }
 
   render() {
   }
 
   onNavigatorEvent(event) {
-    switch (event.id) {
-      case 'left':
-        Alert.alert('NavBar', 'Left button pressed');
-        break;
-      case 'right':
-        Alert.alert('NavBar', 'Right button pressed');
-        break;
+    if (event.type == 'DeepLink') {
+      this.handleDeepLink(event);
+    } else {
+      switch (event.id) {
+        case 'left':
+          Alert.alert('NavBar', 'Left button pressed');
+          break;
+        case 'right':
+          Alert.alert('NavBar', 'Right button pressed');
+          break;
+      }
     }
+    console.log('ListScreen', 'Unhandled event ' + event.id);
   }
+
+  handleDeepLink(event) {
+    const parts = event.link.split('/');
+    if (parts[0] == 'tab2' && parts[1] == 'pushScreen') {
+      this.props.navigator.toggleDrawer({
+        side: 'left',
+        animated: true,
+        to: 'closed'
+      });
+
+      this.props.navigator.push({
+        title: "Pushed from SideMenu",
+        screen: parts[2],
+        passProps: {
+          str: 'This is a prop passed in \'navigator.push()\'!',
+          obj: {
+            str: 'This is a prop passed in an object!',
+            arr: [
+              {
+                str: 'This is a prop in an object in an array in an object!'
+              }
+            ]
+          },
+          num: 1234
+        }
+      });
+    }
+    return;
+
+  }
+
 }
 
 const styles = StyleSheet.create({

example-redux/src/screens/SideMenu.js

+import React, {Component, PropTypes} from 'react';
+import {
+  Text,
+  View,
+  ScrollView,
+  TouchableOpacity,
+  StyleSheet,
+  Alert
+} from 'react-native';
+import {connect} from 'react-redux';
+import * as counterActions from '../reducers/counter/actions';
+import _ from 'lodash';
+
+class SideMenu extends Component {
+
+  constructor(props) {
+    super(props);
+    // if you want to listen on navigator events, set this up
+    this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
+  }
+
+  onNavigatorEvent(event) {
+      console.log('SideMenu', 'Unhandled event ' + event.id);
+  }
+
+  render() {
+    return (
+      <View style={styles.sideMenu}>
+        <Text style={styles.title}>Hello from SideMenu</Text>
+
+        <TouchableOpacity onPress={ this.onShowModalPress.bind(this) }>
+          <Text style={styles.button}>Show modal</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onPushScreen.bind(this) }>
+          <Text style={styles.button}>Push screen</Text>
+        </TouchableOpacity>
+      </View>
+    );
+  }
+
+  onShowModalPress() {
+    this.props.navigator.showModal({
+      title: "Modal Screen from SideMenu",
+      screen: "example.PushedScreen",
+      passProps: {
+        str: 'This is a prop passed in \'navigator.showModal()\'!',
+        obj: {
+          str: 'This is a prop passed in an object!',
+          arr: [
+            {
+              str: 'This is a prop in an object in an array in an object!'
+            }
+          ]
+        },
+        num: 1234
+      }
+    });
+  }
+
+  onPushScreen() {
+    this.props.navigator.handleDeepLink({
+      link: 'tab1/pushScreen/example.PushedScreen'
+    });
+  }
+}
+
+const styles = StyleSheet.create({
+  sideMenu: {
+    flex: 1,
+    backgroundColor: '#efefef',
+    padding: 20
+  },
+  title: {
+    textAlign: 'center',
+    marginBottom: 15
+  },
+  button: {
+    textAlign: 'center',
+    fontSize: 18,
+    borderBottomWidth: 1,
+    borderColor: 'grey',
+    marginBottom: 10,
+    marginTop:10,
+    color: 'black'
+  }
+});
+
+export default connect()(SideMenu);

example-redux/src/screens/index.js

 import SecondTabScreen from './SecondTabScreen';
 import PushedScreen from './PushedScreen';
 import ListScreen from './ListScreen';
+import SideMenu from './SideMenu';
+import BottomTabsSideMenu from './BottomTabsSideMenu';
 
 // register all screens of the app (including internal ones)
 export function registerScreens(store, Provider) {
   Navigation.registerComponent('example.SecondTabScreen', () => SecondTabScreen, store, Provider);
   Navigation.registerComponent('example.PushedScreen', () => PushedScreen, store, Provider);
   Navigation.registerComponent('example.ListScreen', () => ListScreen, store, Provider);
+  Navigation.registerComponent('example.SideMenu', () => SideMenu, store, Provider);
+  Navigation.registerComponent('example.BottomTabsSideMenu', () => BottomTabsSideMenu, store, Provider);
 }

src/deprecated/platformSpecificDeprecated.android.js

     return;
   }
   addNavigatorParams(screen);
-  addNavigatorButtons(screen);
+  addNavigatorButtons(screen, params.drawer);
   addNavigationStyleParams(screen);
   screen.passProps = params.passProps;
 
-  //const drawer = setupDrawer(params.drawer);
-
   /*
    * adapt to new API
    */
   params.screen = adaptNavigationStyleToScreenStyle(screen);
   params.screen = adaptNavigationParams(screen);
   params.appStyle = convertStyleParams(params.appStyle);
+  params.sideMenu = convertDrawerParamsToSideMenuParams(params.drawer);
 
   newPlatformSpecific.startApp(params);
 }
   }
 }
 
+function convertDrawerParamsToSideMenuParams(drawerParams) {
+  const drawer = Object.assign({}, drawerParams);
+  if (!drawer.left || !drawer.left.screen) {
+    return null;
+  }
+
+  let result = {};
+  result.disableOpenGesture = drawer.disableOpenGesture !== undefined;
+  result.screenId = drawer.left.screen;
+  addNavigatorParams(result);
+  result = adaptNavigationParams(result);
+  result.passProps = drawer.passProps;
+  return result;
+}
+
 function adaptNavigationParams(screen) {
   screen.navigationParams = {
     screenInstanceID: screen.screenInstanceID,
 
   params.tabs.forEach(function(tab, idx) {
     addNavigatorParams(tab, null, idx);
-    addNavigatorButtons(tab);
+    addNavigatorButtons(tab, params.drawer);
     addNavigationStyleParams(tab);
     addTabIcon(tab);
     tab.passProps = params.passProps;
   params.tabs = newTabs;
 
   params.appStyle = convertStyleParams(params.appStyle);
-  // TODO: add drawer params
+  params.sideMenu = convertDrawerParamsToSideMenuParams(params.drawer);
 
   newPlatformSpecific.startApp(params);
 }
 }
 
 function navigatorToggleDrawer(navigator, params) {
-  //RctActivity.toggleDrawer({
-  //  side: params.side,
-  //  animated: !(params.animated === false),
-  //  to: params.to || ''
-  //});
+  const animated = !(params.animated === false);
+  if (params.to) {
+    const visible = params.to === 'open';
+    newPlatformSpecific.setSideMenuVisible(animated, visible);
+  } else {
+    newPlatformSpecific.toggleSideMenuVisible(animated);
+  }
 }
 
 function navigatorToggleNavBar(navigator, params) {
   screen.navigatorEventID = screen.screenInstanceID + '_events';
 }
 
-function addNavigatorButtons(screen) {
+function addNavigatorButtons(screen, sideMenuParams) {
   const Screen = Navigation.getRegisteredScreen(screen.screen);
   Object.assign(screen, Screen.navigatorButtons);
 
     });
   }
 
-  const leftButton = getLeftButton(screen);
+  let leftButton = getLeftButton(screen);
+  if (sideMenuParams && !leftButton) {
+    leftButton = createSideMenuButton();
+  }
   if (leftButton) {
     if (leftButton.icon) {
       const icon = resolveAssetSource(leftButton.icon);
   }
 }
 
+function createSideMenuButton() {
+  return {
+    id: "sideMenu"
+  };
+}
+
 function addTitleBarBackButtonIfNeeded(screen) {
   const leftButton = getLeftButton(screen);
   if (!leftButton) {
   screen.navigatorStyle = Object.assign({}, screen.navigatorStyle, Screen.navigatorStyle);
 }
 
-function setupDrawer(drawerParams) {
-  const drawer = Object.assign({}, drawerParams);
-  [drawer.left, drawer.right].forEach(side => {
-    if (!side) {
-      return;
-    }
-    const icon = resolveAssetSource(side.icon);
-    if (icon) {
-      side.icon = icon.uri;
-    }
-  });
-  if (drawer.disableOpenGesture === undefined) {
-    drawer.disableOpenGesture = false;
-  }
-
-  return drawer;
-}
-
 export default {
   startTabBasedApp,
   startSingleScreenApp,

src/platformSpecific.android.js

       savePassProps(tab);
     });
   }
+
+  if (params.sideMenu) {
+    PropRegistry.save(params.sideMenu.navigationParams.screenInstanceID, params.sideMenu.passProps);
+  }
+}
+
+function toggleSideMenuVisible(animated) {
+  NativeReactModule.toggleSideMenuVisible(animated);
+}
+
+function setSideMenuVisible(animated, visible) {
+  NativeReactModule.setSideMenuVisible(animated, visible);
 }
 
 module.exports = {
   setScreenTitleBarButtons,
   showModal,
   dismissTopModal,
-  dismissAllModals
+  dismissAllModals,
+  toggleSideMenuVisible,
+  setSideMenuVisible
 };