f

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

 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.BottomNavigation;
 import com.reactnativenavigation.views.RnnToolBar;
         mBottomNavigation = (BottomNavigation) findViewById(R.id.bottom_tab_bar);
         mContentFrame = (CoordinatorLayout) findViewById(R.id.contentFrame);
 
-        final ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
+        final ArrayList<_Screen> screens = (ArrayList<_Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
         final Drawer drawer = (Drawer) getIntent().getSerializableExtra(DRAWER_PARAMS);
         mBottomNavigation.setForceTint(true);
         setupDrawer(screens.get(0), drawer, R.id.drawerFrame, R.id.drawerLayout);
         });
     }
 
-    private void setupPages(ArrayList<Screen> screens) {
+    private void setupPages(ArrayList<_Screen> screens) {
         new SetupTabsTask(this, toolbar, screens).execute();
     }
 
-    private void setupToolbar(ArrayList<Screen> screens) {
+    private void setupToolbar(ArrayList<_Screen> screens) {
         toolbar.setScreens(screens);
-        Screen initialScreen = screens.get(0);
+        _Screen initialScreen = screens.get(0);
         toolbar.update(initialScreen);
         StyleHelper.updateStyles(toolbar, initialScreen);
     }
     }
 
     @Override
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         super.push(screen);
         for (ScreenStack stack : mScreenStacks) {
             if (stack.peek().navigatorId.equals(screen.navigatorId)) {
     }
 
     @Override
-    public Screen pop(String navigatorId) {
+    public _Screen pop(String navigatorId) {
         super.pop(navigatorId);
         for (ScreenStack stack : mScreenStacks) {
             if (stack.peek().navigatorId.equals(navigatorId)) {
-                Screen popped = stack.pop();
-                Screen currentScreen = getCurrentScreen();
+                _Screen popped = stack.pop();
+                _Screen currentScreen = getCurrentScreen();
                 StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
     }
 
     @Override
-    public Screen popToRoot(String navigatorId) {
+    public _Screen popToRoot(String navigatorId) {
         super.popToRoot(navigatorId);
         for (ScreenStack stack : mScreenStacks) {
             if (stack.peek().navigatorId.equals(navigatorId)) {
-                Screen popped = stack.popToRoot();
-                Screen currentScreen = getCurrentScreen();
+                _Screen popped = stack.popToRoot();
+                _Screen currentScreen = getCurrentScreen();
                 StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
     }
 
     @Override
-    public Screen getCurrentScreen() {
-        Screen currentScreen = super.getCurrentScreen();
+    public _Screen getCurrentScreen() {
+        _Screen currentScreen = super.getCurrentScreen();
         if (currentScreen != null) {
             return currentScreen;
         }
         return mScreenStacks != null ? mScreenStacks.get(mCurrentStackPosition).peek() : null;
     }
 
-    public Screen resetTo(Screen screen) {
+    public _Screen resetTo(_Screen screen) {
         super.resetTo(screen);
         StyleHelper.updateStyles(toolbar, screen);
         return mScreenStacks.get(mCurrentStackPosition).resetTo(screen);
         mBottomNavigation.toggleTabs(hide, animated);
     }
 
-    private boolean shouldToggleTabs(Screen newScreen) {
+    private boolean shouldToggleTabs(_Screen newScreen) {
         return mBottomNavigation.isShown() == newScreen.bottomTabsHidden;
     }
 
         mBottomNavigation.onScroll(direction);
     }
 
-    private static class SetupTabsTask extends AsyncTask<Void, Void, Map<Screen, Drawable>> {
+    private static class SetupTabsTask extends AsyncTask<Void, Void, Map<_Screen, Drawable>> {
         private BottomTabActivity mActivity;
         private RnnToolBar mToolBar;
-        private ArrayList<Screen> mScreens;
+        private ArrayList<_Screen> mScreens;
 
-        public SetupTabsTask(BottomTabActivity context, RnnToolBar toolBar, ArrayList<Screen> screens) {
+        public SetupTabsTask(BottomTabActivity context, RnnToolBar toolBar, ArrayList<_Screen> screens) {
             mActivity = context;
             mToolBar = toolBar;
             mScreens = screens;
         }
 
         @Override
-        protected Map<Screen, Drawable> doInBackground(Void... params) {
-            Map<Screen, Drawable> icons = new HashMap<>();
-            for (Screen screen : mScreens) {
+        protected Map<_Screen, Drawable> doInBackground(Void... params) {
+            Map<_Screen, Drawable> icons = new HashMap<>();
+            for (_Screen screen : mScreens) {
                 if (screen.icon != null) {
                     icons.put(screen, screen.getIcon(this.mActivity));
                 }
         }
 
         @Override
-        protected void onPostExecute(Map<Screen, Drawable> icons) {
+        protected void onPostExecute(Map<_Screen, Drawable> icons) {
             mActivity.setTabsWithIcons(mScreens, icons);
             StyleHelper.updateStyles(mToolBar, mActivity.getCurrentScreen());
         }
         return null;
     }
 
-    private void setTabsWithIcons(ArrayList<Screen> screens, Map<Screen, Drawable> icons) {
+    private void setTabsWithIcons(ArrayList<_Screen> screens, Map<_Screen, Drawable> icons) {
         mScreenStacks = new ArrayList<>();
         for (int i = 0; i < screens.size(); i++) {
-            final Screen screen = screens.get(i);
+            final _Screen screen = screens.get(i);
             ScreenStack stack = new ScreenStack(this);
             stack.push(screen);
             mScreenStacks.add(stack);

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

 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnToolBar;
 import com.reactnativenavigation.views.ScreenStack;
         setContentView(R.layout.single_screen_activity);
         toolbar = (RnnToolBar) findViewById(R.id.toolbar);
 
-        final Screen screen = (Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
+        final _Screen screen = (_Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
         final Drawer drawer = (Drawer) getIntent().getSerializableExtra(DRAWER_PARAMS);
 
         mNavigatorId = screen.navigatorId;
         });
     }
 
-    protected void setupToolbar(Screen screen) {
+    protected void setupToolbar(_Screen screen) {
         StyleHelper.updateStyles(toolbar, screen);
     }
 
     @Override
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         super.push(screen);
         mScreenStack.push(screen);
         StyleHelper.updateStyles(toolbar, screen);
     }
 
     @Override
-    public Screen pop(String navigatorId) {
+    public _Screen pop(String navigatorId) {
         super.pop(navigatorId);
-        Screen popped = mScreenStack.pop();
+        _Screen popped = mScreenStack.pop();
         StyleHelper.updateStyles(toolbar, getCurrentScreen());
         return popped;
     }
 
     @Override
-    public Screen popToRoot(String navigatorId) {
+    public _Screen popToRoot(String navigatorId) {
         super.popToRoot(navigatorId);
-        Screen screen = mScreenStack.popToRoot();
+        _Screen screen = mScreenStack.popToRoot();
         StyleHelper.updateStyles(toolbar, getCurrentScreen());
         return screen;
     }
 
     @Override
-    public Screen resetTo(Screen screen) {
+    public _Screen resetTo(_Screen screen) {
         super.resetTo(screen);
-        Screen popped = mScreenStack.resetTo(screen);
+        _Screen popped = mScreenStack.resetTo(screen);
         StyleHelper.updateStyles(toolbar, screen);
         return popped;
     }
     }
 
     @Override
-    public Screen getCurrentScreen() {
-        Screen currentScreen = super.getCurrentScreen();
+    public _Screen getCurrentScreen() {
+        _Screen currentScreen = super.getCurrentScreen();
         if (currentScreen != null) {
             return currentScreen;
         }

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

 
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.adapters.ViewPagerAdapter;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnTabLayout;
 import com.reactnativenavigation.views.RnnToolBar;
         mTabLayout = (RnnTabLayout) findViewById(R.id.tabLayout);
         mViewPager = (ViewPager) findViewById(R.id.viewPager);
 
-        ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
+        ArrayList<_Screen> screens = (ArrayList<_Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
 
         setupToolbar(screens);
         setupViewPager(screens);
     }
 
-    private void setupToolbar(ArrayList<Screen> screens) {
-        Screen initialScreen = screens.get(0);
+    private void setupToolbar(ArrayList<_Screen> screens) {
+        _Screen initialScreen = screens.get(0);
         toolbar.setScreens(screens);
         toolbar.update(initialScreen);
         setNavigationStyle(initialScreen);
     }
 
-    public void setNavigationStyle(Screen screen) {
+    public void setNavigationStyle(_Screen screen) {
         mTabLayout.setStyle(screen);
     }
 
-    private void setupViewPager(ArrayList<Screen> screens) {
+    private void setupViewPager(ArrayList<_Screen> screens) {
         mAdapter = new ViewPagerAdapter(this, mViewPager, toolbar, screens);
         mViewPager.setAdapter(mAdapter);
         mTabLayout.setupWithViewPager(mViewPager);
     }
 
     @Override
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         super.push(screen);
         StyleHelper.updateStyles(toolbar, screen);
         mAdapter.push(screen);
     }
 
     @Override
-    public Screen pop(String navigatorId) {
+    public _Screen pop(String navigatorId) {
         super.pop(navigatorId);
-        Screen popped = mAdapter.pop(navigatorId);
+        _Screen popped = mAdapter.pop(navigatorId);
         setNavigationStyle(getCurrentScreen());
         return popped;
     }
 
     @Override
-    public Screen getCurrentScreen() {
+    public _Screen getCurrentScreen() {
         return mAdapter.peek(getCurrentNavigatorId());
     }
 

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.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.StyleHelper;
 import com.reactnativenavigation.views.RnnToolBar;
 import com.reactnativenavigation.views.ScreenStack;
     private int mCurrentPage = 0;
 
     public ViewPagerAdapter(BaseReactActivity context, ViewPager viewPager, RnnToolBar toolbar,
-                            ArrayList<Screen> screens) {
+                            ArrayList<_Screen> screens) {
         mViewPager = viewPager;
         mToolbar = toolbar;
         mScreenStacks = new ArrayList<>();
         mNavigatorIds = new ArrayList<>();
         mStackByNavigatorId = new HashMap<>();
-        for (Screen screen : screens) {
+        for (_Screen screen : screens) {
             ScreenStack stack = new ScreenStack(context);
             stack.push(screen);
             mScreenStacks.add(stack);
         }
     }
 
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         ScreenStack stack = mStackByNavigatorId.get(screen.navigatorId);
-        Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
+        _Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
         mToolbar.setupToolbarButtonsAsync(prevScreen, screen);
         stack.push(screen);
     }
 
-    public Screen pop(String navigatorId) {
+    public _Screen pop(String navigatorId) {
         ScreenStack stack = mStackByNavigatorId.get(navigatorId);
-        Screen oldScreen =  stack != null ? stack.pop() : null;
-        Screen newScreen = stack.peek();
+        _Screen oldScreen = stack != null ? stack.pop() : null;
+        _Screen newScreen = stack.peek();
         mToolbar.setupToolbarButtonsAsync(oldScreen, newScreen);
         return oldScreen;
     }
 
-    public Screen peek(String navigatorId) {
+    public _Screen peek(String navigatorId) {
         ScreenStack stack = mStackByNavigatorId.get(navigatorId);
         return stack != null ? stack.peek() : null;
     }
         mViewPager.setCurrentItem(position);
 
         // Set screen buttons
-        Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
-        Screen newScreen = mScreenStacks.get(position).peek();
+        _Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
+        _Screen newScreen = mScreenStacks.get(position).peek();
         mToolbar.setupToolbarButtonsAsync(prevScreen, newScreen);
 
         // Set title
 
         // Send tab selected event
         WritableMap params = Arguments.createMap();
-        Screen screen = mScreenStacks.get(position).peek();
+        _Screen screen = mScreenStacks.get(position).peek();
         RctManager.getInstance().sendEvent(EVENT_ON_TAB_SELECTED, screen, params);
     }
 

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

 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 
 public class NavigationReactEventEmitter {
 
 
         params.putString(KEY_EVENT_TYPE, EVENT_TYPE);
         params.putString(KEY_EVENT_ID, eventName);
-        params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, navigatorEventId);
+        params.putString(_Screen.KEY_NAVIGATOR_EVENT_ID, navigatorEventId);
         eventEmitter.emit(navigatorEventId, params);
     }
 }

android/app/src/main/java/com/reactnativenavigation/core/Button.java

+package com.reactnativenavigation.core;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.ColorInt;
+import android.support.annotation.NonNull;
+import android.support.v7.widget.ActionMenuView;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.TextView;
+
+import com.reactnativenavigation.utils.ImageUtils;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import java.util.ArrayList;
+
+public class Button {
+    public static class Params {
+        public enum ShowAsAction {
+            IfRoom(MenuItem.SHOW_AS_ACTION_IF_ROOM),
+            Always(MenuItem.SHOW_AS_ACTION_ALWAYS),
+            Never(MenuItem.SHOW_AS_ACTION_NEVER),
+            WithText(MenuItem.SHOW_AS_ACTION_WITH_TEXT);
+
+            int action;
+            ShowAsAction(int action) {
+                this.action = action;
+            }
+        }
+
+        // Todo: add id for click listener
+        String label;
+        Drawable icon;
+        @ColorInt
+        int color;
+        ShowAsAction showAsAction;
+    }
+
+    private final Activity activity;
+    private final Menu menu;
+    private final ActionMenuView parent;
+    private Params buttonParams;
+
+    public Button(Activity activity, Menu menu, ActionMenuView parent, Params buttonParams) {
+        this.activity = activity;
+        this.menu = menu;
+        this.parent = parent;
+        this.buttonParams = buttonParams;
+    }
+
+    public MenuItem addToMenu(int index) {
+        MenuItem item = menu.add(Menu.NONE, Menu.NONE, index, buttonParams.label);
+        item.setShowAsAction(buttonParams.showAsAction.action);
+        setIcon(item);
+        setColor();
+        return item;
+    }
+
+    private void setIcon(MenuItem item) {
+        if (hasIcon()) {
+            item.setIcon(buttonParams.icon);
+        }
+    }
+
+    private void setColor() {
+        if (!hasColor()) {
+            return;
+        }
+
+        if (hasIcon()) {
+            setIconColor();
+        } else {
+            setTextColor();
+        }
+    }
+
+    private void setIconColor() {
+        ImageUtils.tint(buttonParams.icon, buttonParams.color);
+    }
+
+    private void setTextColor() {
+        ViewUtils.runOnPreDraw(parent, new Runnable() {
+            @Override
+            public void run() {
+                ArrayList<View> outViews = findActualTextViewInMenuByLabel();
+                setTextColorInternal(outViews);
+            }
+        });
+    }
+
+    @NonNull
+    private ArrayList<View> findActualTextViewInMenuByLabel() {
+        ArrayList<View> outViews = new ArrayList<>();
+        parent.findViewsWithText(outViews, buttonParams.label, View.FIND_VIEWS_WITH_CONTENT_DESCRIPTION);
+        return outViews;
+    }
+
+    private void setTextColorInternal(ArrayList<View> outViews) {
+        for (View button : outViews) {
+            ((TextView) button).setTextColor(buttonParams.color);
+        }
+    }
+
+    private boolean hasIcon() {
+        return buttonParams.icon != null;
+    }
+
+    private boolean hasColor() {
+        return buttonParams.color > 0;
+    }
+
+}

android/app/src/main/java/com/reactnativenavigation/core/objects/Drawer.java

     private static final String KEY_RIGHT = "right";
     private static final String KEY_DISABLE_OPEN_GESTURE = "disableOpenGesture";
 
-    public final Screen left;
-    public final Screen right;
+    public final _Screen left;
+    public final _Screen right;
     public final boolean disableOpenGesture;
 
     public Drawer(ReadableMap params) {
-        left = params.hasKey(KEY_LEFT) ? new Screen(params.getMap(KEY_LEFT)) : null;
-        right = params.hasKey(KEY_RIGHT) ? new Screen(params.getMap(KEY_RIGHT)) : null;
+        left = params.hasKey(KEY_LEFT) ? new _Screen(params.getMap(KEY_LEFT)) : null;
+        right = params.hasKey(KEY_RIGHT) ? new _Screen(params.getMap(KEY_RIGHT)) : null;
         disableOpenGesture = getBoolean(params, KEY_DISABLE_OPEN_GESTURE);
     }
 }

android/app/src/main/java/com/reactnativenavigation/core/objects/Button.java → android/app/src/main/java/com/reactnativenavigation/core/objects/_Button.java

 /**
  * Created by guyc on 08/04/16.
  */
-public class Button extends JsonObject implements Serializable {
+public class _Button extends JsonObject implements Serializable {
     private static final long serialVersionUID = -570145217281069067L;
 
     private static final String KEY_ID = "id";
     private static final AtomicInteger sAtomicIdGenerator = new AtomicInteger();
     private static final Map<String, Integer> sStringToNumericId = new HashMap<>();
 
-    public Button(ReadableMap button) {
+    public _Button(ReadableMap button) {
         id = getString(button, KEY_ID);
         title = getString(button, KEY_TITLE, "");
         mIconSource = getString(button, KEY_ICON);

android/app/src/main/java/com/reactnativenavigation/core/objects/Screen.java → android/app/src/main/java/com/reactnativenavigation/core/objects/_Screen.java

 /**
  * Created by guyc on 02/04/16.
  */
-public class Screen extends JsonObject implements Serializable {
+public class _Screen extends JsonObject implements Serializable {
     private static final long serialVersionUID = -1033475305421107791L;
 
     private static final String KEY_TITLE = "title";
     public final String navigatorId;
     public final String navigatorEventId;
     public final String icon;
-    public ArrayList<Button> buttons;
+    public ArrayList<_Button> buttons;
     public final boolean backButtonHidden;
     public boolean bottomTabsHiddenOnScroll;
     public HashMap<String, Object> passedProps = new HashMap<>();
     public Boolean bottomTabsHidden;
 
     @NonNull
-    public List<Button> getButtons() {
-        return buttons == null ? Collections.<Button>emptyList() : buttons;
+    public List<_Button> getButtons() {
+        return buttons == null ? Collections.<_Button>emptyList() : buttons;
     }
 
-    public Screen(ReadableMap screen) {
+    public _Screen(ReadableMap screen) {
         title = getString(screen, KEY_TITLE);
         label = getString(screen, KEY_LABEL);
         screenId = getString(screen, KEY_SCREEN);
         this.buttons = getButtons(params);
     }
 
-    private ArrayList<Button> getButtons(ReadableMap screen) {
-        ArrayList<Button> ret = new ArrayList<>();
+    private ArrayList<_Button> getButtons(ReadableMap screen) {
+        ArrayList<_Button> ret = new ArrayList<>();
         if (hasButtons(screen)) {
             ReadableArray rightButtons = getRightButtons(screen);
             for (int i = 0; i < rightButtons.size(); i++) {
-                ret.add(new Button(rightButtons.getMap(i)));
+                ret.add(new _Button(rightButtons.getMap(i)));
             }
         }
         return ret;

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

 import android.widget.FrameLayout;
 
 import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.views.RctView;
 import com.reactnativenavigation.views.RnnToolBar;
 import com.reactnativenavigation.views.ScreenStack;
     private RnnToolBar toolBar;
     private ScreenStack screenStack;
 
-    public BaseLayout(Context context, Screen initialScreen) {
+    public BaseLayout(Context context, _Screen initialScreen) {
         super(context);
         toolBar = (RnnToolBar) findViewById(R.id.toolbar);
         screenStack = (ScreenStack) findViewById(R.id.screenStack);
         addInitialScreen(initialScreen);
     }
 
-    private void addInitialScreen(Screen screen) {
+    private void addInitialScreen(_Screen screen) {
         screenStack.push(screen, new RctView.OnDisplayedListener() {
             @Override
             public void onDisplayed() {
     }
 
     @Override
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         screenStack.push(screen);
     }
 
     @Override
-    public Screen pop() {
-        Screen popped = screenStack.pop();
+    public _Screen pop() {
+        _Screen popped = screenStack.pop();
         if (onScreenPoppedListener != null) {
             onScreenPoppedListener.onScreenPopped(popped);
         }

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

 package com.reactnativenavigation.layouts;
 
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 
 public interface Layout {
     boolean onBackPressed();
 
     void removeAllReactViews();
 
-    void push(Screen screen);
+    void push(_Screen screen);
 
-    Screen pop();
+    _Screen pop();
 
     int getScreenCount();
 }

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

 package com.reactnativenavigation.layouts;
 
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 
 public interface OnScreenPoppedListener {
 
-    void onScreenPopped(Screen popped);
+    void onScreenPopped(_Screen popped);
 }

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

 import android.widget.LinearLayout;
 
 import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.core.Button;
 import com.reactnativenavigation.views.ContentView;
 import com.reactnativenavigation.views.ScrollDirectionListener;
+import com.reactnativenavigation.views.TitleBar;
+
+import java.util.List;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 
 public class ScreenLayout extends LinearLayout implements ScrollDirectionListener.OnScrollChanged {
 
+    public static class Params {
+        String moduleName;
+        Bundle passProps;
+        List<Button> buttons;
+    }
+
     private final ReactInstanceManager reactInstanceManager;
     private final String moduleName;
     private final Bundle passProps;
+    private final List<Button> buttons;
     private ContentView contentView;
     private TopBar topBar;
 
-    public ScreenLayout(Context context, ReactInstanceManager reactInstanceManager, String moduleName, Bundle passProps) {
+    public ScreenLayout(Context context, ReactInstanceManager reactInstanceManager, Params screenParams) {
         super(context);
         this.reactInstanceManager = reactInstanceManager;
-        this.moduleName = moduleName;
-        this.passProps = passProps;
+        moduleName = screenParams.moduleName;
+        passProps = screenParams.passProps;
+        buttons = screenParams.buttons;
         setOrientation(VERTICAL);
 
         createViews();
 
     private void createViews() {
         addTopBar();
+        addTitleBarAndSetButtons();
         addContentView();
     }
 
+    private void addTitleBarAndSetButtons() {
+        TitleBar titleBar = new TitleBar(getContext());
+        titleBar.setButtons(buttons);
+        topBar.addView(titleBar);
+    }
+
     private void addTopBar() {
         topBar = new TopBar(getContext());
         addView(topBar, new LinearLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT));

android/app/src/main/java/com/reactnativenavigation/modal/RnnModal.java

 import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.Window;
-import android.view.WindowManager;
 
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.activities.BaseReactActivity;
 import com.reactnativenavigation.controllers.ModalController;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.layouts.Layout;
 import com.reactnativenavigation.layouts.OnScreenPoppedListener;
 import com.reactnativenavigation.utils.ContextProvider;
-import com.reactnativenavigation.utils.SdkSupports;
 import com.reactnativenavigation.utils.StyleHelper;
 
 public class RnnModal extends Dialog implements DialogInterface.OnDismissListener, OnScreenPoppedListener {
 
     private Layout contentView;
 
-    public RnnModal(Context context, ModalController modalController, Screen screen) {
+    public RnnModal(Context context, ModalController modalController, _Screen screen) {
         super(context, R.style.Modal);
         modalController.add(this);
         init(context, screen);
     }
 
     @SuppressLint("InflateParams")
-    private void init(final Context context, Screen screen) {
+    private void init(final Context context, _Screen screen) {
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         contentView = null;
         setContentView((View) contentView);
         setOnDismissListener(this);
     }
 
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         contentView.push(screen);
     }
 
-    public Screen pop() {
+    public _Screen pop() {
         return contentView.pop();
     }
 
     @Override
-    public void onScreenPopped(Screen popped) {
+    public void onScreenPopped(_Screen popped) {
         if (contentView.getScreenCount() == 0) {
             dismiss();
         }
     }
 
     @Nullable
-    public Screen getCurrentScreen() {
+    public _Screen getCurrentScreen() {
         return mScreenStack.isEmpty() ? null : mScreenStack.peek();
     }
 
         // After modal is dismissed, update Toolbar with screen from parent activity or previously displayed modal
         BaseReactActivity context = ContextProvider.getActivityContext();
         if (context != null) {
-            Screen currentScreen = context.getCurrentScreen();
+            _Screen currentScreen = context.getCurrentScreen();
             StyleHelper.updateStyles(mToolBar, currentScreen);
         }
     }

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

 package com.reactnativenavigation.utils;
 
-import android.content.Context;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
 
-/**
- * Created by guyc on 23/04/16.
- */
+import com.reactnativenavigation.NavigationApplication;
+
 public class ImageUtils {
 
     public static void tint(Drawable drawable, int tint) {
         drawable.setColorFilter(new PorterDuffColorFilter(tint, PorterDuff.Mode.SRC_IN));
     }
 
-    /**
-     * This method converts dp unit to equivalent pixels, depending on device density.
-     *
-     * @param dp      A value in dp (density independent pixels) unit. Which we need to convert into pixels
-     * @param context Context to get resources and device specific display metrics
-     * @return A float value to represent px equivalent to dp depending on device density
-     */
-    public static float convertDpToPixel(float dp, Context context) {
-        float scale = context.getResources().getDisplayMetrics().density;
+    public static float convertDpToPixel(float dp) {
+        float scale = NavigationApplication.instance.getResources().getDisplayMetrics().density;
         return dp * scale + 0.5f;
     }
 }

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

 import android.view.Window;
 
 import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.views.RnnToolBar;
 
 /**
  */
 public class StyleHelper {
 
-    public static void updateStyles(RnnToolBar toolBar, Screen screen) {
+    public static void updateStyles(RnnToolBar toolBar, _Screen screen) {
         try {
             toolBar.updateAndSetButtons(screen);
             setWindowStyle(screen);
         }
     }
 
-    private static void setWindowStyle(Screen screen) {
+    private static void setWindowStyle(_Screen screen) {
         BaseReactActivity context = ContextProvider.getActivityContext();
         if (context != null) {
             StyleHelper.setWindowStyle(context.getWindow(), context, screen);
         }
     }
 
-    public static void setWindowStyle(Window window, Context context, Screen screen) {
+    public static void setWindowStyle(Window window, Context context, _Screen screen) {
         if (SdkSupports.lollipop()) {
             final int black = ContextCompat.getColor(context, android.R.color.black);
             if (screen.statusBarColor != null) {

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

-package com.reactnativenavigation.views;
-
-import android.app.Activity;
-import android.graphics.drawable.Drawable;
-import android.support.annotation.ColorInt;
-import android.support.annotation.NonNull;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.ViewTreeObserver;
-import android.widget.TextView;
-
-import com.reactnativenavigation.utils.ImageUtils;
-
-import java.util.ArrayList;
-
-public class Button {
-    public enum ShowAsAction {
-        IfRoom(MenuItem.SHOW_AS_ACTION_IF_ROOM),
-        Always(MenuItem.SHOW_AS_ACTION_ALWAYS),
-        Never(MenuItem.SHOW_AS_ACTION_NEVER),
-        WithText(MenuItem.SHOW_AS_ACTION_WITH_TEXT);
-
-        int action;
-        ShowAsAction(int action) {
-            this.action = action;
-        }
-    }
-
-    String label;
-    Drawable icon;
-    @ColorInt
-    int color;
-    ShowAsAction showAsAction;
-
-    public MenuItem addToMenu(Activity context, Menu menu, int index) {
-        MenuItem item = menu.add(Menu.NONE, Menu.NONE, index, label);
-        setShowAsAction(item);
-        setIcon(item);
-        setColor(context, item);
-        return item;
-    }
-
-    private void setShowAsAction(MenuItem item) {
-        item.setShowAsAction(showAsAction.action);
-    }
-
-    private void setIcon(MenuItem item) {
-        if (icon != null) {
-            item.setIcon(icon);
-        }
-    }
-
-    private void setColor(Activity context, MenuItem item) {
-        if (!hasColor()) {
-            return;
-        }
-
-        if (hasIcon()) {
-            setIconColor();
-        } else {
-            setTextColor(context);
-        }
-    }
-
-    private void setTextColor(Activity context) {
-        final View decorView = context.getWindow().getDecorView();
-        decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
-            @Override
-            public void onGlobalLayout() {
-                decorView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
-
-                ArrayList<View> outViews = findButtonTextView();
-                setTextColorInternal(outViews);
-            }
-
-            @NonNull
-            private ArrayList<View> findButtonTextView() {
-                ArrayList<View> outViews = new ArrayList<>();
-                decorView.findViewsWithText(outViews, label, View.FIND_VIEWS_WITH_CONTENT_DESCRIPTION);
-                return outViews;
-            }
-
-            private void setTextColorInternal(ArrayList<View> outViews) {
-                for (View button : outViews) {
-                    ((TextView) button).setTextColor(color);
-                }
-            }
-        });
-    }
-
-    private void setIconColor() {
-        ImageUtils.tint(icon, color);
-    }
-
-    private boolean hasIcon() {
-        return icon != null;
-    }
-
-    private boolean hasColor() {
-        return color > 0;
-    }
-
-}

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

 import com.facebook.react.ReactRootView;
 import com.reactnativenavigation.activities.BaseReactActivity;
 import com.reactnativenavigation.activities.BottomTabActivity;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.BridgeUtils;
-import com.reactnativenavigation.utils.ReflectionUtils;
 
 /**
  * Created by guyc on 10/03/16.
     }
 
     @SuppressWarnings("unchecked")
-    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, final Screen screen,
+    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, final _Screen screen,
                    final OnDisplayedListener onDisplayedListener) {
         super(ctx);
         setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
         addView(reactRootView);
     }
 
-    private Bundle createPassProps(Screen screen) {
+    private Bundle createPassProps(_Screen screen) {
         Bundle passProps = new Bundle();
-        passProps.putString(Screen.KEY_SCREEN_INSTANCE_ID, screen.screenInstanceId);
-        passProps.putString(Screen.KEY_NAVIGATOR_ID, screen.navigatorId);
-        passProps.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
+        passProps.putString(_Screen.KEY_SCREEN_INSTANCE_ID, screen.screenInstanceId);
+        passProps.putString(_Screen.KEY_NAVIGATOR_ID, screen.navigatorId);
+        passProps.putString(_Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
         if (screen.passedProps != null) {
             BridgeUtils.addMapToBundle(screen.passedProps, passProps);
         }

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

 import android.util.TypedValue;
 
 import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 
 /**
  * Created by guyc on 07/05/16.
         a.recycle();
     }
 
-    public void setStyle(Screen screen) {
+    public void setStyle(_Screen screen) {
         if (screen.toolBarColor != null) {
             setBackgroundColor(screen.toolBarColor);
         } else {

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

 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.graphics.drawable.DrawerArrowDrawable;
 import android.support.v7.widget.Toolbar;
-import android.util.AttributeSet;
 import android.view.Gravity;
 import android.view.Menu;
 import android.view.MenuItem;
 
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Button;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Button;
+import com.reactnativenavigation.core.objects._Screen;
 import com.reactnativenavigation.utils.ContextProvider;
 import com.reactnativenavigation.react.ImageLoader;
 import com.reactnativenavigation.utils.ImageUtils;
  */
 public class RnnToolBar extends Toolbar {
 
-    private List<Screen> mScreens;
+    private List<_Screen> mScreens;
     private AsyncTask mDrawerIconTask;
     private AsyncTask mSetupToolbarTask;
     private Drawable mBackground;
         mBackground = getBackground();
     }
 
-    public void setScreens(List<Screen> screens) {
+    public void setScreens(List<_Screen> screens) {
         mScreens = screens;
     }
 
 //        }
     }
 
-    public ActionBarDrawerToggle setupDrawer(DrawerLayout drawerLayout, Screen drawerScreen, Screen screen) {
+    public ActionBarDrawerToggle setupDrawer(DrawerLayout drawerLayout, _Screen drawerScreen, _Screen screen) {
         if (drawerLayout == null || drawerScreen == null) {
             return null;
         }
         }
     }
 
-    public void setupDrawerIconAsync(String drawerIconSource, Screen screen) {
+    public void setupDrawerIconAsync(String drawerIconSource, _Screen screen) {
         if (mDrawerIconTask == null) {
             mDrawerIconTask = new SetupDrawerIconTask(this, drawerIconSource, screen).execute();
         }
     }
 
-    public void setupToolbarButtonsAsync(Screen newScreen) {
+    public void setupToolbarButtonsAsync(_Screen newScreen) {
         if (newScreen != null) {
             this.setupToolbarButtonsAsync(null, newScreen);
         }
     }
 
 
-    public void setupToolbarButtonsAsync(Screen oldScreen, Screen newScreen) {
+    public void setupToolbarButtonsAsync(_Screen oldScreen, _Screen newScreen) {
         if (mSetupToolbarTask == null) {
             mSetupToolbarTask = new SetupToolbarButtonsTask(this, oldScreen, newScreen).execute();
         }
     }
 
     @SuppressWarnings({"ConstantConditions"})
-    public void setNavUpButton(Screen screen) {
+    public void setNavUpButton(_Screen screen) {
         BaseReactActivity context = ContextProvider.getActivityContext();
         if (context == null) {
             return;
      * @param screen The currently displayed screen
      */
     @UiThread
-    public void update(@NonNull Screen screen) {
+    public void update(@NonNull _Screen screen) {
         ((AppCompatActivity) getContext()).setSupportActionBar(this);
         setTitle(screen.title);
         setStyle(screen);
     }
 
-    public void updateAndSetButtons(Screen screen) {
+    public void updateAndSetButtons(_Screen screen) {
         update(screen);
         setupToolbarButtonsAsync(screen);
     }
         private final String mDrawerIconSource;
         private final Integer mTintColor;
 
-        public SetupDrawerIconTask(RnnToolBar toolBar, String drawerIconSource, Screen screen) {
+        public SetupDrawerIconTask(RnnToolBar toolBar, String drawerIconSource, _Screen screen) {
             mToolbarWR = new WeakReference<>(toolBar);
             mDrawerIconSource = drawerIconSource;
             mTintColor = screen.navBarButtonColor;
     }
 
     private static class SetupToolbarButtonsTask extends AsyncTask<Void, Void, Map<String, Drawable>> {
-        private final List<Button> mOldButtons;
-        private final List<Button> mNewButtons;
+        private final List<_Button> mOldButtons;
+        private final List<_Button> mNewButtons;
         private final WeakReference<RnnToolBar> mToolbarWR;
         @ColorInt private final Integer mTintColor;
         private final int mIconDimensions;
 
-        public SetupToolbarButtonsTask(RnnToolBar toolBar, Screen oldScreen, Screen newScreen) {
+        public SetupToolbarButtonsTask(RnnToolBar toolBar, _Screen oldScreen, _Screen newScreen) {
             mToolbarWR = new WeakReference<>(toolBar);
             mOldButtons = oldScreen == null ? null : oldScreen.getButtons();
             mNewButtons = newScreen.getButtons();
             }
 
             Map<String, Drawable> icons = new HashMap<>();
-            for (Button button : mNewButtons) {
+            for (_Button button : mNewButtons) {
                 if (button.hasIcon()) {
                     icons.put(button.id, button.getIcon(context, mIconDimensions));
                 }
             if(mOldButtons == null) {
                 menu.clear();
             } else {
-                for (Button btn : mOldButtons) {
+                for (_Button btn : mOldButtons) {
                     menu.removeItem(btn.getItemId());
                 }
             }
             final List<String> textButtons = new ArrayList<>();
             final int size = mNewButtons.size();
             for (int i = 0; i < size; i++) {
-                Button button = mNewButtons.get(i);
+                _Button button = mNewButtons.get(i);
                 MenuItem item = menu.add(Menu.NONE, button.getItemId(), size - i - 1, button.title);
                 item.setShowAsAction(getMenuItemShowAction(button.showAsAction));
 

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

 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.core.objects._Screen;
 
 import java.util.Stack;
 
     private static final int DISAPPEAR_ANIMATION_DELAY = 200;
 
     private static class ScreenView {
-        Screen screen;
+        _Screen screen;
         RctView view;
 
-        public ScreenView(Screen screen, RctView view) {
+        public ScreenView(_Screen screen, RctView view) {
             this.screen = screen;
             this.view = view;
         }
         setLayoutTransition(new LayoutTransition());
     }
 
-    public void push(Screen screen) {
+    public void push(_Screen screen) {
         push(screen, null);
     }
 
-    public void push(Screen screen, RctView.OnDisplayedListener onDisplayed) {
+    public void push(_Screen screen, RctView.OnDisplayedListener onDisplayed) {
         RctView oldView = mStack.isEmpty() ? null : mStack.peek().view;
         RctView view = new RctView(mReactActivity, mReactInstanceManager, screen, onDisplayed);
         if (oldView != null) {
         mStack.push(new ScreenView(screen, view));
     }
 
-    public Screen pop() {
+    public _Screen pop() {
         if (mStack.isEmpty() || getStackSize() == 1) {
             return null;
         }
         return popped.screen;
     }
 
-    public Screen popToRoot() {
+    public _Screen popToRoot() {
         if (mStack.isEmpty() || getStackSize() <= 1) {
             return null;
         }
         return oldScreenView != null ? oldScreenView.screen : null;
     }
 
-    public Screen resetTo(Screen screen) {
+    public _Screen resetTo(_Screen screen) {
         return resetTo(screen, null);
     }
 
-    public Screen resetTo(Screen screen, RctView.OnDisplayedListener onDisplayed) {
+    public _Screen resetTo(_Screen screen, RctView.OnDisplayedListener onDisplayed) {
         RctView view = new RctView(mReactActivity, mReactInstanceManager, screen, onDisplayed);
         addView(view, MATCH_PARENT, MATCH_PARENT);
 
         return mStack.size();
     }
 
-    public Screen peek() {
+    public _Screen peek() {
         return mStack.peek().screen;
     }
 

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

 package com.reactnativenavigation.views;
 
 import android.app.Activity;
+import android.content.Context;
 import android.support.v7.widget.ActionMenuView;
 import android.support.v7.widget.Toolbar;
 import android.view.Menu;
 import android.view.MenuInflater;
 
 import com.reactnativenavigation.R;
+import com.reactnativenavigation.core.Button;
 
 import java.util.List;
 
     private Menu menu;
     private ActionMenuView actionMenuView;
 
-
-
-    public TitleBar(Activity context) {
+    public TitleBar(Context context) {
         super(context);
         createMenu();
     }
         // TODO: Maybe setSupportActionBar
     }
 
-    public void setButtons(List<Button> buttons) {
-        removeView(actionMenuView);
-        createMenu();
+    public void setButtons(List<Button.Params> buttons) {
+        menu.clear();
 
         Activity context = (Activity) getContext();
         for (int i = 0; i < buttons.size(); i++) {
-            final Button button = buttons.get(i);
+            final Button button = new Button(context, buttons.get(i));
+            // Add button in reverse order because in iOS, index 0 starts at right
             final int index = buttons.size() - i - 1;
             button.addToMenu(context, menu, index);
         }