Side menu works

android/app/src/main/java/com/reactnativenavigation/layout/Container.java

 import android.widget.FrameLayout;
 
 public class Container extends FrameLayout {
-    public Container(Context context, LayoutFactory.RootViewCreator rootViewCreator, String id, String name) {
+    public Container(Context context, LayoutFactory.ReactRootViewCreator reactRootViewCreator, String id, String name) {
         super(context);
-        addView(rootViewCreator.createRootView(id, name));
+        addView(reactRootViewCreator.create(id, name));
     }
 }

android/app/src/main/java/com/reactnativenavigation/layout/ContainerStack.java → android/app/src/main/java/com/reactnativenavigation/layout/ContainerStackLayout.java

 import android.content.Context;
 import android.widget.FrameLayout;
 
-public class ContainerStack extends FrameLayout {
-    public ContainerStack(Context context) {
+public class ContainerStackLayout extends FrameLayout {
+    public ContainerStackLayout(Context context) {
         super(context);
     }
 }

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

 package com.reactnativenavigation.layout;
 
 import android.app.Activity;
+import android.support.v4.widget.DrawerLayout;
+import android.view.Gravity;
 import android.view.View;
+import android.view.ViewGroup.LayoutParams;
 
-import com.reactnativenavigation.layout.bottomtabs.BottomTabsContainer;
 import com.reactnativenavigation.layout.bottomtabs.BottomTabsCreator;
+import com.reactnativenavigation.layout.bottomtabs.BottomTabsLayout;
+import com.reactnativenavigation.utils.ViewIdGenerator;
 
 import java.util.List;
 
 public class LayoutFactory {
 
-    public interface RootViewCreator {
-        View createRootView(String id, String name);
+    public interface ReactRootViewCreator {
+        View create(String id, String name);
     }
 
     private final Activity activity;
-    private final RootViewCreator rootViewCreator;
+    private final ReactRootViewCreator reactRootViewCreator;
     private final BottomTabsCreator bottomTabsCreator; // TODO: revisit this, may not be needed
 
-    public LayoutFactory(Activity activity, RootViewCreator rootViewCreator, BottomTabsCreator bottomTabsCreator) {
+    public LayoutFactory(Activity activity, ReactRootViewCreator reactRootViewCreator, BottomTabsCreator bottomTabsCreator) {
         this.activity = activity;
-        this.rootViewCreator = rootViewCreator;
+        this.reactRootViewCreator = reactRootViewCreator;
         this.bottomTabsCreator = bottomTabsCreator;
     }
 
                 return createContainerStackView(node);
             case "BottomTabs":
                 return createBottomTabs(node);
+            case "SideMenuRoot":
+                return createSideMenuRoot(node);
+            case "SideMenuCenter":
+                return createSideMenuContent(node);
+            case "SideMenuLeft":
+                return createSideMenuLeft(node);
+            case "SideMenuRight":
+                return createSideMenuRight(node);
             default:
                 throw new IllegalArgumentException("Invalid node type: "+node.type);
         }
     }
 
+    private View createSideMenuRoot(LayoutNode node) {
+        SideMenuLayout sideMenuLayout = new SideMenuLayout(activity);
+        for (LayoutNode child : node.children) {
+            sideMenuLayout.addView(create(child));
+        }
+        return sideMenuLayout;
+    }
+
+    private View createSideMenuContent(LayoutNode node) {
+        return create(node.children.get(0));
+    }
+
+    private View createSideMenuLeft(LayoutNode node) {
+        View view = create(node.children.get(0));
+        view.setId(ViewIdGenerator.generate());
+        DrawerLayout.LayoutParams lp = new DrawerLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+        lp.gravity = Gravity.LEFT;
+        view.setLayoutParams(lp);
+        return view;
+    }
+
+    private View createSideMenuRight(LayoutNode node) {
+        View view = create(node.children.get(0));
+        view.setId(ViewIdGenerator.generate());
+        DrawerLayout.LayoutParams lp = new DrawerLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+        lp.gravity = Gravity.RIGHT;
+        view.setLayoutParams(lp);
+        return view;
+    }
+
     private View createContainerView(LayoutNode node) {
         final String name = (String) node.data.get("name");
-        return new Container(activity, rootViewCreator, node.id, name);
+        Container container = new Container(activity, reactRootViewCreator, node.id, name);
+        container.setId(ViewIdGenerator.generate());
+        return container;
+
     }
 
     private View createContainerStackView(LayoutNode node) {
-        final ContainerStack containerStack = new ContainerStack(activity);
+        final ContainerStackLayout containerStack = new ContainerStackLayout(activity);
+        containerStack.setId(ViewIdGenerator.generate());
         addChildrenNodes(containerStack, node.children);
         return containerStack;
     }
 
     private View createBottomTabs(LayoutNode node) {
-        final BottomTabsContainer tabsContainer = new BottomTabsContainer(activity, bottomTabsCreator.create());
-
-        int i = 0;
-        for (LayoutNode child : node.children) {
-            final View tabContent = create(child);
+        final BottomTabsLayout tabsContainer = new BottomTabsLayout(activity, bottomTabsCreator.create());
+        for (int i = 0; i < node.children.size(); i++) {
+            final View tabContent = create(node.children.get(i));
             tabsContainer.addTabContent("#" + i, tabContent);
-            i++;
         }
         return tabsContainer;
     }
 
-    private void addChildrenNodes(ContainerStack containerStack, List<LayoutNode> children) {
+    private void addChildrenNodes(ContainerStackLayout containerStack, List<LayoutNode> children) {
         for (LayoutNode child : children) {
             containerStack.addView(create(child));
         }

android/app/src/main/java/com/reactnativenavigation/layout/LayoutNode.java

     public LayoutNode() {
     }
 
+    public LayoutNode(String type, List<LayoutNode> children) {
+        this.type = type;
+        this.children = children;
+    }
+
     public LayoutNode(String id, String type, Map<String, Object> data) {
         this.id = id;
         this.type = type;

android/app/src/main/java/com/reactnativenavigation/layout/SideMenuLayout.java

+package com.reactnativenavigation.layout;
+
+import android.content.Context;
+import android.support.v4.widget.DrawerLayout;
+
+public class SideMenuLayout extends DrawerLayout {
+    public SideMenuLayout(Context context) {
+        super(context);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/layout/bottomtabs/BottomTabs.java

 package com.reactnativenavigation.layout.bottomtabs;
 
 import android.graphics.Color;
-import android.os.Build;
 import android.support.annotation.NonNull;
 import android.support.design.widget.BottomNavigationView;
 import android.view.Menu;
 import android.view.MenuItem;
-import android.view.View;
 import android.widget.RelativeLayout;
 import android.widget.RelativeLayout.LayoutParams;
 
-import java.util.concurrent.atomic.AtomicInteger;
-
+import static android.view.View.generateViewId;
 import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
 
 public class BottomTabs implements BottomNavigationView.OnNavigationItemSelectedListener {
         void onTabSelected(int index);
     }
 
-    private static final AtomicInteger viewId = new AtomicInteger(1);
-
     private BottomNavigationView bottomNavigationView;
     private BottomTabsSelectionListener listener;
 
     public void attach(RelativeLayout parentLayout) {
         createBottomNavigation(parentLayout);
-        addButtomNavigationToParent(parentLayout);
+        addBottomNavigationToParent(parentLayout);
     }
 
     public void setSelectionListener(BottomTabsSelectionListener listener) {
         bottomNavigationView.setOnNavigationItemSelectedListener(this);
     }
 
-    private void addButtomNavigationToParent(RelativeLayout parentLayout) {
+    private void addBottomNavigationToParent(RelativeLayout parentLayout) {
         LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
         lp.addRule(ALIGN_PARENT_BOTTOM);
         bottomNavigationView.setLayoutParams(lp);
         parentLayout.addView(bottomNavigationView, lp);
     }
-
-    private int generateViewId() {
-        if (Build.VERSION.SDK_INT >= 17) {
-            return View.generateViewId();
-        } else {
-            return compatGenerateViewId();
-        }
-    }
-
-    private int compatGenerateViewId() {
-        while(true) {
-            final int result = viewId.get();
-            // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
-            int newValue = result + 1;
-            if (newValue > 0x00FFFFFF) newValue = 1; // Roll over to 1, not 0.
-            if (viewId.compareAndSet(result, newValue)) {
-                return result;
-            }
-        }
-    }
 }

android/app/src/main/java/com/reactnativenavigation/layout/bottomtabs/BottomTabsContainer.java → android/app/src/main/java/com/reactnativenavigation/layout/bottomtabs/BottomTabsLayout.java

 import java.util.ArrayList;
 import java.util.List;
 
-public class BottomTabsContainer extends RelativeLayout implements BottomTabs.BottomTabsSelectionListener {
+public class BottomTabsLayout extends RelativeLayout implements BottomTabs.BottomTabsSelectionListener {
 
     private List<View> tabsContent;
     private BottomTabs bottomTabs;
     private int currentTab;
 
-    public BottomTabsContainer(Activity activity, BottomTabs bottomTabs) {
+    public BottomTabsLayout(Activity activity, BottomTabs bottomTabs) {
         super(activity);
         initBottomTabs(bottomTabs);
     }

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

         NavigationActivity.instance.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                LayoutFactory factory = new LayoutFactory(NavigationActivity.instance, new LayoutFactory.RootViewCreator() {
+                LayoutFactory factory = new LayoutFactory(NavigationActivity.instance, new LayoutFactory.ReactRootViewCreator() {
                     @Override
-                    public View createRootView(String id, String name) {
+                    public View create(String id, String name) {
                         ReactRootView rootView = new ReactRootView(NavigationActivity.instance);
                         Bundle opts = new Bundle();
                         opts.putString("id", id);

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

+package com.reactnativenavigation.utils;
+
+import android.os.Build;
+import android.view.View;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ViewIdGenerator {
+    private static final AtomicInteger viewId = new AtomicInteger(1);
+
+    public static int generate() {
+        if (Build.VERSION.SDK_INT >= 17) {
+            return View.generateViewId();
+        } else {
+            return compatGenerateViewId();
+        }
+    }
+
+    private static int compatGenerateViewId() {
+        while(true) {
+            final int result = viewId.get();
+            // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
+            int newValue = result + 1;
+            if (newValue > 0x00FFFFFF) newValue = 1; // Roll over to 1, not 0.
+            if (viewId.compareAndSet(result, newValue)) {
+                return result;
+            }
+        }
+    }
+}

android/app/src/test/java/com/reactnativenavigation/BottomTabsContainerTest.java

 import android.view.View;
 
 import com.reactnativenavigation.layout.bottomtabs.BottomTabs;
-import com.reactnativenavigation.layout.bottomtabs.BottomTabsContainer;
+import com.reactnativenavigation.layout.bottomtabs.BottomTabsLayout;
 import com.reactnativenavigation.layout.bottomtabs.TooManyTabsException;
 
 import org.junit.Before;
     public void addsTabToBottomTabs() throws Exception {
         View tabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
 
         verify(bottomTabs).add(TAB_NAME);
     public void addsTabContentToLayout() throws Exception {
         View tabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
 
         verify(bottomTabs).attach(bottomTabsContainer);
         View tabContent = new View(activity);
         View otherTabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
         bottomTabsContainer.addTabContent(OTHER_TAB_NAME, otherTabContent);
 
 
     @Test (expected = TooManyTabsException.class)
     public void throwsExceptionWhenMoreThenFiveTabs() throws Exception {
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         for (int i = 0; i < 6; i++) {
             View content = new View(activity);
             bottomTabsContainer.addTabContent("#" + i, content);
 
     @Test
     public void addFiveTabs() throws Exception {
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         for (int i = 0; i < 5; i++) {
             View content = new View(activity);
             bottomTabsContainer.addTabContent("#" + i, content);
         View tabContent = new View(activity);
         View otherTabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
         bottomTabsContainer.addTabContent(OTHER_TAB_NAME, otherTabContent);
 
 
     @Test
     public void listensToTabsSwitchingEvents() throws Exception {
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         verify(bottomTabs).setSelectionListener(bottomTabsContainer);
     }
 
         View tabContent = new View(activity);
         View otherTabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
         bottomTabsContainer.addTabContent(OTHER_TAB_NAME, otherTabContent);
         bottomTabsContainer.onTabSelected(1);
         View tabContent = new View(activity);
         View otherTabContent = new View(activity);
 
-        BottomTabsContainer bottomTabsContainer = createBottomTabsContainer();
+        BottomTabsLayout bottomTabsContainer = createBottomTabsContainer();
         bottomTabsContainer.addTabContent(TAB_NAME, tabContent);
         bottomTabsContainer.addTabContent(OTHER_TAB_NAME, otherTabContent);
         bottomTabsContainer.onTabSelected(1);
         assertThat(otherTabContent.getVisibility()).isEqualTo(View.GONE);
     }
 
-    private BottomTabsContainer createBottomTabsContainer() {
-        return new BottomTabsContainer(activity, bottomTabs);
+    private BottomTabsLayout createBottomTabsContainer() {
+        return new BottomTabsLayout(activity, bottomTabs);
     }
 }

android/app/src/test/java/com/reactnativenavigation/LayoutFactoryTest.java

 import android.view.ViewGroup;
 
 import com.reactnativenavigation.layout.Container;
-import com.reactnativenavigation.layout.ContainerStack;
+import com.reactnativenavigation.layout.ContainerStackLayout;
 import com.reactnativenavigation.layout.LayoutFactory;
 import com.reactnativenavigation.layout.LayoutNode;
+import com.reactnativenavigation.layout.SideMenuLayout;
 import com.reactnativenavigation.layout.bottomtabs.BottomTabs;
-import com.reactnativenavigation.layout.bottomtabs.BottomTabsContainer;
 import com.reactnativenavigation.layout.bottomtabs.BottomTabsCreator;
+import com.reactnativenavigation.layout.bottomtabs.BottomTabsLayout;
 
 import org.junit.Before;
 import org.junit.Test;
 @RunWith(RobolectricTestRunner.class)
 public class LayoutFactoryTest {
 
-    private final static String VIEW_ID = "myUniqueId";
-    private final static String VIEW_NAME = "myName";
+    private final static String NODE_ID = "myUniqueId";
+    private final static String REACT_ROOT_VIEW_KEY = "myName";
 
-    private final static String OTHER_VIEW_ID = "anotherUniqueId";
-    private final static String OTHER_VIEW_NAME = "anotherName";
+    private final static String OTHER_NODE_ID = "anotherUniqueId";
+    private final static String OTHER_REACT_ROOT_VIEW_KEY = "anotherName";
 
     private Activity activity;
     private View mockView;
     private View otherMockView;
-    private LayoutFactory.RootViewCreator rootViewCreator;
+    private LayoutFactory.ReactRootViewCreator reactRootViewCreator;
 
     @Before
     public void setUp() {
         activity = Robolectric.buildActivity(AppCompatActivity.class).get();
         mockView = new View(activity);
         otherMockView = new View(activity);
-        rootViewCreator = mock(LayoutFactory.RootViewCreator.class);
+        reactRootViewCreator = mock(LayoutFactory.ReactRootViewCreator.class);
     }
 
     @Test
     public void returnsContainerThatHoldsTheRootView() throws Exception {
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
         final LayoutNode node = createContainerNode();
 
         final ViewGroup result = (ViewGroup) createLayoutFactory().create(node);
 
     @Test
     public void returnsContainerStack() throws Exception {
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
         final LayoutNode containerNode = createContainerNode();
         final LayoutNode stackNode = createContainerStackNode(containerNode);
 
         final ViewGroup result = (ViewGroup) createLayoutFactory().create(stackNode);
 
-        assertThat(result).isInstanceOf(ContainerStack.class);
+        assertThat(result).isInstanceOf(ContainerStackLayout.class);
         ViewGroup container = (ViewGroup) TestUtils.assertViewChildrenCount(result, 1).get(0);
         TestUtils.assertViewChildren(container, mockView);
     }
     public void returnsContainerStackWithMultipleViews() throws Exception {
         final View mockView1 = mock(View.class);
         final View mockView2 = mock(View.class);
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView1);
-        when(rootViewCreator.createRootView(eq(OTHER_VIEW_ID), eq(OTHER_VIEW_NAME))).thenReturn(mockView2);
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView1);
+        when(reactRootViewCreator.create(eq(OTHER_NODE_ID), eq(OTHER_REACT_ROOT_VIEW_KEY))).thenReturn(mockView2);
 
-        final LayoutNode containerNode1 = createContainerNode(VIEW_ID, VIEW_NAME);
-        final LayoutNode containerNode2 = createContainerNode(OTHER_VIEW_ID, OTHER_VIEW_NAME);
+        final LayoutNode containerNode1 = createContainerNode(NODE_ID, REACT_ROOT_VIEW_KEY);
+        final LayoutNode containerNode2 = createContainerNode(OTHER_NODE_ID, OTHER_REACT_ROOT_VIEW_KEY);
         final LayoutNode stackNode = createContainerStackNode(containerNode1, containerNode2);
 
         final ViewGroup result = (ViewGroup) createLayoutFactory().create(stackNode);
 
-        assertThat(result).isInstanceOf(ContainerStack.class);
+        assertThat(result).isInstanceOf(ContainerStackLayout.class);
         List<View> containers = TestUtils.assertViewChildrenCount(result, 2);
         ViewGroup container1 = (ViewGroup) containers.get(0);
         ViewGroup container2 = (ViewGroup) containers.get(1);
         TestUtils.assertViewChildren(container2, mockView2);
     }
 
+    @Test
+    public void returnsSideMenuRoot() throws Exception {
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
+        final LayoutNode containerNode = createSideMenuContainerNode(Arrays.asList(createContainerNode()));
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(containerNode);
+        assertThat(result).isInstanceOf(SideMenuLayout.class);
+    }
+
+    @Test
+    public void hasContentContainer() throws Exception {
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
+        LayoutNode contentContainer = createContainerNode();
+        final LayoutNode sideMenu = createSideMenuContainerNode(Arrays.asList(contentContainer));
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(sideMenu);
+        assertThat(result.getChildAt(0)).isInstanceOf(Container.class);
+    }
+
+    @Test
+    public void hasLeftMenu() throws Exception {
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
+        LayoutNode sideMenuLeft = createSideMenuLeftNode();
+        final LayoutNode sideMenu = createSideMenuContainerNode(Arrays.asList(sideMenuLeft));
+        final ViewGroup result = (ViewGroup) createLayoutFactory().create(sideMenu);
+        assertThat(result.getChildAt(0)).isInstanceOf(Container.class);
+    }
+
     @Test
     public void returnsSingleTabContent() throws Exception {
         BottomTabs bottomTabsMock = mock(BottomTabs.class);
         when(bottomTabsMock.size()).thenReturn(0);
 
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
         final LayoutNode containerNode = createContainerNode();
-        final LayoutNode tabNode = createTabNode(containerNode);
+        final LayoutNode tabNode = createBottomTabNode(containerNode);
 
         final View result = createLayoutFactory(bottomTabsMock).create(tabNode);
 
         verify(bottomTabsMock).add("#0");
 
-        assertThat(result).isInstanceOf(BottomTabsContainer.class);
-        Container container = (Container) TestUtils.assertViewChildrenCount((BottomTabsContainer) result, 1).get(0);
+        assertThat(result).isInstanceOf(BottomTabsLayout.class);
+        Container container = (Container) TestUtils.assertViewChildrenCount((BottomTabsLayout) result, 1).get(0);
         View view = TestUtils.assertViewChildrenCount(container, 1).get(0);
         assertThat(view).isEqualTo(mockView);
     }
         BottomTabs bottomTabsMock = mock(BottomTabs.class);
         when(bottomTabsMock.size()).thenReturn(0, 1);
 
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
-        final LayoutNode firstTabRootNode = createContainerNode(VIEW_ID, VIEW_NAME);
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
+        final LayoutNode firstTabRootNode = createContainerNode(NODE_ID, REACT_ROOT_VIEW_KEY);
 
-        when(rootViewCreator.createRootView(eq(OTHER_VIEW_ID), eq(OTHER_VIEW_NAME))).thenReturn(otherMockView);
-        final LayoutNode secondTabRootNode = createContainerStackNode(createContainerNode(OTHER_VIEW_ID, OTHER_VIEW_NAME));
+        when(reactRootViewCreator.create(eq(OTHER_NODE_ID), eq(OTHER_REACT_ROOT_VIEW_KEY))).thenReturn(otherMockView);
+        final LayoutNode secondTabRootNode = createContainerStackNode(createContainerNode(OTHER_NODE_ID, OTHER_REACT_ROOT_VIEW_KEY));
 
-        final LayoutNode tabNode = createTabNode(firstTabRootNode, secondTabRootNode);
+        final LayoutNode tabNode = createBottomTabNode(firstTabRootNode, secondTabRootNode);
 
         final View result = createLayoutFactory(bottomTabsMock).create(tabNode);
 
-        assertThat(result).isInstanceOf(BottomTabsContainer.class);
+        assertThat(result).isInstanceOf(BottomTabsLayout.class);
         verify(bottomTabsMock).add(eq("#0"));
         verify(bottomTabsMock).add(eq("#1"));
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void throwsExceptionForUnknownType() throws Exception {
-        when(rootViewCreator.createRootView(eq(VIEW_ID), eq(VIEW_NAME))).thenReturn(mockView);
-        final LayoutNode node = new LayoutNode(VIEW_ID, "***unknownType***", Collections.<String, Object>emptyMap());
+        when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
+        final LayoutNode node = new LayoutNode(NODE_ID, "***unknownType***", Collections.<String, Object>emptyMap());
 
         createLayoutFactory().create(node);
     }
             when(bottomTabsCreator.create()).thenReturn(bottomTabs);
         }
 
-        return new LayoutFactory(activity, rootViewCreator, bottomTabsCreator);
+        return new LayoutFactory(activity, reactRootViewCreator, bottomTabsCreator);
     }
 
     private LayoutNode createContainerNode() {
-        return createContainerNode(VIEW_ID, VIEW_NAME);
+        return createContainerNode(NODE_ID, REACT_ROOT_VIEW_KEY);
+    }
+
+    private LayoutNode createSideMenuLeftNode() {
+        List<LayoutNode> children = Arrays.asList(createContainerNode());
+        return new LayoutNode("SideMenuLeft", children);
     }
 
     private LayoutNode createContainerNode(final String id, final String name) {
         return new LayoutNode(id, "Container", new HashMap<String, Object>() {{ put("name", name); }});
     }
 
+    private LayoutNode createSideMenuContainerNode(List<LayoutNode> children) {
+        return new LayoutNode("SideMenuRoot", children);
+    }
+
     private LayoutNode createContainerStackNode(LayoutNode... children) {
-        LayoutNode node = new LayoutNode();
-        node.type = "ContainerStack";
-        node.children = Arrays.asList(children);
-        return node;
+        return new LayoutNode("ContainerStack", Arrays.asList(children));
     }
 
-    private LayoutNode createTabNode(LayoutNode... children) {
-        LayoutNode node = new LayoutNode();
-        node.type = "BottomTabs";
-        node.children = Arrays.asList(children);
-        return node;
+    private LayoutNode createBottomTabNode(LayoutNode... children) {
+        return new LayoutNode("BottomTabs", Arrays.asList(children));
     }
 }