Merge branch 'Android_implementation'

android/app/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    defaultPublishConfig 'release'
+    publishNonDefault true
+    productFlavors {
+        library {
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+        debug {
+            minifyEnabled false
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: "libs", include: ["*.jar"])
+    compile "com.android.support:appcompat-v7:23.0.1"
+    compile 'com.android.support:design:23.1.1'
+    compile "com.facebook.react:react-native:+"  // From node_modules
+}

android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.reactnativenavigation">
+
+    <application>
+        <activity android:name="com.reactnativenavigation.activities.TabActivity" />
+        <activity android:name="com.reactnativenavigation.activities.SingleScreenActivity" />
+    </application>
+
+</manifest>

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

@@ -0,0 +1,309 @@
+package com.reactnativenavigation.activities;
+
+import android.content.Intent;
+import android.os.Build;
+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 android.view.Menu;
+import android.view.MenuItem;
+import android.widget.EditText;
+import android.widget.Toast;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.reactnativenavigation.BuildConfig;
+import com.reactnativenavigation.core.RctManager;
+import com.reactnativenavigation.core.objects.Button;
+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;
+
+import javax.annotation.Nullable;
+
+/**
+ * Base Activity for React Native applications.
+ */
+public abstract class BaseReactActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler {
+
+    private static final String TAG = "BaseReactActivity";
+    private static final String REDBOX_PERMISSION_MESSAGE =
+            "Overlay permissions needs to be granted in order for react native apps to run in dev mode";
+
+    @Nullable
+    protected ReactInstanceManager mReactInstanceManager;
+    private boolean mDoRefresh = false;
+    private Menu mMenu;
+    protected RnnToolBar mToolbar;
+
+    /**
+     * Returns the name of the bundle in assets. If this is null, and no file path is specified for
+     * the bundle, the app will only work with {@code getUseDeveloperSupport} enabled and will
+     * always try to load the JS bundle from the packager server.
+     * e.g. "index.android.bundle"
+     */
+    @Nullable
+    public String getBundleAssetName() {
+        return "index.android.bundle";
+    }
+
+    /**
+     * Returns a custom path of the bundle file. This is used in cases the bundle should be loaded
+     * from a custom path. By default it is loaded from Android assets, from a path specified
+     * by {getBundleAssetName}.
+     * e.g. "file://sdcard/myapp_cache/index.android.bundle"
+     */
+    @Nullable
+    public String getJSBundleFile() {
+        return null;
+    }
+
+    /**
+     * Returns the name of the main module. Determines the URL used to fetch the JS bundle
+     * from the packager server. It is only used when dev support is enabled.
+     * This is the first file to be executed once the {@link ReactInstanceManager} is created.
+     * e.g. "index.android"
+     */
+    public String getJSMainModuleName() {
+        return "index.android";
+    }
+
+    /**
+     * Returns the launchOptions which will be passed to the {@link ReactInstanceManager}
+     * when the application is started. By default, this will return null and an empty
+     * object will be passed to your top level component as its initial props.
+     * If your React Native application requires props set outside of JS, override
+     * this method to return the Android.os.Bundle of your desired initial props.
+     */
+    @Nullable
+    protected Bundle getLaunchOptions() {
+        return null;
+    }
+
+    /**
+     * Returns the name of the main component registered from JavaScript.
+     * This is used to schedule rendering of the component.
+     * e.g. "MoviesApp"
+     */
+    protected String getMainComponentName() {
+        return "";
+    }
+
+    /**
+     * Returns whether dev mode should be enabled. This enables e.g. the dev menu.
+     */
+    public boolean getUseDeveloperSupport() {
+        return BuildConfig.DEBUG;
+    }
+
+    /**
+     * Returns a list of {@link ReactPackage} used by the app.
+     * You'll most likely want to return at least the {@code MainReactPackage}.
+     * If your app uses additional views or modules besides the default ones,
+     * you'll want to include more packages here.
+     */
+    public List<ReactPackage> getPackages() {
+        return Arrays.asList(
+                new MainReactPackage(),
+                new RnnPackage()
+        );
+    }
+
+    /**
+     * A subclass may override this method if it needs to use a custom {@link ReactRootView}.
+     */
+    protected ReactRootView createRootView() {
+        return new ReactRootView(this);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mReactInstanceManager = createReactInstanceManager();
+        handleOnCreate();
+    }
+
+    /**
+     * A subclass may override this method if it needs to use a custom instance.
+     */
+    protected ReactInstanceManager createReactInstanceManager() {
+        return getReactInstanceManager();
+    }
+
+    protected ReactInstanceManager getReactInstanceManager() {
+        RctManager rctManager = RctManager.getInstance();
+        if (!rctManager.isInitialized()) {
+            rctManager.init(this);
+        }
+        return rctManager.getReactInstanceManager();
+    }
+
+    protected void handleOnCreate() {
+        if (getUseDeveloperSupport() && Build.VERSION.SDK_INT >= 23) {
+            // Get permission to show redbox in dev builds.
+            if (!Settings.canDrawOverlays(this)) {
+                Intent serviceIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+                startActivity(serviceIntent);
+                FLog.w(ReactConstants.TAG, REDBOX_PERMISSION_MESSAGE);
+                Toast.makeText(this, REDBOX_PERMISSION_MESSAGE, Toast.LENGTH_LONG).show();
+            }
+        }
+
+        ReactRootView mReactRootView = createRootView();
+        mReactRootView.startReactApplication(mReactInstanceManager, getMainComponentName(), getLaunchOptions());
+        setContentView(mReactRootView);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        ContextProvider.setActivityContext(this);
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onResume(this, this);
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onPause();
+        }
+
+        ContextProvider.clearActivityContext();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+
+        // Destroy react instance manager only if there are no resumed react activities
+        BaseReactActivity activity = ContextProvider.getActivityContext();
+        if (mReactInstanceManager != null && (activity == null || activity.isFinishing())) {
+            Log.i(TAG, "Destroying ReactInstanceManager");
+            mReactInstanceManager.onDestroy();
+        } else {
+            Log.d(TAG, "Not destroying ReactInstanceManager");
+        }
+    }
+
+    @CallSuper
+    public void push(Screen screen) {
+        if (mToolbar != null &&
+            getCurrentNavigatorId().equals(screen.navigatorId) &&
+            getScreenStackSize() >= 1) {
+            mToolbar.showBackButton();
+        }
+    }
+
+    @CallSuper
+    public Screen pop(String navigatorId) {
+        if (mToolbar != null &&
+            getCurrentNavigatorId().equals(navigatorId) &&
+            getScreenStackSize() <= 2) {
+            mToolbar.hideBackButton();
+        }
+        return null;
+    }
+
+    protected abstract String getCurrentNavigatorId();
+
+    protected abstract Screen getCurrentScreen();
+
+    public abstract int getScreenStackSize();
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        mMenu = menu;
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            onBackPressed();
+        } else {
+            String eventId = Button.getButtonEventId(item);
+            assert eventId != null;
+
+            WritableMap params = Arguments.createMap();
+            RctManager.getInstance().sendEvent(eventId, getCurrentScreen(), params);
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    public Menu getMenu() {
+        return mMenu;
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (mReactInstanceManager != null &&
+            mReactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
+            if (keyCode == KeyEvent.KEYCODE_MENU) {
+                mReactInstanceManager.showDevOptionsDialog();
+                return true;
+            }
+            if (keyCode == KeyEvent.KEYCODE_R && !(getCurrentFocus() instanceof EditText)) {
+                // Enable double-tap-R-to-reload
+                if (mDoRefresh) {
+                    mReactInstanceManager.getDevSupportManager().handleReloadJS();
+                    mDoRefresh = false;
+                } else {
+                    mDoRefresh = true;
+                    new Handler().postDelayed(
+                            new Runnable() {
+                                @Override
+                                public void run() {
+                                    mDoRefresh = false;
+                                }
+                            },
+                            200);
+                }
+            }
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public void onBackPressed() {
+        if (getScreenStackSize() > 1) {
+            pop(getCurrentNavigatorId());
+        } else {
+            if (mReactInstanceManager != null) {
+                mReactInstanceManager.onBackPressed();
+            } else {
+                super.onBackPressed();
+            }
+        }
+    }
+
+    @Override
+    public void invokeDefaultOnBackPressed() {
+        super.onBackPressed();
+    }
+}

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

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

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

@@ -0,0 +1,70 @@
+package com.reactnativenavigation.activities;
+
+import android.support.v7.widget.Toolbar;
+import android.widget.FrameLayout;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.core.RctManager;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.views.ScreenStack;
+
+/**
+ * Created by guyc on 05/04/16.
+ */
+public class SingleScreenActivity extends BaseReactActivity {
+
+    public static final String EXTRA_SCREEN = "extraScreen";
+
+    private Toolbar mToolbar;
+    private ScreenStack mScreenStack;
+    private String mNavigatorId;
+
+    @Override
+    protected void handleOnCreate() {
+        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
+
+        setContentView(R.layout.single_screen_activity);
+        mToolbar = (Toolbar) findViewById(R.id.toolbar);
+
+        Screen screen = (Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
+        mNavigatorId = screen.navigatorId;
+        setupToolbar(screen.title);
+
+        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) {
+        super.push(screen);
+        mScreenStack.push(screen);
+    }
+
+    @Override
+    public Screen pop(String navigatorId) {
+        super.pop(navigatorId);
+        return mScreenStack.pop();
+    }
+
+    @Override
+    public String getCurrentNavigatorId() {
+        return mNavigatorId;
+    }
+
+    @Override
+    protected Screen getCurrentScreen() {
+        return mScreenStack.peek();
+    }
+
+    @Override
+    public int getScreenStackSize() {
+        return mScreenStack.getStackSize();
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.reactnativenavigation.activities;
+
+import android.support.design.widget.TabLayout;
+import android.support.v4.view.ViewPager;
+import android.view.Menu;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.adapters.ViewPagerAdapter;
+import com.reactnativenavigation.core.RctManager;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.views.RnnToolBar;
+
+import java.util.ArrayList;
+
+/**
+ * Created by guyc on 02/04/16.
+ */
+public class TabActivity extends BaseReactActivity {
+    public static final String EXTRA_SCREENS = "extraScreens";
+
+    private TabLayout mTabLayout;
+    private ViewPager mViewPager;
+    private ViewPagerAdapter mAdapter;
+
+    @Override
+    protected void handleOnCreate() {
+        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
+
+        setContentView(R.layout.tab_activity);
+        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
+        mTabLayout = (TabLayout) findViewById(R.id.tabLayout);
+        mViewPager = (ViewPager) findViewById(R.id.viewPager);
+
+        ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
+
+        setupToolbar(screens);
+        setupViewPager(screens);
+    }
+
+    private void setupToolbar(ArrayList<Screen> screens) {
+        setSupportActionBar(mToolbar);
+        mToolbar.setScreens(screens);
+    }
+
+    private void setupViewPager(ArrayList<Screen> screens) {
+        mAdapter = new ViewPagerAdapter(this, mViewPager, mToolbar, screens);
+        mViewPager.setAdapter(mAdapter);
+        mTabLayout.setupWithViewPager(mViewPager);
+        mTabLayout.setOnTabSelectedListener(mAdapter);
+        mAdapter.notifyDataSetChanged();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        boolean ret = super.onCreateOptionsMenu(menu);
+        mToolbar.handleOnCreateOptionsMenuAsync();
+        return ret;
+    }
+
+    @Override
+    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
+    protected Screen getCurrentScreen() {
+        return mAdapter.peek(getCurrentNavigatorId());
+    }
+
+    @Override
+    protected String getCurrentNavigatorId() {
+        return mAdapter.getNavigatorId(mViewPager.getCurrentItem());
+    }
+
+    @Override
+    public int getScreenStackSize() {
+        return mAdapter.getStackSizeForNavigatorId(getCurrentNavigatorId());
+    }
+}

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

@@ -0,0 +1,124 @@
+package com.reactnativenavigation.adapters;
+
+import android.support.design.widget.TabLayout;
+import android.support.v4.view.PagerAdapter;
+import android.support.v4.view.ViewPager;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.core.RctManager;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.views.RnnToolBar;
+import com.reactnativenavigation.views.ScreenStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Created by guyc on 02/04/16.
+ */
+public class ViewPagerAdapter extends PagerAdapter implements TabLayout.OnTabSelectedListener {
+
+    private static final String EVENT_ON_TAB_SELECTED = "OnTabSelected";
+
+    private ViewPager mViewPager;
+    private RnnToolBar mToolbar;
+    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;
+        mScreenStacks = new ArrayList<>();
+        mNavigatorIds = new ArrayList<>();
+        mStackByNavigatorId = new HashMap<>();
+        for (Screen screen : screens) {
+            ScreenStack stack = new ScreenStack(context);
+            stack.push(screen);
+            mScreenStacks.add(stack);
+            mNavigatorIds.add(screen.navigatorId);
+            mStackByNavigatorId.put(screen.navigatorId, stack);
+        }
+    }
+
+    public void push(Screen screen) {
+        ScreenStack stack = mStackByNavigatorId.get(screen.navigatorId);
+        stack.push(screen);
+    }
+
+    public Screen pop(String navigatorId) {
+        ScreenStack stack = mStackByNavigatorId.get(navigatorId);
+        return stack != null ? stack.pop() : null;
+    }
+
+    public Screen peek(String navigatorId) {
+        ScreenStack stack = mStackByNavigatorId.get(navigatorId);
+        return stack != null ? stack.peek() : null;
+    }
+
+    @Override
+    public Object instantiateItem(ViewGroup container, int position) {
+        ScreenStack view = mScreenStacks.get(position);
+        container.addView(view);
+        return view;
+    }
+
+    @Override
+    public void destroyItem(ViewGroup container, int position, Object view) {
+        container.removeView((View) view);
+    }
+
+    @Override
+    public int getCount() {
+        return mScreenStacks.size();
+    }
+
+    @Override
+    public boolean isViewFromObject(View view, Object object) {
+        return view == object;
+    }
+
+    @Override
+    public CharSequence getPageTitle(int position) {
+        return mScreenStacks.get(position).peek().title;
+    }
+
+    @Override
+    public void onTabSelected(TabLayout.Tab tab) {
+        // Set the viewPager's current item
+        int position = tab.getPosition();
+        mViewPager.setCurrentItem(position);
+
+        mToolbar.setupToolbarButtonsAsync(mScreenStacks.get(position).peek());
+
+        // Send tab selected event
+        WritableMap params = Arguments.createMap();
+        Screen screen = mScreenStacks.get(position).peek();
+        RctManager.getInstance().sendEvent(EVENT_ON_TAB_SELECTED, screen, params);
+    }
+
+    @Override
+    public void onTabUnselected(TabLayout.Tab tab) {
+
+    }
+
+    @Override
+    public void onTabReselected(TabLayout.Tab tab) {
+
+    }
+
+    public String getNavigatorId(int position) {
+        return mNavigatorIds.get(position);
+    }
+
+    public int getStackSizeForNavigatorId(String activeNavigatorID) {
+        return mStackByNavigatorId.get(activeNavigatorID).getStackSize();
+    }
+}

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

@@ -0,0 +1,112 @@
+package com.reactnativenavigation.core;
+
+import android.app.Application;
+
+import com.facebook.react.LifecycleState;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.core.objects.Screen;
+
+import static com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
+
+/**
+ * Created by guyc on 22/02/16.
+ */
+public class RctManager {
+    private static final String KEY_EVENT_ID = "id";
+    private static RctManager sInstance;
+
+    private ReactInstanceManager mReactManager;
+
+    private RctManager() {
+        // Singleton
+    }
+
+    public static synchronized RctManager getInstance() {
+        if (sInstance == null) {
+            sInstance = new RctManager();
+        }
+        return sInstance;
+    }
+
+    public ReactInstanceManager getReactInstanceManager() {
+        return mReactManager;
+    }
+
+    public boolean isInitialized() {
+        return mReactManager != null;
+    }
+
+    public void init(BaseReactActivity context) {
+        createReactInstanceManager(context);
+    }
+
+    /**
+     * Creates a React Instance Manager associated with this component name
+     */
+    public ReactInstanceManager createReactInstanceManager(BaseReactActivity reactActivity) {
+        ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
+                .setApplication((Application) reactActivity.getApplicationContext())
+                .setJSMainModuleName(reactActivity.getJSMainModuleName())
+                .setUseDeveloperSupport(reactActivity.getUseDeveloperSupport())
+                .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
+
+        for (ReactPackage reactPackage : reactActivity.getPackages()) {
+            builder.addPackage(reactPackage);
+        }
+
+        String jsBundleFile = reactActivity.getJSBundleFile();
+
+        if (jsBundleFile != null) {
+            builder.setJSBundleFile(jsBundleFile);
+        } else {
+            builder.setBundleAssetName(reactActivity.getBundleAssetName());
+        }
+
+        mReactManager = builder.build();
+        return mReactManager;
+    }
+
+    public <T extends ReactContextBaseJavaModule> T getNativeModule(Class<T> nativeModuleClass) {
+        if (mReactManager == null || mReactManager.getCurrentReactContext() == null) {
+            return null;
+        }
+
+        return mReactManager.getCurrentReactContext().getNativeModule(nativeModuleClass);
+    }
+
+    /**
+     * Sends an event to JavaScript using <a href="https://facebook.github.io/react-native/docs/native-modules-android.html#sending-events-to-javascript">RCTDeviceEventEmitter</a>
+     * @param eventName Name of the event
+     * @param params Event params
+     * @param screen screen which should receive the event
+     */
+    public void sendEvent(String eventName, Screen screen, WritableMap params) {
+        RCTDeviceEventEmitter eventEmitter = getEventEmitter();
+        if (eventEmitter == null) {
+            return;
+        }
+
+        params.putString(KEY_EVENT_ID, eventName);
+        params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
+        eventEmitter.emit(screen.navigatorEventId, params);
+    }
+
+    private RCTDeviceEventEmitter getEventEmitter() {
+        if (mReactManager == null) {
+            return null;
+        }
+
+        ReactContext currentReactContext = mReactManager.getCurrentReactContext();
+        if (currentReactContext == null) {
+            return null;
+        }
+
+        return currentReactContext.getJSModule(RCTDeviceEventEmitter.class);
+    }
+}
+

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

@@ -0,0 +1,120 @@
+package com.reactnativenavigation.core.objects;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.view.MenuItem;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.reactnativenavigation.BuildConfig;
+import com.reactnativenavigation.utils.ResourceDrawableIdHelper;
+
+import java.io.Serializable;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Created by guyc on 08/04/16.
+ */
+public class Button extends JsonObject implements Serializable {
+    private static final long serialVersionUID = -570145217281069067L;
+
+    public static final String LOCAL_RESOURCE_URI_SCHEME = "res";
+    private static final String KEY_ID = "id";
+    private static final String KEY_TITLE = "title";
+    private static final String KEY_ICON = "icon";
+
+    private static ResourceDrawableIdHelper sResDrawableIdHelper = new ResourceDrawableIdHelper();
+
+    public String id;
+    public String title;
+    private String mIconSource;
+
+    private static AtomicInteger sAtomicIdGenerator = new AtomicInteger();
+    private static Map<String, Integer> sStringToNumericId = new HashMap<>();
+
+    public Button(ReadableMap button) {
+        id = getString(button, KEY_ID);
+        title = getString(button, KEY_TITLE, "");
+        mIconSource = getString(button, KEY_ICON);
+    }
+
+    public boolean hasIcon() {
+        return mIconSource != null;
+    }
+
+    public Drawable getIcon(Context ctx) {
+        if (mIconSource == null) {
+            return null;
+        }
+
+        try {
+            Drawable icon;
+            Uri iconUri = getIconUri(ctx);
+
+            if (LOCAL_RESOURCE_URI_SCHEME.equals(iconUri.getScheme())) {
+                icon = sResDrawableIdHelper.getResourceDrawable(ctx, mIconSource);
+            } else {
+                URL url = new URL(iconUri.toString());
+                Bitmap bitmap = BitmapFactory.decodeStream(url.openStream());
+                icon = new BitmapDrawable(bitmap);
+            }
+            return icon;
+        } catch (Exception e) {
+            if (BuildConfig.DEBUG) {
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+    private Uri getIconUri(Context context) {
+        Uri ret = null;
+        if (mIconSource != null) {
+            try {
+                ret = Uri.parse(mIconSource);
+                // Verify scheme is set, so that relative uri (used by static resources) are not handled.
+                if (ret.getScheme() == null) {
+                    ret = null;
+                }
+            } catch (Exception e) {
+                // Ignore malformed uri, then attempt to extract resource ID.
+            }
+            if (ret == null) {
+                ret = sResDrawableIdHelper.getResourceDrawableUri(context, mIconSource);
+            }
+        }
+        return ret;
+    }
+
+    public int getItemId() {
+        if (sStringToNumericId.containsKey(id)) {
+            return sStringToNumericId.get(id);
+        }
+
+        int itemId = sAtomicIdGenerator.addAndGet(1);
+        sStringToNumericId.put(id, itemId);
+        return itemId;
+    }
+
+    /**
+     * Each button has a string id, defined in JS, which is used to identify the button when
+     * handling events.
+     * @param item Toolbar button
+     * @return Returns the event id associated with the given menu item
+     */
+    public static String getButtonEventId(MenuItem item) {
+        for (Map.Entry<String, Integer> entry : sStringToNumericId.entrySet()) {
+            if (entry.getValue() == item.getItemId()) {
+                return entry.getKey();
+            }
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.reactnativenavigation.core.objects;
+
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Created by guyc on 08/04/16.
+ */
+public class JsonObject {
+
+    protected String getString(ReadableMap map, String key) {
+        return getString(map, key, null);
+    }
+
+    protected String getString(ReadableMap map, String key, String defaultValue) {
+        return map.hasKey(key) ? map.getString(key) : defaultValue;
+    }
+
+    protected int getInt(ReadableMap map, String key) {
+        return map.hasKey(key) ? map.getInt(key) : -1;
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.reactnativenavigation.core.objects;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by guyc on 02/04/16.
+ */
+public class Screen extends JsonObject implements Serializable {
+    private static final long serialVersionUID = -1033475305421107791L;
+
+    private static final String KEY_TITLE = "title";
+    private static final String KEY_SCREEN = "screen";
+    public static final String KEY_SCREEN_INSTANCE_ID = "screenInstanceID";
+    public static final String KEY_NAVIGATOR_ID = "navigatorID";
+    public static final String KEY_NAVIGATOR_EVENT_ID = "navigatorEventID";
+    private static final String KEY_ICON = "icon";
+    private static final String KEY_RIGHT_BUTTONS = "rightButtons";
+
+    public String title;
+    public String screenId;
+    public String screenInstanceId;
+    public String navigatorId;
+    public String navigatorEventId;
+    public int icon;
+    public List<Button> buttons;
+
+    public Screen(ReadableMap screen) {
+        title = getString(screen, KEY_TITLE);
+        screenId = getString(screen, KEY_SCREEN);
+        screenInstanceId = getString(screen, KEY_SCREEN_INSTANCE_ID);
+        navigatorId = getString(screen, KEY_NAVIGATOR_ID);
+        navigatorEventId = getString(screen, KEY_NAVIGATOR_EVENT_ID);
+        icon = getInt(screen, KEY_ICON);
+
+        if (screen.hasKey(KEY_RIGHT_BUTTONS)) {
+            buttons = new ArrayList<>();
+            ReadableArray rightButtons = screen.getArray(KEY_RIGHT_BUTTONS);
+            for (int i = 0; i < rightButtons.size(); i++) {
+                buttons.add(new Button(rightButtons.getMap(i)));
+            }
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/modules/RctActivityModule.java

@@ -0,0 +1,99 @@
+package com.reactnativenavigation.modules;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.activities.SingleScreenActivity;
+import com.reactnativenavigation.activities.TabActivity;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.utils.ContextProvider;
+
+import java.util.ArrayList;
+
+/**
+ * Created by guyc on 10/03/16.
+ */
+public class RctActivityModule extends ReactContextBaseJavaModule {
+    public static final String REACT_CLASS = "RctActivity";
+
+    public RctActivityModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void startTabBasedApp(ReadableArray screens) {
+        Activity context = ContextProvider.getActivityContext();
+        if (context != null && !context.isFinishing()) {
+            Intent intent = new Intent(context, TabActivity.class);
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
+
+            Bundle extras = new Bundle();
+            extras.putSerializable(TabActivity.EXTRA_SCREENS, createScreens(screens));
+            intent.putExtras(extras);
+            
+            context.startActivity(intent);
+        }
+    }
+
+    private ArrayList<Screen> createScreens(ReadableArray screens) {
+        ArrayList<Screen> ret = new ArrayList<>();
+        for(int i = 0; i < screens.size(); i++) {
+            ret.add(new Screen(screens.getMap(i)));
+        }
+        return ret;
+    }
+
+    @ReactMethod
+    public void startSingleScreenApp(ReadableMap screen) {
+        BaseReactActivity context = ContextProvider.getActivityContext();
+        if (context != null && !context.isFinishing()) {
+            Intent intent = new Intent(context, SingleScreenActivity.class);
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
+
+            Bundle extras = new Bundle();
+            extras.putSerializable(SingleScreenActivity.EXTRA_SCREEN, new Screen(screen));
+            intent.putExtras(extras);
+
+            context.startActivity(intent);
+        }
+    }
+
+    @ReactMethod
+    public void navigatorPush(final ReadableMap screen) {
+        final BaseReactActivity context = ContextProvider.getActivityContext();
+         if (context != null && !context.isFinishing()) {
+             context.runOnUiThread(new Runnable() {
+                 @Override
+                 public void run() {
+                     context.push(new Screen(screen));
+                 }
+             });
+        }
+    }
+
+    @ReactMethod
+    public void navigatorPop(final ReadableMap navigator) {
+        final String navID = navigator.getString("navigatorID");
+        final BaseReactActivity context = ContextProvider.getActivityContext();
+        if (context != null && !context.isFinishing()) {
+            context.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    context.pop(navID);
+                }
+            });
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/packages/RnnPackage.java

@@ -0,0 +1,36 @@
+package com.reactnativenavigation.packages;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.reactnativenavigation.modules.RctActivityModule;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ *
+ * Created by guyc on 07/03/16.
+ */
+public class RnnPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(
+                new RctActivityModule(reactContext)
+        );
+    }
+
+    @Override
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.reactnativenavigation.utils;
+
+import java.util.Collection;
+
+/**
+ * Created by guyc on 11/04/16.
+ */
+public class CollectionUtils {
+
+    public static boolean isNullOrEmpty(Collection collection) {
+        return collection == null || collection.size() == 0;
+    }
+
+}

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

@@ -0,0 +1,32 @@
+package com.reactnativenavigation.utils;
+
+import com.reactnativenavigation.activities.BaseReactActivity;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Created by guyc on 10/03/16.
+ */
+public class ContextProvider {
+    private static WeakReference<BaseReactActivity> sActivityWR;
+
+    public static void setActivityContext(BaseReactActivity activity) {
+        if (sActivityWR == null) {
+            sActivityWR = new WeakReference<>(activity);
+        }
+    }
+
+    /**
+     * Returns the currently resumed activity or {@code null} if there is none.
+     */
+    public static BaseReactActivity getActivityContext() {
+        return sActivityWR != null ? sActivityWR.get() : null;
+    }
+
+    public static void clearActivityContext() {
+        if (sActivityWR != null) {
+            sActivityWR.clear();
+        }
+        sActivityWR = null;
+    }
+}

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

@@ -0,0 +1,24 @@
+package com.reactnativenavigation.utils;
+
+import java.lang.reflect.Field;
+
+/**
+ * Created by guyc on 14/04/16.
+ */
+public class ReflectionUtils {
+
+    public static boolean setBooleanField(Object obj, String name, Boolean value) {
+        Field field;
+        try {
+            field = obj.getClass().getDeclaredField(name);
+            field.setAccessible(true);
+            field.set(obj, value);
+            return true;
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,54 @@
+package com.reactnativenavigation.utils;// Copyright 2004-present Facebook. All Rights Reserved.
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+
+import com.facebook.common.util.UriUtil;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Helper class for obtaining information about local images.
+ */
+public class ResourceDrawableIdHelper {
+
+    private Map<String, Integer> mResourceDrawableIdMap;
+
+    public ResourceDrawableIdHelper() {
+        mResourceDrawableIdMap = new HashMap<>();
+    }
+
+    public int getResourceDrawableId(Context context, @Nullable String name) {
+        if (name == null || name.isEmpty()) {
+            return 0;
+        }
+        name = name.toLowerCase().replace("-", "_");
+        if (mResourceDrawableIdMap.containsKey(name)) {
+            return mResourceDrawableIdMap.get(name);
+        }
+        int id = context.getResources().getIdentifier(
+                name,
+                "drawable",
+                context.getPackageName());
+        mResourceDrawableIdMap.put(name, id);
+        return id;
+    }
+
+    @Nullable
+    public Drawable getResourceDrawable(Context context, @Nullable String name) {
+        int resId = getResourceDrawableId(context, name);
+        return resId > 0 ? context.getResources().getDrawable(resId) : null;
+    }
+
+    public Uri getResourceDrawableUri(Context context, @Nullable String name) {
+        int resId = getResourceDrawableId(context, name);
+        return resId > 0 ? new Uri.Builder()
+                .scheme(UriUtil.LOCAL_RESOURCE_SCHEME)
+                .path(String.valueOf(resId))
+                .build() : Uri.EMPTY;
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.reactnativenavigation.views;
+
+import android.os.Bundle;
+import android.widget.FrameLayout;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactRootView;
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.core.objects.Screen;
+
+/**
+ * Created by guyc on 10/03/16.
+ */
+public class RctView extends FrameLayout {
+
+    private ReactRootView mReactRootView;
+
+    public ReactRootView getReactRootView() {
+        return mReactRootView;
+    }
+
+    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, Screen screen) {
+        super(ctx);
+        setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        mReactRootView = new ReactRootView(ctx);
+        mReactRootView.setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        String componentName = screen.screenId;
+        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);
+
+        mReactRootView.startReactApplication(rctInstanceManager, componentName, passProps);
+
+        addView(mReactRootView);
+    }
+}
+

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

@@ -0,0 +1,123 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.os.AsyncTask;
+import android.support.v7.widget.Toolbar;
+import android.util.AttributeSet;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.core.objects.Button;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.utils.ContextProvider;
+
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by guyc on 09/04/16.
+ */
+public class RnnToolBar extends Toolbar {
+
+    private List<Screen> mScreens;
+    private AsyncTask mSetupToolbarTask;
+
+    public RnnToolBar(Context context) {
+        super(context);
+    }
+
+    public RnnToolBar(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public RnnToolBar(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public void setScreens(List<Screen> screens) {
+        mScreens = screens;
+    }
+
+    public void handleOnCreateOptionsMenuAsync() {
+        setupToolbarButtonsAsync(mScreens.get(0));
+    }
+
+    public void setupToolbarButtonsAsync(Screen screen) {
+        if (mSetupToolbarTask == null) {
+            mSetupToolbarTask = new SetupToolbarButtonsTask(this, screen).execute();
+        }
+    }
+
+    @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;
+
+        public SetupToolbarButtonsTask(RnnToolBar toolBar, Screen newScreen) {
+            mToolbarWR = new WeakReference<>(toolBar);
+            mButtons = newScreen.buttons == null ? Collections.EMPTY_LIST : newScreen.buttons;
+        }
+
+        @Override
+        protected Map<String, Drawable> doInBackground(Void... params) {
+            Context context = ContextProvider.getActivityContext();
+            if (context == null) {
+                return null;
+            }
+
+            Map<String, Drawable> icons = new HashMap<>();
+            for (Button button : mButtons) {
+                if (button.hasIcon()) {
+                    icons.put(button.id, button.getIcon(context));
+                }
+            }
+            return icons;
+        }
+
+        @Override
+        protected void onPostExecute(Map<String, Drawable> icons) {
+            Context context = ContextProvider.getActivityContext();
+            if (context == null) {
+                return;
+            }
+
+            Menu menu = ((BaseReactActivity) context).getMenu();
+
+            // Add new screen buttons
+            int i;
+            for (i = 0; i < mButtons.size(); i++) {
+                Button button = mButtons.get(i);
+                MenuItem item = menu.add(Menu.NONE, button.getItemId(), i, button.title);
+                if (icons.containsKey(button.id)) {
+                    Drawable icon = icons.get(button.id);
+                    item.setIcon(icon).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
+                }
+            }
+
+            // Remove prev screen buttons
+            for (int j = i; j < menu.size(); j++) {
+                menu.removeItem(j);
+            }
+
+            RnnToolBar toolBar = mToolbarWR.get();
+            if (toolBar != null) {
+                toolBar.mSetupToolbarTask = null;
+                mToolbarWR.clear();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+package com.reactnativenavigation.views;
+
+import android.animation.LayoutTransition;
+import android.widget.FrameLayout;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactRootView;
+import com.reactnativenavigation.activities.BaseReactActivity;
+import com.reactnativenavigation.core.RctManager;
+import com.reactnativenavigation.core.objects.Screen;
+import com.reactnativenavigation.utils.ReflectionUtils;
+
+import java.util.Stack;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+public class ScreenStack extends FrameLayout {
+
+    private static class ScreenView {
+        Screen screen;
+        RctView view;
+
+        public ScreenView(Screen screen, RctView view) {
+            this.screen = screen;
+            this.view = view;
+        }
+    }
+
+    private final Stack<ScreenView> mStack = new Stack<>();
+    private final ReactInstanceManager mReactInstanceManager =
+            RctManager.getInstance().getReactInstanceManager();
+    private final BaseReactActivity mReactActivity;
+
+    public ScreenStack(BaseReactActivity context) {
+        super(context);
+        mReactActivity = context;
+        setLayoutTransition(new LayoutTransition());
+    }
+
+    public void push(Screen screen) {
+        RctView oldView = null;
+        if (!mStack.isEmpty()) {
+            oldView = mStack.peek().view;
+        }
+        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);
+        }
+        mStack.push(new ScreenView(screen, view));
+    }
+
+    public Screen pop() {
+        if (mStack.isEmpty()) {
+            return null;
+        }
+        ScreenView popped = mStack.pop();
+        if (!mStack.isEmpty()) {
+            addView(mStack.peek().view, 0);
+        }
+
+        ReflectionUtils.setBooleanField(popped.view.getReactRootView(), "mAttachScheduled", false);
+        removeView(popped.view);
+        return popped.screen;
+    }
+
+    public boolean isEmpty() {
+        return mStack.isEmpty();
+    }
+
+    public int getStackSize() {
+        return mStack.size();
+    }
+
+    public Screen peek() {
+        return mStack.peek().screen;
+    }
+}

android/app/src/main/res/layout/single_screen_activity.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <android.support.design.widget.AppBarLayout
+        android:id="@+id/appbar"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:fitsSystemWindows="true">
+        <android.support.v7.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            app:layout_scrollFlags="scroll|enterAlways"/>
+    </android.support.design.widget.AppBarLayout>
+
+    <FrameLayout
+        android:id="@+id/contentFrame"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+</LinearLayout>

android/app/src/main/res/layout/tab_activity.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".activities.TabActivity">
+
+    <android.support.design.widget.AppBarLayout
+        android:id="@+id/appbar"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:fitsSystemWindows="true">
+        <com.reactnativenavigation.views.RnnToolBar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            app:layout_scrollFlags="scroll|enterAlways"/>
+        <android.support.design.widget.TabLayout
+            android:id="@+id/tabLayout"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            app:layout_scrollFlags="scroll|enterAlways"/>
+    </android.support.design.widget.AppBarLayout>
+
+    <android.support.v4.view.ViewPager
+        android:id="@+id/viewPager"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+</LinearLayout>

android/app/src/main/res/values/ids.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item name="react_root_view" type="id"/>
+</resources>

android/build.gradle

@@ -0,0 +1,24 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        mavenLocal()
+        jcenter()
+        maven {
+            // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+            url "$projectDir/../../node_modules/react-native/android"
+        }
+    }
+}

android/gradle.properties

@@ -0,0 +1,20 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useDeprecatedNdk=true

android/react-native-navigation.iml

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.id=":react-native-navigation" external.linked.project.path="$MODULE_DIR$/app" external.root.project.path="$MODULE_DIR$/../../../android" external.system.id="GRADLE" external.system.module.group="example" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="java-gradle" name="Java-Gradle">
+      <configuration>
+        <option name="BUILD_FOLDER_PATH" value="$MODULE_DIR$/build" />
+        <option name="BUILDABLE" value="false" />
+      </configuration>
+    </facet>
+    <facet type="android-gradle" name="Android-Gradle">
+      <configuration>
+        <option name="GRADLE_PROJECT_PATH" value=":react-native-navigation" />
+      </configuration>
+    </facet>
+    <facet type="android" name="Android">
+      <configuration>
+        <option name="SELECTED_BUILD_VARIANT" value="libraryDebug" />
+        <option name="SELECTED_TEST_ARTIFACT" value="_android_test_" />
+        <option name="ASSEMBLE_TASK_NAME" value="assembleLibraryDebug" />
+        <option name="COMPILE_JAVA_TASK_NAME" value="compileLibraryDebugSources" />
+        <option name="ASSEMBLE_TEST_TASK_NAME" value="assembleLibraryDebugAndroidTest" />
+        <option name="COMPILE_JAVA_TEST_TASK_NAME" value="compileLibraryDebugAndroidTestSources" />
+        <afterSyncTasks>
+          <task>generateLibraryDebugAndroidTestSources</task>
+          <task>generateLibraryDebugSources</task>
+        </afterSyncTasks>
+        <option name="ALLOW_USER_CONFIGURATION" value="false" />
+        <option name="MANIFEST_FILE_RELATIVE_PATH" value="/src/main/AndroidManifest.xml" />
+        <option name="RES_FOLDER_RELATIVE_PATH" value="/src/main/res" />
+        <option name="RES_FOLDERS_RELATIVE_PATH" value="file://$MODULE_DIR$/app/src/main/res" />
+        <option name="ASSETS_FOLDER_RELATIVE_PATH" value="/src/main/assets" />
+        <option name="LIBRARY_PROJECT" value="true" />
+      </configuration>
+    </facet>
+  </component>
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_7" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/app/build/intermediates/classes/library/debug" />
+    <output-test url="file://$MODULE_DIR$/app/build/intermediates/classes/androidTest/library/debug" />
+    <exclude-output />
+    <content url="file://$MODULE_DIR$/app">
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/r/library/debug" isTestSource="false" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/aidl/library/debug" isTestSource="false" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/buildConfig/library/debug" isTestSource="false" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/rs/library/debug" isTestSource="false" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/res/rs/library/debug" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/res/resValues/library/debug" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/res" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/assets" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/aidl" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/jni" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/libraryDebug/rs" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/r/androidTest/library/debug" isTestSource="true" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/aidl/androidTest/library/debug" isTestSource="true" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/buildConfig/androidTest/library/debug" isTestSource="true" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/source/rs/androidTest/library/debug" isTestSource="true" generated="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/res/rs/androidTest/library/debug" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/build/generated/res/resValues/androidTest/library/debug" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/res" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/assets" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/aidl" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/jni" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/library/rs" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/res" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/resources" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/assets" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/aidl" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/java" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/jni" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTestLibrary/rs" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/res" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/assets" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/aidl" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/jni" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/debug/rs" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/res" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/assets" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/aidl" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/jni" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/main/rs" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/res" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/resources" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/assets" type="java-test-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/aidl" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/java" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/jni" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/app/src/androidTest/rs" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/annotations" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/assets" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/bundles" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/classes" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/dependency-cache" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/exploded-aar/com.facebook.react/react-native/0.20.1/jars" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/incremental" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/lint" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/res" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/rs" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/intermediates/symbols" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/outputs" />
+      <excludeFolder url="file://$MODULE_DIR$/app/build/tmp" />
+    </content>
+    <orderEntry type="jdk" jdkName="Android API 23 Platform" jdkType="Android SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" exported="" name="support-annotations-23.1.1" level="project" />
+    <orderEntry type="library" exported="" name="fresco-0.8.1" level="project" />
+    <orderEntry type="library" exported="" name="design-23.1.1" level="project" />
+    <orderEntry type="library" exported="" name="imagepipeline-okhttp-0.8.1" level="project" />
+    <orderEntry type="library" exported="" name="imagepipeline-0.8.1" level="project" />
+    <orderEntry type="library" exported="" name="stetho-1.2.0" level="project" />
+    <orderEntry type="library" exported="" name="jsr305-3.0.0" level="project" />
+    <orderEntry type="library" exported="" name="jackson-core-2.2.3" level="project" />
+    <orderEntry type="library" exported="" name="recyclerview-v7-23.1.1" level="project" />
+    <orderEntry type="library" exported="" name="react-native-0.20.1" level="project" />
+    <orderEntry type="library" exported="" name="support-v4-23.1.1" level="project" />
+    <orderEntry type="library" exported="" name="appcompat-v7-23.1.1" level="project" />
+    <orderEntry type="library" exported="" name="okhttp-2.5.0" level="project" />
+    <orderEntry type="library" exported="" name="okhttp-ws-2.5.0" level="project" />
+    <orderEntry type="library" exported="" name="okio-1.6.0" level="project" />
+    <orderEntry type="library" exported="" name="fbcore-0.8.1" level="project" />
+    <orderEntry type="library" exported="" name="android-jsc-r174650" level="project" />
+    <orderEntry type="library" exported="" name="drawee-0.8.1" level="project" />
+    <orderEntry type="library" exported="" name="stetho-okhttp-1.2.0" level="project" />
+    <orderEntry type="library" exported="" name="bolts-android-1.1.4" level="project" />
+    <orderEntry type="library" exported="" name="commons-cli-1.2" level="project" />
+    <orderEntry type="library" exported="" name="library-2.4.0" level="project" />
+  </component>
+</module>

android/react-navtive-navigation.iml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.id="react-navtive-navigation" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="java-gradle" name="Java-Gradle">
+      <configuration>
+        <option name="BUILD_FOLDER_PATH" value="$MODULE_DIR$/build" />
+        <option name="BUILDABLE" value="false" />
+      </configuration>
+    </facet>
+  </component>
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_7" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.gradle" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

example-redux/android/app/build.gradle

@@ -123,4 +123,7 @@ dependencies {
     compile fileTree(dir: "libs", include: ["*.jar"])
     compile "com.android.support:appcompat-v7:23.0.1"
     compile "com.facebook.react:react-native:+"  // From node_modules
+    debugCompile project(path: ':react-native-navigation', configuration: 'libraryDebug')
+    releaseCompile project(path: ':react-native-navigation', configuration: 'libraryRelease')
+//    compile project(':react-native-navigation')
 }

example-redux/android/app/react.gradle

@@ -41,7 +41,7 @@ gradle.projectsEvaluated {
             def jsBundleDir = elvisFile(config."$jsBundleDirConfigName") ?:
                     file("$buildDir/intermediates/assets/${targetPath}")
 
-            def resourcesDirConfigName = "jsBundleDir${targetName}"
+            def resourcesDirConfigName = "resourcesDir${targetName}"
             def resourcesDir = elvisFile(config."${resourcesDirConfigName}") ?:
                     file("$buildDir/intermediates/res/merged/${targetPath}")
             def jsBundleFile = file("$jsBundleDir/$bundleAssetName")

example-redux/android/app/src/main/java/com/exampleredux/MainActivity.java

@@ -1,40 +1,7 @@
 package com.exampleredux;
 
-import com.facebook.react.ReactActivity;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.shell.MainReactPackage;
+import com.reactnativenavigation.activities.RootActivity;
 
-import java.util.Arrays;
-import java.util.List;
+public class MainActivity extends RootActivity {
 
-public class MainActivity extends ReactActivity {
-
-    /**
-     * Returns the name of the main component registered from JavaScript.
-     * This is used to schedule rendering of the component.
-     */
-    @Override
-    protected String getMainComponentName() {
-        return "exampleRedux";
-    }
-
-    /**
-     * Returns whether dev mode should be enabled.
-     * This enables e.g. the dev menu.
-     */
-    @Override
-    protected boolean getUseDeveloperSupport() {
-        return BuildConfig.DEBUG;
-    }
-
-    /**
-     * A list of packages used by the app. If the app uses additional views
-     * or modules besides the default ones, add more packages here.
-     */
-    @Override
-    protected List<ReactPackage> getPackages() {
-        return Arrays.<ReactPackage>asList(
-            new MainReactPackage()
-        );
-    }
 }

example-redux/android/settings.gradle

@@ -1,3 +1,6 @@
 rootProject.name = 'exampleRedux'
 
 include ':app'
+include ':react-native-navigation'
+project(':react-native-navigation').projectDir = new File(
+        rootProject.projectDir, '../node_modules/react-native-navigation/android/app/')

example-redux/index.android.js

@@ -1,45 +1,3 @@
-/**
- * Sample React Native App
- * https://github.com/facebook/react-native
- */
-'use strict';
-import React, {
-  AppRegistry,
-  Component,
-  StyleSheet,
-  Text,
-  View
-} from 'react-native';
+import App from './src/app';
 
-class exampleRedux extends Component {
-  render() {
-    return (
-      <View style={styles.container}>
-        <Text style={styles.welcome}>
-          Coming Soon
-        </Text>
-      </View>
-    );
-  }
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#F5FCFF',
-  },
-  welcome: {
-    fontSize: 20,
-    textAlign: 'center',
-    margin: 10,
-  },
-  instructions: {
-    textAlign: 'center',
-    color: '#333333',
-    marginBottom: 5,
-  },
-});
-
-AppRegistry.registerComponent('exampleRedux', () => exampleRedux);
+const app = new App();

example-redux/src/app.js

@@ -21,15 +21,17 @@ export default class App {
     store.subscribe(this.onStoreUpdate.bind(this));
     store.dispatch(appActions.appInitialized());
   }
+
   onStoreUpdate() {
     const { root } = store.getState().app;
     // handle a root change
     // if your app doesn't change roots in runtime, you can remove onStoreUpdate() altogether
-    if (this.currentRoot !== root) {
+    if (this.currentRoot != root) {
       this.currentRoot = root;
       this.startApp(root);
     }
   }
+
   startApp(root) {
     switch (root) {
       case 'login':
@@ -61,7 +63,8 @@ export default class App {
               navigatorStyle: {}
             }
           ],
-          animationType: 'slide-down'
+          animationType: 'slide-down',
+          title: 'Redux Example'
         });
         return;
       default:

example-redux/src/screens/FirstTabScreen.js

@@ -5,7 +5,7 @@ import React, {
   ScrollView,
   TouchableOpacity,
   StyleSheet,
-  AlertIOS
+  Alert
 } from 'react-native';
 import { connect } from 'react-redux';
 import * as counterActions from '../reducers/counter/actions';
@@ -20,6 +20,7 @@ class FirstTabScreen extends Component {
       },
       {
         icon: require('../../img/navicon_add.png'),
+        title: 'Add',
         id: 'add'
       }
     ]
@@ -30,11 +31,18 @@ class FirstTabScreen extends Component {
     this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
   }
   onNavigatorEvent(event) {
-    if (event.id == 'edit') {
-      AlertIOS.alert('NavBar', 'Edit button pressed');
-    }
-    if (event.id == 'add') {
-      AlertIOS.alert('NavBar', 'Add button pressed');
+    switch (event.id) {
+      case 'edit':
+        Alert.alert('NavBar', 'Edit button pressed');
+        break;
+
+      case 'add':
+        Alert.alert('NavBar', 'Add button pressed');
+        break;
+
+      default:
+        console.log('Unhandled event ' + event.id);
+        break;
     }
   }
   render() {
@@ -72,7 +80,7 @@ const styles = StyleSheet.create({
     textAlign: 'center',
     fontSize: 18,
     marginBottom: 10,
-    marginTop:10,
+    marginTop:10
   },
   button: {
     textAlign: 'center',

example-redux/src/screens/LoginScreen.js

@@ -4,8 +4,7 @@ import React, {
   View,
   ScrollView,
   TouchableOpacity,
-  StyleSheet,
-  AlertIOS
+  StyleSheet
 } from 'react-native';
 import { connect } from 'react-redux';
 import * as counterActions from '../reducers/counter/actions';

example-redux/src/screens/PushedScreen.js

@@ -4,7 +4,8 @@ import React, {
   View,
   ScrollView,
   TouchableOpacity,
-  StyleSheet
+  StyleSheet,
+  TextInput
 } from 'react-native';
 import { connect } from 'react-redux';
 import * as counterActions from '../reducers/counter/actions';
@@ -13,10 +14,22 @@ import * as counterActions from '../reducers/counter/actions';
 class PushedScreen extends Component {
   constructor(props) {
     super(props);
+    this.bgColor = this.getRandomColor();
+    console.log('constructor');
   }
+
+  getRandomColor() {
+    var letters = '0123456789ABCDEF'.split('');
+    var color = '#';
+    for (var i = 0; i < 6; i++ ) {
+      color += letters[Math.floor(Math.random() * 16)];
+    }
+    return color;
+  }
+
   render() {
     return (
-      <View style={{flex: 1, padding: 20}}>
+      <View style={{flex: 1, padding: 20, backgroundColor: this.bgColor}}>
 
         <Text style={styles.text}>
           <Text style={{fontWeight: '500'}}>Counter: </Text> {this.props.counter.count}
@@ -34,6 +47,8 @@ class PushedScreen extends Component {
           <Text style={styles.button}>Pop Screen</Text>
         </TouchableOpacity>
 
+        <TextInput style={{height: 40, borderColor: 'gray', borderWidth: 1}}/>
+
       </View>
     );
   }

example-redux/src/screens/SecondTabScreen.js

@@ -6,7 +6,7 @@ import React, {
   ScrollView,
   TouchableOpacity,
   StyleSheet,
-  AlertIOS
+  Alert
 } from 'react-native';
 import { connect } from 'react-redux';
 import * as counterActions from '../reducers/counter/actions';

example/android/app/build.gradle

@@ -120,7 +120,10 @@ android {
 }
 
 dependencies {
-    compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.android.support:appcompat-v7:23.0.1"
-    compile "com.facebook.react:react-native:+"  // From node_modules
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'com.android.support:appcompat-v7:23.0.1'
+    compile 'com.facebook.react:react-native:+'
+        debugCompile project(path: ':react-native-navigation', configuration: 'libraryDebug')
+        releaseCompile project(path: ':react-native-navigation', configuration: 'libraryRelease')
+//    compile project(':react-native-navigation')
 }

example/android/app/react.gradle

@@ -41,7 +41,7 @@ gradle.projectsEvaluated {
             def jsBundleDir = elvisFile(config."$jsBundleDirConfigName") ?:
                     file("$buildDir/intermediates/assets/${targetPath}")
 
-            def resourcesDirConfigName = "jsBundleDir${targetName}"
+            def resourcesDirConfigName = "resourcesDir${targetName}"
             def resourcesDir = elvisFile(config."${resourcesDirConfigName}") ?:
                     file("$buildDir/intermediates/res/merged/${targetPath}")
             def jsBundleFile = file("$jsBundleDir/$bundleAssetName")

example/android/app/src/main/AndroidManifest.xml

@@ -1,23 +1,23 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.example">
+          package="com.example">
 
     <uses-permission android:name="android.permission.INTERNET" />
 
     <application
-      android:allowBackup="true"
-      android:label="@string/app_name"
-      android:icon="@mipmap/ic_launcher"
-      android:theme="@style/AppTheme">
-      <activity
-        android:name=".MainActivity"
+        android:allowBackup="true"
         android:label="@string/app_name"
-        android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
-        <intent-filter>
-            <action android:name="android.intent.action.MAIN" />
-            <category android:name="android.intent.category.LAUNCHER" />
-        </intent-filter>
-      </activity>
-      <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+        android:icon="@mipmap/ic_launcher"
+        android:theme="@style/AppTheme">
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
     </application>
 
 </manifest>

example/android/app/src/main/java/com/example/MainActivity.java

@@ -1,40 +1,18 @@
 package com.example;
 
-import com.facebook.react.ReactActivity;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.shell.MainReactPackage;
 
-import java.util.Arrays;
-import java.util.List;
+import com.reactnativenavigation.activities.RctActivity;
 
-public class MainActivity extends ReactActivity {
+public class MainActivity extends RctActivity {
 
-    /**
-     * Returns the name of the main component registered from JavaScript.
-     * This is used to schedule rendering of the component.
-     */
     @Override
     protected String getMainComponentName() {
-        return "example";
+        return "App";
     }
 
-    /**
-     * Returns whether dev mode should be enabled.
-     * This enables e.g. the dev menu.
-     */
     @Override
-    protected boolean getUseDeveloperSupport() {
-        return BuildConfig.DEBUG;
-    }
-
-    /**
-     * A list of packages used by the app. If the app uses additional views
-     * or modules besides the default ones, add more packages here.
-     */
-    @Override
-    protected List<ReactPackage> getPackages() {
-        return Arrays.<ReactPackage>asList(
-            new MainReactPackage()
-        );
+    protected void onPause() {
+        super.onPause();
+        finish();
     }
 }

example/android/settings.gradle

@@ -1,3 +1,6 @@
 rootProject.name = 'example'
 
 include ':app'
+include ':react-native-navigation'
+project(':react-native-navigation').projectDir = new File(
+        rootProject.projectDir, '../node_modules/react-native-navigation/android/app/')

example/index.android.js

@@ -1,45 +1 @@
-/**
- * Sample React Native App
- * https://github.com/facebook/react-native
- */
-'use strict';
-import React, {
-  AppRegistry,
-  Component,
-  StyleSheet,
-  Text,
-  View
-} from 'react-native';
-
-class example extends Component {
-  render() {
-    return (
-      <View style={styles.container}>
-        <Text style={styles.welcome}>
-          Coming Soon
-        </Text>
-      </View>
-    );
-  }
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#F5FCFF',
-  },
-  welcome: {
-    fontSize: 20,
-    textAlign: 'center',
-    margin: 10,
-  },
-  instructions: {
-    textAlign: 'center',
-    color: '#333333',
-    marginBottom: 5,
-  },
-});
-
-AppRegistry.registerComponent('example', () => example);
+import App from './src/app';

example/src/app.js

@@ -1,9 +1,28 @@
+import React, {
+  AppRegistry,
+  Component,
+  View
+} from 'react-native';
 import { Navigation } from 'react-native-navigation';
 
 // screen related book keeping
 import { registerScreens } from './screens';
 registerScreens();
 
+AppRegistry.registerComponent('App', () => App);
+
+export default class App extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+
+  render() {
+    return (
+      <View />
+    );
+  }
+}
+
 // this will start our app
 Navigation.startTabBasedApp({
   tabs: [

example/src/screens/FirstTabScreen.android.js

@@ -0,0 +1,111 @@
+import React, {
+  Component,
+  Text,
+  View,
+  ScrollView,
+  TouchableOpacity,
+  StyleSheet
+} from 'react-native';
+
+export default class FirstTabScreen extends Component {
+  static navigatorButtons = {
+    leftButtons: [{
+      icon: require('../../img/navicon_menu.png'),
+      id: 'menu'
+    }],
+    rightButtons: [
+      {
+        title: 'Edit',
+        id: 'edit'
+      },
+      {
+        icon: require('../../img/navicon_add.png'),
+        id: 'add'
+      }
+    ]
+  };
+  static navigatorStyle = {
+    drawUnderTabBar: true
+  };
+  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) {
+    if (event.id == 'menu') {
+      this.props.navigator.toggleDrawer({
+        side: 'left',
+        animated: true
+      });
+    }
+    if (event.id == 'edit') {
+      // AlertIOS.alert('NavBar', 'Edit button pressed');
+    }
+    if (event.id == 'add') {
+      // AlertIOS.alert('NavBar', 'Add button pressed');
+    }
+  }
+  render() {
+    return (
+      <View style={{flex: 1, padding: 20}}>
+
+        <TouchableOpacity onPress={ this.onPushPress.bind(this) }>
+          <Text style={styles.button}>Push Plain Screen</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onPushStyledPress.bind(this) }>
+          <Text style={styles.button}>Push Styled Screen</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onModalPress.bind(this) }>
+          <Text style={styles.button}>Show Modal Screen</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onLightBoxPress.bind(this) }>
+          <Text style={styles.button}>Show LightBox</Text>
+        </TouchableOpacity>
+
+      </View>
+    );
+  }
+  onPushPress() {
+    this.props.navigator.push({
+      title: "More",
+      screen: "example.PushedScreen"
+    });
+  }
+  onPushStyledPress() {
+    console.warn('navigator.push not implemented yet');
+    // this.props.navigator.push({
+    //   title: "Styled",
+    //   screen: "example.StyledScreen"
+    // });
+  }
+  onModalPress() {
+    console.warn('navigator.showModal not implemented yet');
+    // this.props.navigator.showModal({
+    //   title: "Modal",
+    //   screen: "example.ModalScreen"
+    // });
+  }
+  onLightBoxPress() {
+    console.warn('navigator.showLightBox not implemented yet');
+    // this.props.navigator.showLightBox({
+    //   screen: "example.LightBoxScreen",
+    //   style: {
+    //     backgroundBlur: "dark"
+    //   }
+    // });
+  }
+}
+
+const styles = StyleSheet.create({
+  button: {
+    textAlign: 'center',
+    fontSize: 18,
+    marginBottom: 10,
+    marginTop:10,
+    color: 'blue'
+  }
+});

example/src/screens/SecondTabScreen.android.js

@@ -0,0 +1,133 @@
+import React, {
+  Component,
+  Text,
+  View,
+  ScrollView,
+  TouchableOpacity,
+  StyleSheet
+} from 'react-native';
+
+export default class SecondTabScreen extends Component {
+  static navigatorStyle = {
+    drawUnderTabBar: true
+  };
+  constructor(props) {
+    super(props);
+    this.buttonsCounter = 0;
+    // if you want to listen on navigator events, set this up
+    // this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
+  }
+  render() {
+    return (
+      <View style={{flex: 1, padding: 20}}>
+
+        <TouchableOpacity onPress={ this.onChangeButtonsPress.bind(this) }>
+          <Text style={styles.button}>Change Buttons</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onChangeTitlePress.bind(this) }>
+          <Text style={styles.button}>Change Title</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onSwitchTabPress.bind(this) }>
+          <Text style={styles.button}>Switch To Tab#1</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onSetTabBadgePress.bind(this) }>
+          <Text style={styles.button}>Set Tab Badge</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity onPress={ this.onToggleTabsPress.bind(this) }>
+          <Text style={styles.button}>Toggle Tabs</Text>
+        </TouchableOpacity>
+
+      </View>
+    );
+  }
+  onChangeTitlePress() {
+    this.props.navigator.setTitle({
+      title: Math.round(Math.random() * 100000).toString()
+    });
+  }
+  onChangeButtonsPress() {
+    let buttons;
+    if (this.buttonsCounter % 3 == 0) {
+      buttons = [
+        {
+          title: 'Edit',
+          id: 'edit',
+          disabled: true
+        },
+        {
+          icon: require('../../img/navicon_add.png'),
+          id: 'add'
+        }
+      ];
+    } else if (this.buttonsCounter % 3 == 1) {
+      buttons = [{
+        title: 'Save',
+        id: 'save'
+      }];
+    } else {
+      buttons = [];
+    }
+    this.buttonsCounter++;
+
+    this.props.navigator.setButtons({
+      rightButtons: buttons,
+      animated: true
+    });
+  }
+  onSwitchTabPress() {
+    this.props.navigator.switchToTab({
+      tabIndex: 0
+    });
+  }
+  onSetTabBadgePress() {
+    this.props.navigator.setTabBadge({
+      badge: 12
+    });
+  }
+  onToggleTabsPress() {
+    this.props.navigator.toggleTabs({
+      to: this.tabsHidden ? 'shown' : 'hidden'
+    });
+    this.tabsHidden = !this.tabsHidden;
+  }
+  onNavigatorEvent(event) {
+    // handle a deep link
+    if (event.type == 'DeepLink') {
+      const parts = event.link.split('/');
+      if (parts[0] == 'tab2') {
+        this.props.navigator.resetTo({
+          title: "Replaced Root",
+          screen: parts[1],
+          animated: true
+        });
+        this.props.navigator.switchToTab();
+      }
+    }
+    // handle a button press
+    // if (event.type == 'NavBarButtonPress') {
+    //   if (event.id == 'edit') {
+    //     AlertIOS.alert('NavBar', 'Dynamic Edit button pressed');
+    //   }
+    //   if (event.id == 'add') {
+    //     AlertIOS.alert('NavBar', 'Dynamic Add button pressed');
+    //   }
+    //   if (event.id == 'save') {
+    //     AlertIOS.alert('NavBar', 'Dynamic Save button pressed');
+    //   }
+    // }
+  }
+}
+
+const styles = StyleSheet.create({
+  button: {
+    textAlign: 'center',
+    fontSize: 18,
+    marginBottom: 10,
+    marginTop:10,
+    color: 'blue'
+  }
+});

example/src/screens/index.android.js

@@ -0,0 +1,20 @@
+import { Navigation } from 'react-native-navigation';
+
+import FirstTabScreen from './FirstTabScreen';
+import SecondTabScreen from './SecondTabScreen';
+import ThirdTabScreen from './ThirdTabScreen';
+import PushedScreen from './PushedScreen';
+import StyledScreen from './StyledScreen';
+import ModalScreen from './ModalScreen';
+import LightBoxScreen from './LightBoxScreen';
+import SideMenu from './SideMenu';
+
+// register all screens of the app (including internal ones)
+export function registerScreens() {
+  Navigation.registerComponent('example.FirstTabScreen', () => FirstTabScreen);
+  Navigation.registerComponent('example.SecondTabScreen', () => SecondTabScreen);
+  Navigation.registerComponent('example.ThirdTabScreen', () => ThirdTabScreen);
+  Navigation.registerComponent('example.PushedScreen', () => PushedScreen);
+  Navigation.registerComponent('example.StyledScreen', () => StyledScreen);
+  Navigation.registerComponent('example.SideMenu', () => SideMenu);
+}

index.js

@@ -1,7 +1,9 @@
 import Navigation from './src/Navigation';
 import Screen from './src/Screen';
+import RctActivity from './src/modules/RctActivity';
 
 export {
   Navigation,
-  Screen
+  Screen,
+  RctActivity
 };

src/Navigation.js

@@ -10,8 +10,11 @@ function registerScreen(screenID, generator) {
 }
 
 function registerComponent(screenID, generator, store = undefined, Provider = undefined) {
-  if (store && Provider) return _registerComponentRedux(screenID, generator, store, Provider);
-  else return _registerComponentNoRedux(screenID, generator);
+  if (store && Provider) {
+    return _registerComponentRedux(screenID, generator, store, Provider);
+  } else {
+    return _registerComponentNoRedux(screenID, generator);
+  }
 }
 
 function _registerComponentNoRedux(screenID, generator) {
@@ -26,7 +29,7 @@ function _registerComponentNoRedux(screenID, generator) {
         );
       }
     };
-  }
+  };
   registerScreen(screenID, generatorWrapper);
   return generatorWrapper;
 }
@@ -45,7 +48,7 @@ function _registerComponentRedux(screenID, generator, store, Provider) {
         );
       }
     };
-  }
+  };
   registerScreen(screenID, generatorWrapper);
   return generatorWrapper;
 }

src/Screen.js

@@ -1,4 +1,9 @@
-import { Component, NativeAppEventEmitter } from 'react-native';
+import {
+  Component,
+  NativeAppEventEmitter,
+  DeviceEventEmitter,
+  Platform
+} from 'react-native';
 import platformSpecific from './platformSpecific';
 import Navigation from './Navigation';
 
@@ -11,55 +16,72 @@ class Navigator {
     this.navigatorEventHandler = null;
     this.navigatorEventSubscription = null;
   }
+
   push(params = {}) {
     return platformSpecific.navigatorPush(this, params);
   }
+
   pop(params = {}) {
     return platformSpecific.navigatorPop(this, params);
   }
+
   popToRoot(params = {}) {
     return platformSpecific.navigatorPopToRoot(this, params);
   }
+
   resetTo(params = {}) {
     return platformSpecific.navigatorResetTo(this, params);
   }
+
   showModal(params = {}) {
     return Navigation.showModal(params);
   }
+
   dismissModal(params = {}) {
     return Navigation.dismissModal(params);
   }
+
   dismissAllModals(params = {}) {
     return Navigation.dismissAllModals(params);
   }
+
   showLightBox(params = {}) {
     return Navigation.showLightBox(params);
   }
+
   dismissLightBox(params = {}) {
     return Navigation.dismissLightBox(params);
   }
+
   setButtons(params = {}) {
     return platformSpecific.navigatorSetButtons(this, this.navigatorEventID, params);
   }
+
   setTitle(params = {}) {
     return platformSpecific.navigatorSetTitle(this, params);
   }
+
   toggleDrawer(params = {}) {
     return platformSpecific.navigatorToggleDrawer(this, params);
   }
+
   toggleTabs(params = {}) {
     return platformSpecific.navigatorToggleTabs(this, params);
   }
+
   setTabBadge(params = {}) {
     return platformSpecific.navigatorSetTabBadge(this, params);
   }
+
   switchToTab(params = {}) {
     return platformSpecific.navigatorSwitchToTab(this, params);
   }
+
   setOnNavigatorEvent(callback) {
     this.navigatorEventHandler = callback;
     if (!this.navigatorEventSubscription) {
-      this.navigatorEventSubscription = NativeAppEventEmitter.addListener(this.navigatorEventID, (event) => this.onNavigatorEvent(event));
+      let Emitter = Platform.OS === 'android' ? DeviceEventEmitter : NativeAppEventEmitter;
+      this.navigatorEventSubscription = Emitter.addListener(this.navigatorEventID, (event) => this.onNavigatorEvent(event));
       _allNavigatorEventHandlers[this.navigatorEventID] = (event) => this.onNavigatorEvent(event);
     }
   }
@@ -73,11 +95,13 @@ class Navigator {
       _allNavigatorEventHandlers[i](event);
     }
   }
+
   onNavigatorEvent(event) {
     if (this.navigatorEventHandler) {
       this.navigatorEventHandler(event);
     }
   }
+
   cleanup() {
     if (this.navigatorEventSubscription) {
       this.navigatorEventSubscription.remove();
@@ -89,12 +113,14 @@ class Navigator {
 export default class Screen extends Component {
   static navigatorStyle = {};
   static navigatorButtons = {};
+  
   constructor(props) {
     super(props);
     if (props.navigatorID) {
       this.navigator = new Navigator(props.navigatorID, props.navigatorEventID);
     }
   }
+
   componentWillUnmount() {
     if (this.navigator) {
       this.navigator.cleanup();

src/modules/RctActivity.js

@@ -0,0 +1,2 @@
+import { NativeModules } from 'react-native';
+module.exports = NativeModules.RctActivity;

src/platformSpecific.android.js

@@ -0,0 +1,80 @@
+import React, {
+  AppRegistry,
+  Component
+} from 'react-native';
+
+import Navigation from './Navigation';
+import utils from './utils';
+
+import {
+  RctActivity
+} from 'react-native-navigation';
+
+var resolveAssetSource = require('resolveAssetSource');
+
+function startSingleScreenApp(params) {
+  let screen = params.screen;
+  if (!screen.screen) {
+    console.error('startSingleScreenApp(params): screen must include a screen property');
+    return;
+  }
+
+  addNavigatorParams(screen);
+  addNavigatorButtons(screen);
+  RctActivity.startSingleScreenApp(screen);
+}
+
+function startTabBasedApp(params) {
+  if (!params.tabs) {
+    console.error('startTabBasedApp(params): params.tabs is required');
+    return;
+  }
+
+  params.tabs.forEach(function (tab, idx) {
+    addNavigatorParams(tab, null, idx)
+    addNavigatorButtons(tab);
+  });
+
+  RctActivity.startTabBasedApp(params.tabs);
+}
+
+function navigatorPush(navigator, params) {
+  addNavigatorParams(params, navigator)
+  addNavigatorButtons(params);
+  RctActivity.navigatorPush(params);
+}
+
+function navigatorPop(navigator, params) {
+  RctActivity.navigatorPop(navigator);
+}
+
+function addNavigatorParams(screen, navigator = null, idx = '') {
+  screen.navigatorID = navigator ? navigator.navigatorID : utils.getRandomId() + '_nav' + idx;
+  screen.screenInstanceID = utils.getRandomId();
+  screen.navigatorEventID = navigator ? navigator.navigatorEventID : screen.screenInstanceID + '_events';
+}
+
+function addNavigatorButtons(screen) {
+  const Screen = Navigation.getRegisteredScreen(screen.screen);
+  Object.assign(screen, Screen.navigatorButtons);
+
+  // Get image uri from image id
+  if (screen.rightButtons) {
+    screen.rightButtons.forEach(function(button) {
+      if (button.icon) {
+        const icon = resolveAssetSource(button.icon);
+        if (icon) {
+          button.icon = icon.uri;
+        }
+        console.log('final icon: ' + button.icon);
+      }
+    });
+  }
+}
+
+export default {
+  startSingleScreenApp,
+  startTabBasedApp,
+  navigatorPush,
+  navigatorPop
+}

src/platformSpecific.ios.js

@@ -38,9 +38,8 @@ function startTabBasedApp(params) {
       return (
         <TabBarControllerIOS
           id={controllerID + '_tabs'}
-          style={params.tabsStyle}
-        >
-        {
+          style={params.tabsStyle}>
+          {
           params.tabs.map(function(tab, index) {
             const navigatorID = controllerID + '_nav' + index;
             const screenInstanceID = utils.getRandomId();
@@ -98,8 +97,7 @@ function startSingleScreenApp(params) {
             passPropsLeft={{navigatorID: navigatorID}}
             componentRight={params.drawer.right ? params.drawer.right.screen : undefined}
             passPropsRight={{navigatorID: navigatorID}}
-            disableOpenGesture={params.drawer.disableOpenGesture}
-          >
+            disableOpenGesture={params.drawer.disableOpenGesture}>
             {this.renderBody()}
           </DrawerControllerIOS>
         );