Initial back button implementation

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

 import android.os.Bundle;
 import android.os.Handler;
 import android.provider.Settings;
+import android.support.annotation.CallSuper;
 import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.view.KeyEvent;
 import com.reactnativenavigation.core.objects.Screen;
 import com.reactnativenavigation.packages.RnnPackage;
 import com.reactnativenavigation.utils.ContextProvider;
+import com.reactnativenavigation.views.RnnToolBar;
 
 import java.util.Arrays;
 import java.util.List;
     private LifecycleState mLifecycleState = LifecycleState.BEFORE_RESUME;
     private boolean mDoRefresh = false;
     private Menu mMenu;
+    protected RnnToolBar mToolbar;
 
     /**
      * Returns the name of the bundle in assets. If this is null, and no file path is specified for
         }
     }
 
-    public abstract void push(Screen screen);
+    @CallSuper
+    public void push(Screen screen) {
+        if (mToolbar != null &&
+            getCurrentNavigatorId().equals(screen.navigatorId) &&
+            getScreenStackSize() >= 1) {
+            mToolbar.showBackButton();
+        }
+    }
 
-    public abstract Screen pop(String navID);
+    @CallSuper
+    public Screen pop(String navigatorId) {
+        if (mToolbar != null &&
+            getCurrentNavigatorId().equals(navigatorId) &&
+            getScreenStackSize() <= 2) {
+            mToolbar.hideBackButton();
+        }
+        return null;
+    }
 
-    public abstract String getActiveNavigatorID();
+    public abstract String getCurrentNavigatorId();
 
     public abstract int getScreenStackSize();
 
     @Override
     public void onBackPressed() {
         if (getScreenStackSize() > 1) {
-            pop(getActiveNavigatorID());
+            pop(getCurrentNavigatorId());
         } else {
             if (mReactInstanceManager != null) {
                 mReactInstanceManager.onBackPressed();

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

     }
 
     @Override
-    public Screen pop(String navID) {
+    public Screen pop(String navigatorId) {
         return null;
     }
 
     @Override
-    public String getActiveNavigatorID() {
+    public String getCurrentNavigatorId() {
         return null;
     }
 

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

     public static final String EXTRA_SCREEN = "extraScreen";
 
     private Toolbar mToolbar;
-    private FrameLayout mContentFrame;
-    private ScreenStack screenStack;
-    private String navID;
+    private ScreenStack mScreenStack;
+    private String mNavigatorId;
 
     @Override
     protected void handleOnCreate() {
 
         setContentView(R.layout.single_screen_activity);
         mToolbar = (Toolbar) findViewById(R.id.toolbar);
-        mContentFrame = (FrameLayout) findViewById(R.id.contentFrame);
 
         Screen screen = (Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
-        navID = screen.navigatorId;
+        mNavigatorId = screen.navigatorId;
         setupToolbar(screen.title);
 
-        screenStack = new ScreenStack(this);
-        mContentFrame.addView(screenStack);
-        screenStack.push(screen);
+        mScreenStack = new ScreenStack(this);
+        FrameLayout contentFrame = (FrameLayout) findViewById(R.id.contentFrame);
+        contentFrame.addView(mScreenStack);
+        mScreenStack.push(screen);
     }
 
     private void setupToolbar(String title) {
         mToolbar.setTitle(title);
+        setSupportActionBar(mToolbar);
     }
     
     @Override
     public void push(Screen screen) {
-        screenStack.push(screen);
+        super.push(screen);
+        mScreenStack.push(screen);
     }
 
     @Override
-    public Screen pop(String navID) {
-        return screenStack.pop();
+    public Screen pop(String navigatorId) {
+        super.pop(navigatorId);
+        return mScreenStack.pop();
     }
 
     @Override
-    public String getActiveNavigatorID() {
-        return navID;
+    public String getCurrentNavigatorId() {
+        return mNavigatorId;
     }
 
     @Override
     public int getScreenStackSize() {
-        return screenStack.getStackSize();
+        return mScreenStack.getStackSize();
     }
 }

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

 public class TabActivity extends BaseReactActivity {
     public static final String EXTRA_SCREENS = "extraScreens";
 
-    private RnnToolBar mToolbar;
     private TabLayout mTabLayout;
     private ViewPager mViewPager;
 
     private ArrayList<Screen> mScreens;
-    private ViewPagerAdapter adapter;
+    private ViewPagerAdapter mAdapter;
 
     @Override
     protected void handleOnCreate() {
         setupViewPager();
     }
 
-    @Override
-    public void push(Screen screen) {
-        adapter.pushScreen(screen);
-    }
-
-    @Override
-    public Screen pop(String navID) {
-        return adapter.pop(navID);
-    }
-
     private void setupToolbar() {
         setSupportActionBar(mToolbar);
         mToolbar.setScreens(mScreens);
     }
 
     private void setupViewPager() {
-        adapter = new ViewPagerAdapter(this, mViewPager, mToolbar, mScreens);
-        mViewPager.setAdapter(adapter);
+        mAdapter = new ViewPagerAdapter(this, mViewPager, mToolbar, mScreens);
+        mViewPager.setAdapter(mAdapter);
         mTabLayout.setupWithViewPager(mViewPager);
-        mTabLayout.setOnTabSelectedListener(adapter);
-        adapter.notifyDataSetChanged();
+        mTabLayout.setOnTabSelectedListener(mAdapter);
+        mAdapter.notifyDataSetChanged();
     }
 
     @Override
     }
 
     @Override
-    public String getActiveNavigatorID() {
-        return adapter.getNavID(mViewPager.getCurrentItem());
+    public void push(Screen screen) {
+        super.push(screen);
+        mAdapter.push(screen);
+    }
+
+    @Override
+    public Screen pop(String navigatorId) {
+        super.pop(navigatorId);
+        return mAdapter.pop(navigatorId);
+    }
+
+    @Override
+    public String getCurrentNavigatorId() {
+        return mAdapter.getNavigatorId(mViewPager.getCurrentItem());
     }
 
     @Override
     public int getScreenStackSize() {
-        return adapter.getStackSizeForNavigatorId(getActiveNavigatorID());
+        return mAdapter.getStackSizeForNavigatorId(getCurrentNavigatorId());
     }
 }

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

 
     private ViewPager mViewPager;
     private RnnToolBar mToolbar;
-    private final ArrayList<ScreenStack> screenStacks;
-    private final ArrayList<String> navIDs;
-    private final Map<String, ScreenStack> stacksByNavId;
+    private final ArrayList<ScreenStack> mScreenStacks;
+    private final ArrayList<String> mNavigatorIds;
+    private final Map<String, ScreenStack> mStackByNavigatorId;
 
 
     public ViewPagerAdapter(BaseReactActivity context, ViewPager viewPager, RnnToolBar toolbar,
                             ArrayList<Screen> screens) {
         mViewPager = viewPager;
         mToolbar = toolbar;
-        screenStacks = new ArrayList<>();
-        navIDs = new ArrayList<>();
-        stacksByNavId = new HashMap<>();
+        mScreenStacks = new ArrayList<>();
+        mNavigatorIds = new ArrayList<>();
+        mStackByNavigatorId = new HashMap<>();
         for (Screen screen : screens) {
             ScreenStack stack = new ScreenStack(context);
             stack.push(screen);
-            screenStacks.add(stack);
-            navIDs.add(screen.navigatorId);
-            stacksByNavId.put(screen.navigatorId, stack);
+            mScreenStacks.add(stack);
+            mNavigatorIds.add(screen.navigatorId);
+            mStackByNavigatorId.put(screen.navigatorId, stack);
         }
     }
 
-    public void pushScreen(Screen screen) {
-        ScreenStack stack = stacksByNavId.get(screen.navigatorId);
+    public void push(Screen screen) {
+        ScreenStack stack = mStackByNavigatorId.get(screen.navigatorId);
         stack.push(screen);
     }
 
-    public Screen pop(String navID) {
-        ScreenStack stack = stacksByNavId.get(navID);
-        if (stack != null) {
-            return stack.pop();
-        }
-        return null;
+    public Screen pop(String navigatorId) {
+        ScreenStack stack = mStackByNavigatorId.get(navigatorId);
+        return stack != null ? stack.pop() : null;
     }
 
     @Override
     public Object instantiateItem(ViewGroup container, int position) {
-        ScreenStack view = screenStacks.get(position);
+        ScreenStack view = mScreenStacks.get(position);
         container.addView(view);
         return view;
     }
 
     @Override
     public int getCount() {
-        return screenStacks.size();
+        return mScreenStacks.size();
     }
 
     @Override
 
     @Override
     public CharSequence getPageTitle(int position) {
-        return screenStacks.get(position).peek().title;
+        return mScreenStacks.get(position).peek().title;
     }
 
     @Override
         int position = tab.getPosition();
         mViewPager.setCurrentItem(position);
 
+        mToolbar.setupToolbarButtonsAsync(mScreenStacks.get(position).peek());
+
         // Send tab selected event
         WritableMap params = Arguments.createMap();
-        Screen screen = screenStacks.get(position).peek();
+        Screen screen = mScreenStacks.get(position).peek();
         params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
-
-        mToolbar.setupToolbarButtonsAsync(screenStacks.get(position).peek());
-
         RctManager.getInstance().sendEvent(EVENT_ON_TAB_SELECTED, screen.navigatorEventId, params);
     }
 
 
     }
 
-    public String getNavID(int position) {
-        return navIDs.get(position);
+    public String getNavigatorId(int position) {
+        return mNavigatorIds.get(position);
     }
 
     public int getStackSizeForNavigatorId(String activeNavigatorID) {
-        return stacksByNavId.get(activeNavigatorID).getStackSize();
+        return mStackByNavigatorId.get(activeNavigatorID).getStackSize();
     }
 }

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

         }
     }
 
+    @SuppressWarnings({"ConstantConditions"})
+    public void showBackButton() {
+        ContextProvider.getActivityContext().getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+    }
+
+    @SuppressWarnings({"ConstantConditions"})
+    public void hideBackButton() {
+        ContextProvider.getActivityContext().getSupportActionBar().setDisplayHomeAsUpEnabled(false);
+    }
+
     private static class SetupToolbarButtonsTask extends AsyncTask<Void, Void, Map<String, Drawable>> {
         private final List<Button> mButtons;
         private final WeakReference<RnnToolBar> mToolbarWR;

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

 
 public class ScreenStack extends FrameLayout {
 
-    private class ScreenView {
+    private static class ScreenView {
         Screen screen;
         RctView view;
 
         }
     }
 
-    private final Stack<ScreenView> stack = new Stack<>();
+    private final Stack<ScreenView> mStack = new Stack<>();
     private final ReactInstanceManager mReactInstanceManager =
             RctManager.getInstance().getReactInstanceManager();
-    private final BaseReactActivity reactActivity;
+    private final BaseReactActivity mReactActivity;
 
     public ScreenStack(BaseReactActivity context) {
         super(context);
-        reactActivity = context;
+        mReactActivity = context;
         setLayoutTransition(new LayoutTransition());
     }
 
     public void push(Screen screen) {
         RctView oldView = null;
-        if (!stack.isEmpty()) {
-            oldView = stack.peek().view;
+        if (!mStack.isEmpty()) {
+            oldView = mStack.peek().view;
         }
-        RctView view = new RctView(reactActivity, mReactInstanceManager, screen);
+        RctView view = new RctView(mReactActivity, mReactInstanceManager, screen);
         addView(view, MATCH_PARENT, MATCH_PARENT);
         if (oldView != null) {
             ReactRootView reactRootView = oldView.getReactRootView();
             ReflectionUtils.setBooleanField(reactRootView, "mAttachScheduled", true);
             removeView(oldView);
         }
-        stack.push(new ScreenView(screen, view));
+        mStack.push(new ScreenView(screen, view));
     }
 
     public Screen pop() {
-        if (stack.isEmpty()) {
+        if (mStack.isEmpty()) {
             return null;
         }
-        ScreenView popped = stack.pop();
-        if (!stack.isEmpty()) {
-            addView(stack.peek().view, 0);
+        ScreenView popped = mStack.pop();
+        if (!mStack.isEmpty()) {
+            addView(mStack.peek().view, 0);
         }
 
         ReflectionUtils.setBooleanField(popped.view.getReactRootView(), "mAttachScheduled", false);
     }
 
     public boolean isEmpty() {
-        return stack.isEmpty();
+        return mStack.isEmpty();
     }
 
     public int getStackSize() {
-        return stack.size();
+        return mStack.size();
     }
 
     public Screen peek() {
-        return stack.peek().screen;
+        return mStack.peek().screen;
     }
 }