Android fixes (#2583)

Continued work on Android

* Rename TopTabsLayout to TopTabsViewPager
* Pass ScrollEventListener from component
* Change ViewController.view to protected
* Don't keep ref to view in ComponentController
* Pull IReactView and ReactViewCreator to separate classes
* Ensure ToolBar.menu is created before clearing menu items
* Unmount react view before destroy
* Let TopTabsController set mediator in view visibility handling

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarCollapseBehavior.java

         this.animator = new TopBarAnimator(topBar);
     }
 
-    public void enableCollapse() {
-        scrollEventListener.register(topBar, this, this);
+    public void enableCollapse(ScrollEventListener scrollEventListener) {
+        this.scrollEventListener = scrollEventListener;
+        this.scrollEventListener.register(topBar, this, this);
     }
 
     public void disableCollapse() {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/OptionsPresenter.java

         }
 
         if (options.hideOnScroll == True) {
-            topBar.enableCollapse();
+            topBar.enableCollapse(component.getScrollEventListener());
         } else if (options.hideOnScroll == False) {
             topBar.disableCollapse();
         }

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactComponentViewCreator.java

 import android.app.Activity;
 
 import com.facebook.react.ReactInstanceManager;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 
 public class ReactComponentViewCreator implements ReactViewCreator {
 	private ReactInstanceManager reactInstanceManager;
 	}
 
 	@Override
-	public ComponentViewController.IReactView create(final Activity activity, final String componentId, final String componentName) {
+	public IReactView create(final Activity activity, final String componentId, final String componentName) {
 		return new ReactView(activity, reactInstanceManager, componentId, componentName);
 	}
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactView.java

 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 
 @SuppressLint("ViewConstructor")
-public class ReactView extends ReactRootView implements ComponentViewController.IReactView {
+public class ReactView extends ReactRootView implements IReactView {
 
 	private final ReactInstanceManager reactInstanceManager;
 	private final String componentId;

lib/android/app/src/main/java/com/reactnativenavigation/utils/DeviceScreen.java

+package com.reactnativenavigation.utils;
+
+import android.content.res.Resources;
+
+public class DeviceScreen {
+    public static int width(Resources resources) {
+        return resources.getDisplayMetrics().widthPixels;
+    }
+
+    public static int height(Resources resources) {
+        return resources.getDisplayMetrics().heightPixels;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/utils/UiUtils.java

 
 public class UiUtils {
 	public static void runOnPreDrawOnce(final View view, final Runnable task) {
-		view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
-			@Override
-			public boolean onPreDraw() {
-				view.getViewTreeObserver().removeOnPreDrawListener(this);
-				task.run();
-				return true;
-			}
-		});
-	}
+        view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+            @Override
+            public boolean onPreDraw() {
+                view.getViewTreeObserver().removeOnPreDrawListener(this);
+                task.run();
+                return true;
+            }
+        });
+    }
 
 	public static void tintDrawable(Drawable drawable, int tint) {
 		drawable.setColorFilter(new PorterDuffColorFilter(tint, PorterDuff.Mode.SRC_IN));

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ComponentViewController.java

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.*;
-import android.support.annotation.*;
-import android.view.*;
+import android.app.Activity;
+import android.support.annotation.NonNull;
 
-import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.views.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.NavigationOptionsListener;
+import com.reactnativenavigation.views.ComponentLayout;
+import com.reactnativenavigation.views.ReactComponent;
 
-public class ComponentViewController extends ViewController implements NavigationOptionsListener {
-
-    public interface ReactViewCreator {
-
-        IReactView create(Activity activity, String componentId, String componentName);
-    }
-
-    public interface IReactView {
-
-        boolean isReady();
-
-        View asView();
-
-        void destroy();
-
-        void sendComponentStart();
-
-        void sendComponentStop();
-
-        void sendOnNavigationButtonPressed(String buttonId);
-
-        ScrollEventListener getScrollEventListener();
-
-        void dispatchTouchEventToJs(MotionEvent event);
-    }
+public class ComponentViewController extends ViewController<ComponentLayout> implements NavigationOptionsListener {
 
     private final String componentName;
 
     private final ReactViewCreator viewCreator;
-    private ReactComponent component;
 
     public ComponentViewController(final Activity activity,
                                    final String id,
         options = initialNavigationOptions;
     }
 
-    @Override
-    public void destroy() {
-        super.destroy();
-        if (component != null) component.destroy();
-        component = null;
-    }
-
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();
-        ensureViewIsCreated();
-        component.applyOptions(options);
-        applyOnParentController(parentController -> {
-            parentController.clearOptions();
-            parentController.applyOptions(options, component);
-        });
-        component.sendComponentStart();
+        view.applyOptions(options);
+        view.sendComponentStart();
     }
 
     @Override
     public void onViewDisappear() {
+        view.sendComponentStop();
         super.onViewDisappear();
-        component.sendComponentStop();
     }
 
     @Override
     protected boolean isViewShown() {
-        return super.isViewShown() && component.isReady();
+        return super.isViewShown() && view.isReady();
     }
 
     @NonNull
     @Override
-    protected View createView() {
-        component = (ReactComponent) viewCreator.create(getActivity(), getId(), componentName);
-        return component.asView();
+    protected ComponentLayout createView() {
+        view = (ComponentLayout) viewCreator.create(getActivity(), getId(), componentName);
+        return (ComponentLayout) view.asView();
     }
 
     @Override
     public void mergeOptions(Options options) {
         this.options.mergeWith(options);
-        component.applyOptions(this.options);
-        applyOnParentController(parentController -> parentController.applyOptions(this.options, component));
+        view.applyOptions(this.options);
+        applyOnParentController(parentController -> parentController.applyOptions(this.options, view));
     }
 
     Options getOptions() {
     }
 
     ReactComponent getComponent() {
-        return component;
+        return view;
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Destroyable.java

+package com.reactnativenavigation.viewcontrollers;
+
+public interface Destroyable {
+    void destroy();
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/IReactView.java

+package com.reactnativenavigation.viewcontrollers;
+
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+
+public interface IReactView extends Destroyable {
+
+    boolean isReady();
+
+    View asView();
+
+    void sendComponentStart();
+
+    void sendComponentStop();
+
+    void sendOnNavigationButtonPressed(String buttonId);
+
+    ScrollEventListener getScrollEventListener();
+
+    void dispatchTouchEventToJs(MotionEvent event);
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

 	public void push(final String fromId, final ViewController viewController, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
-		    from.performOnParentStack(stack -> stack.animatePush(viewController, promise));
+		    from.performOnParentStack(stack -> ((StackController) stack).animatePush(viewController, promise));
 		}
 	}
 
 	void pop(final String fromId, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
-		    from.performOnParentStack(stack -> stack.pop(promise));
+		    from.performOnParentStack(stack -> ((StackController) stack).pop(promise));
 		}
 	}
 
 	public void popSpecific(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
-		    from.performOnParentStack(stack -> stack.popSpecific(from, promise), () -> rejectPromise(promise));
+		    from.performOnParentStack(stack -> ((StackController) stack).popSpecific(from, promise), () -> rejectPromise(promise));
 		} else {
 			rejectPromise(promise);
 		}
 	public void popToRoot(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
-		    from.performOnParentStack(stack -> stack.popToRoot(promise));
+		    from.performOnParentStack(stack -> ((StackController) stack).popToRoot(promise));
 		}
 	}
 
 	public void popTo(final String componentId, Promise promise) {
 		ViewController target = findControllerById(componentId);
 		if (target != null) {
-		    target.performOnParentStack(stack -> stack.popTo(target, promise), () -> rejectPromise(promise));
+		    target.performOnParentStack(stack -> ((StackController) stack).popTo(target, promise), () -> rejectPromise(promise));
 		} else {
 			rejectPromise(promise);
 		}
 	}
 
 	public void showOverlay(ViewController overlay) {
-        overlayManager.show((ViewGroup) root.getView(), overlay);
+        overlayManager.show(root.getView(), overlay);
 	}
 
 	public void dismissOverlay(final String componentId) {
-		overlayManager.dismiss((ViewGroup) root.getView(), componentId);
+		overlayManager.dismiss(root.getView(), componentId);
 	}
 
 	static void rejectPromise(Promise promise) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ReactViewCreator.java

+package com.reactnativenavigation.viewcontrollers;
+
+import android.app.Activity;
+
+public interface ReactViewCreator {
+
+    IReactView create(Activity activity, String componentId, String componentName);
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.StringUtils;
 import com.reactnativenavigation.utils.Task;
+import com.reactnativenavigation.views.ReactComponent;
 
-public abstract class ViewController implements ViewTreeObserver.OnGlobalLayoutListener {
+public abstract class ViewController<T extends ViewGroup> implements ViewTreeObserver.OnGlobalLayoutListener {
+
+    public interface ViewVisibilityListener {
+        /**
+         * @return true if the event is consumed, false otherwise
+         */
+        boolean onViewAppeared(View view);
+
+        /**
+         * @return true if the event is consumed, false otherwise
+         */
+        boolean onViewDisappear(View view);
+    }
 
     public Options options;
 
-	private final Activity activity;
-	private final String id;
-	private View view;
-	private ParentController parentController;
-	private boolean isShown = false;
+    private final Activity activity;
+    private final String id;
+    protected T view;
+    @Nullable private ParentController<T> parentController;
+    private boolean isShown;
     private boolean isDestroyed;
+    private ViewVisibilityListener viewVisibilityListener = new ViewVisibilityListenerAdapter();
+
+    public ViewController(Activity activity, String id) {
+        this.activity = activity;
+        this.id = id;
+    }
 
-	public ViewController(Activity activity, String id) {
-		this.activity = activity;
-		this.id = id;
-	}
+    protected abstract T createView();
 
-	protected abstract View createView();
+    public void setViewVisibilityListener(ViewVisibilityListener viewVisibilityListener) {
+        this.viewVisibilityListener = viewVisibilityListener;
+    }
 
-	@SuppressWarnings("WeakerAccess")
+    @SuppressWarnings("WeakerAccess")
     @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
-	public void ensureViewIsCreated() {
-		getView();
-	}
+    public void ensureViewIsCreated() {
+        getView();
+    }
 
-	public boolean handleBack() {
-		return false;
-	}
+    public boolean handleBack() {
+        return false;
+    }
 
     public void applyOptions(Options options) {
 
     }
 
-	public Activity getActivity() {
-		return activity;
-	}
+    public Activity getActivity() {
+        return activity;
+    }
 
-	protected void applyOnParentController(Task<ParentController> task) {
-        if (parentController != null) {
-            task.run(parentController);
-        }
+    protected void applyOnParentController(Task<ParentController> task) {
+        if (parentController != null) task.run(parentController);
     }
 
-	@Nullable
-    ParentController getParentStackController() {
-		return parentController;
-	}
+    @Nullable
+    ParentController getParentController() {
+        return parentController;
+    }
 
-	public void setParentController(final ParentController parentController) {
-		this.parentController = parentController;
-	}
+    public void setParentController(@NonNull final ParentController parentController) {
+        this.parentController = parentController;
+    }
 
     boolean performOnParentStack(Task<StackController> task) {
-	    if (parentController instanceof StackController) {
+        if (parentController instanceof StackController) {
             task.run((StackController) parentController);
             return true;
         }
         if (this instanceof StackController) {
-	        task.run((StackController) this);
+            task.run((StackController) this);
             return true;
         }
         return false;
     }
 
-    void performOnParentStack(Task<StackController> accept, Runnable  reject) {
+    void performOnParentStack(Task accept, Runnable reject) {
         if (!performOnParentStack(accept)) {
             reject.run();
         }
     }
 
-	@NonNull
-	public View getView() {
-		if (view == null) {
-		    if (isDestroyed) throw new RuntimeException("Tried to create view after it has already been destroyed");
+    @NonNull
+    public T getView() {
+        if (view == null) {
+            if (isDestroyed) {
+                throw new RuntimeException("Tried to create view after it has already been destroyed");
+            }
             view = createView();
-			view.setId(CompatUtils.generateViewId());
-			view.getViewTreeObserver().addOnGlobalLayoutListener(this);
-		}
-		return view;
-	}
-
-	public String getId() {
-		return id;
-	}
-
-	boolean isSameId(final String id) {
-		return StringUtils.isEqual(this.id, id);
-	}
-
-	@Nullable
-	public ViewController findControllerById(String id) {
-		return isSameId(id) ? this : null;
-	}
-
-	public void onViewAppeared() {
+            view.setId(CompatUtils.generateViewId());
+            view.getViewTreeObserver().addOnGlobalLayoutListener(this);
+        }
+        return view;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    boolean isSameId(final String id) {
+        return StringUtils.isEqual(this.id, id);
+    }
+
+    @Nullable
+    public ViewController findControllerById(String id) {
+        return isSameId(id) ? this : null;
+    }
+
+    public void onViewAppeared() {
         isShown = true;
+        applyOnParentController(parentController -> {
+            parentController.clearOptions();
+            parentController.applyOptions(options, (ReactComponent) getView());
+        });
     }
 
-	public void onViewDisappear() {
+    public void onViewDisappear() {
         isShown = false;
     }
 
-	public void destroy() {
-		if (isShown) {
-			isShown = false;
-			onViewDisappear();
-		}
-		if (view != null) {
-			view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
-			if (view.getParent() instanceof ViewGroup) {
-				((ViewManager) view.getParent()).removeView(view);
-			}
-			view = null;
+    public void destroy() {
+        if (isShown) {
+            isShown = false;
+            onViewDisappear();
+            if (view instanceof Destroyable) {
+                ((Destroyable) view).destroy();
+            }
+        }
+        if (view != null) {
+            view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+            if (view.getParent() instanceof ViewGroup) {
+                ((ViewManager) view.getParent()).removeView(view);
+            }
+            view = null;
             isDestroyed = true;
-		}
-	}
-
-	@Override
-	public void onGlobalLayout() {
-		if (!isShown && isViewShown()) {
-			isShown = true;
-			onViewAppeared();
-		} else if (isShown && !isViewShown()) {
-			isShown = false;
-			onViewDisappear();
-		}
-	}
-
-	protected boolean isViewShown() {
+        }
+    }
+
+    @Override
+    public void onGlobalLayout() {
+        if (!isShown && isViewShown()) {
+            if (!viewVisibilityListener.onViewAppeared(view)) {
+                isShown = true;
+                onViewAppeared();
+            }
+        } else if (isShown && !isViewShown()) {
+            if (!viewVisibilityListener.onViewDisappear(view)) {
+                isShown = false;
+                onViewDisappear();
+            }
+        }
+    }
+
+    protected boolean isViewShown() {
         return !isDestroyed && getView().isShown();
-	}
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewVisibilityListenerAdapter.java

+package com.reactnativenavigation.viewcontrollers;
+
+import android.view.View;
+
+public class ViewVisibilityListenerAdapter implements ViewController.ViewVisibilityListener {
+    @Override
+    public boolean onViewAppeared(View view) {
+        return false;
+    }
+
+    @Override
+    public boolean onViewDisappear(View view) {
+        return false;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/overlay/DialogViewController.java

-package com.reactnativenavigation.viewcontrollers.overlay;
-
-import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.view.View;
-
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.ViewController;
-
-
-public class DialogViewController extends ViewController {
-
-	private ComponentViewController.ReactViewCreator viewCreator;
-	private String componentName;
-
-	public DialogViewController(Activity activity, String id, String componentName, ComponentViewController.ReactViewCreator viewCreator) {
-		super(activity, id);
-		this.viewCreator = viewCreator;
-		this.componentName = componentName;
-	}
-
-	@NonNull
-	@Override
-	protected View createView() {
-		return viewCreator.create(getActivity(), getId(), componentName).asView();
-	}
-}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabController.java

-package com.reactnativenavigation.viewcontrollers.toptabs;
-
-import android.app.Activity;
-import android.view.View;
-
-import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.NavigationOptionsListener;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.views.TopTab;
-
-public class TopTabController extends ViewController implements NavigationOptionsListener {
-
-    private final String componentName;
-    private ComponentViewController.ReactViewCreator viewCreator;
-    private TopTab topTab;
-    private boolean isSelectedTab;
-
-    public TopTabController(Activity activity, String id, String name, ComponentViewController.ReactViewCreator viewCreator, Options initialOptions) {
-        super(activity, id);
-        this.componentName = name;
-        this.viewCreator = viewCreator;
-        this.options = initialOptions;
-    }
-
-    @Override
-    public void onViewAppeared() {
-        super.onViewAppeared();
-        isSelectedTab = true;
-        applyOptions(options);
-        topTab.sendComponentStart();
-    }
-
-    @Override
-    public void applyOptions(Options options) {
-        applyOnParentController(parentController -> parentController.applyOptions(options));
-    }
-
-    @Override
-    public void onViewDisappear() {
-        super.onViewDisappear();
-        isSelectedTab = false;
-        topTab.sendComponentStop();
-    }
-
-    @Override
-    protected boolean isViewShown() {
-        return super.isViewShown() && isSelectedTab;
-    }
-
-    @Override
-    public View createView() {
-        topTab = new TopTab(
-                getActivity(),
-                viewCreator.create(getActivity(), getId(), componentName)
-        );
-        return topTab;
-    }
-
-    @Override
-    public void destroy() {
-        super.destroy();
-        if (topTab != null) topTab.destroy();
-        topTab = null;
-    }
-
-    @Override
-    public void mergeOptions(Options options) {
-        this.options.mergeWith(options);
-        applyOptions(this.options);
-    }
-
-    String getTabTitle() {
-        return options.topTabOptions.title.get("");
-    }
-
-    public void setTabIndex(int i) {
-        options.topTabOptions.tabIndex = i;
-    }
-}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

 
 import android.app.Activity;
 import android.support.annotation.NonNull;
-import android.support.v4.view.ViewPager;
-import android.view.ViewGroup;
+import android.view.View;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.utils.Task;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.views.TopTabsLayout;
+import com.reactnativenavigation.viewcontrollers.ViewVisibilityListenerAdapter;
+import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.TopTabsLayoutCreator;
+import com.reactnativenavigation.views.TopTabsViewPager;
 
 import java.util.Collection;
 import java.util.List;
 
-public class TopTabsController extends ParentController implements NavigationOptionsListener {
+public class TopTabsController extends ParentController<TopTabsViewPager> implements NavigationOptionsListener {
 
     private List<ViewController> tabs;
-    private TopTabsLayout topTabsLayout;
     private TopTabsLayoutCreator viewCreator;
     private Options options;
 
         this.tabs = tabs;
         for (ViewController tab : tabs) {
             tab.setParentController(this);
+            tab.setViewVisibilityListener(new ViewVisibilityListenerAdapter() {
+                @Override
+                public boolean onViewAppeared(View view) {
+                    return getView().isCurrentView(view);
+                }
+            });
         }
     }
 
     @NonNull
     @Override
-    protected ViewGroup createView() {
-        topTabsLayout = viewCreator.create();
-        return topTabsLayout;
+    protected TopTabsViewPager createView() {
+        view = viewCreator.create();
+        return (TopTabsViewPager) view;
     }
 
     @NonNull
     @Override
     public void onViewAppeared() {
         applyOptions(options);
-        applyOnParentController(parentController -> parentController.setupTopTabsWithViewPager((ViewPager) getView()));
+        applyOnParentController(parentController -> ((ParentController) parentController).setupTopTabsWithViewPager(getView()));
         performOnCurrentTab(ViewController::onViewAppeared);
     }
 
 
     @Override
     public void applyOptions(Options options) {
-        topTabsLayout.applyOptions(options);
+        getView().applyOptions(options);
+    }
+
+    @Override
+    public void applyOptions(Options options, ReactComponent childComponent) {
+        applyOnParentController(parentController -> ((ParentController) parentController).applyOptions(options, childComponent));
     }
 
     @Override
     }
 
     public void switchToTab(int index) {
-        topTabsLayout.switchToTab(index);
+        getView().switchToTab(index);
     }
 
     private void performOnCurrentTab(Task<ViewController> task) {
-        task.run(tabs.get(topTabsLayout.getCurrentItem()));
+        task.run(tabs.get(getView().getCurrentItem()));
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentLayout.java

 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.views.touch.OverlayTouchDelegate;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 
     @Override
     public void drawBehindTopBar() {
-        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) reactView.asView().getLayoutParams();
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
         layoutParams.removeRule(BELOW);
         reactView.asView().setLayoutParams(layoutParams);
     }
 
     @Override
     public void drawBelowTopBar(TopBar topBar) {
-        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) reactView.asView().getLayoutParams();
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
         layoutParams.addRule(BELOW, topBar.getId());
         reactView.asView().setLayoutParams(layoutParams);
     }

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentViewCreator.java

 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.react.ReactComponentViewCreator;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.IReactView;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 
-public class ComponentViewCreator implements ComponentViewController.ReactViewCreator {
+public class ComponentViewCreator implements ReactViewCreator {
 
     private ReactInstanceManager instanceManager;
 
 	}
 
 	@Override
-	public ComponentViewController.IReactView create(Activity activity, String componentId, String componentName) {
-        ComponentViewController.IReactView reactView = new ReactComponentViewCreator(instanceManager).create(activity, componentId, componentName);
+	public IReactView create(Activity activity, String componentId, String componentName) {
+        IReactView reactView = new ReactComponentViewCreator(instanceManager).create(activity, componentId, componentName);
         return new ComponentLayout(activity, reactView);
 	}
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/ReactComponent.java

 package com.reactnativenavigation.views;
 
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 
-public interface ReactComponent extends Component, ComponentViewController.IReactView {
+public interface ReactComponent extends Component, IReactView {
 }

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

         this.onClickListener = onClickListener;
         collapsingBehavior = new TopBarCollapseBehavior(this);
         titleBar = new Toolbar(context);
+        titleBar.getMenu();
         topTabs = new TopTabs(getContext());
         this.animator = new TopBarAnimator(this);
         addView(titleBar);
         addView(topTabs);
     }
 
-    public void enableCollapse() {
-        collapsingBehavior.enableCollapse();
+    public void enableCollapse(ScrollEventListener scrollEventListener) {
+        collapsingBehavior.enableCollapse(scrollEventListener);
     }
 
     public void disableCollapse() {
         titleBar.setTitle(null);
         titleBar.setNavigationIcon(null);
         titleBar.getMenu().clear();
+        removeView(topTabs);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/TopTab.java

-package com.reactnativenavigation.views;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.view.MotionEvent;
-import android.view.View;
-import android.widget.FrameLayout;
-
-import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
-
-@SuppressLint("ViewConstructor")
-public class TopTab extends FrameLayout implements IReactView {
-
-	private final IReactView reactView;
-
-	public TopTab(Context context, IReactView reactView) {
-		super(context);
-		this.reactView = reactView;
-        addView(reactView.asView());
-	}
-
-	@Override
-	public boolean isReady() {
-		return reactView.isReady();
-	}
-
-	@Override
-	public View asView() {
-		return this;
-	}
-
-	@Override
-	public void destroy() {
-		reactView.destroy();
-	}
-
-	@Override
-	public void sendComponentStart() {
-		reactView.sendComponentStart();
-	}
-
-	@Override
-	public void sendComponentStop() {
-		reactView.sendComponentStop();
-	}
-
-    @Override
-    public void sendOnNavigationButtonPressed(String buttonId) {
-        reactView.sendOnNavigationButtonPressed(buttonId);
-    }
-
-    @Override
-    public ScrollEventListener getScrollEventListener() {
-        return reactView.getScrollEventListener();
-    }
-
-    @Override
-    public void dispatchTouchEventToJs(MotionEvent event) {
-        reactView.dispatchTouchEventToJs(event);
-    }
-}

lib/android/app/src/main/java/com/reactnativenavigation/views/TopTabCreator.java

-package com.reactnativenavigation.views;
-
-import android.app.Activity;
-
-import com.facebook.react.ReactInstanceManager;
-import com.reactnativenavigation.react.ReactComponentViewCreator;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-
-public class TopTabCreator implements ComponentViewController.ReactViewCreator {
-
-
-    private ReactInstanceManager instanceManager;
-
-    public TopTabCreator(ReactInstanceManager instanceManager) {
-        this.instanceManager = instanceManager;
-    }
-
-	@Override
-	public ComponentViewController.IReactView create(Activity activity, String componentId, String componentName) {
-        ComponentViewController.IReactView reactView = new ReactComponentViewCreator(instanceManager).create(activity, componentId, componentName);
-        return new TopTab(activity, reactView);
-	}
-}

lib/android/app/src/main/java/com/reactnativenavigation/views/TopTabsLayoutCreator.java

         this.tabs = tabs;
     }
 
-    public TopTabsLayout create() {
-        return new TopTabsLayout(context, tabs, new TopTabsAdapter(tabs));
+    public TopTabsViewPager create() {
+        return new TopTabsViewPager(context, tabs, new TopTabsAdapter(tabs));
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/TopTabsLayout.java → lib/android/app/src/main/java/com/reactnativenavigation/views/TopTabsViewPager.java

 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.support.v4.view.ViewPager;
+import android.view.View;
 import android.view.ViewGroup;
 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
 
 import static android.widget.RelativeLayout.BELOW;
 
 @SuppressLint("ViewConstructor")
-public class TopTabsLayout extends ViewPager implements Component, TitleBarButton.OnClickListener {
+public class TopTabsViewPager extends ViewPager implements Component, TitleBarButton.OnClickListener {
 
     private static final int OFFSCREEN_PAGE_LIMIT = 99;
     private List<ViewController> tabs;
 
-    public TopTabsLayout(Context context, List<ViewController> tabs, TopTabsAdapter adapter) {
+    public TopTabsViewPager(Context context, List<ViewController> tabs, TopTabsAdapter adapter) {
         super(context);
         this.tabs = tabs;
         initTabs(adapter);
             tab.destroy();
         }
     }
+
+    public boolean isCurrentView(View view) {
+        for (ViewController tab : tabs) {
+            if (tab.getView() == view) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/touch/OverlayTouchDelegate.java

 import android.view.MotionEvent;
 import android.view.ViewGroup;
 
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 
 public class OverlayTouchDelegate {
     private final Rect hitRect = new Rect();

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleComponentViewController.java

 import com.reactnativenavigation.viewcontrollers.*;
 
 public class SimpleComponentViewController extends ComponentViewController {
-    public SimpleComponentViewController(final Activity activity, final String id) {
-        super(activity, id, "theComponentName", new TestComponentViewCreator(), new Options());
+    public SimpleComponentViewController(final Activity activity, final String id, Options initialOptions) {
+        super(activity, id, "theComponentName", new TestComponentViewCreator(), initialOptions);
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleOverlay.java

 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.IReactView;
 
-public class SimpleOverlay extends RelativeLayout implements ComponentViewController.IReactView {
+public class SimpleOverlay extends RelativeLayout implements IReactView {
     public SimpleOverlay(Context context) {
         super(context);
     }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleViewController.java

 package com.reactnativenavigation.mocks;
 
-import android.app.*;
-import android.view.*;
+import android.app.Activity;
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
 
-import com.reactnativenavigation.viewcontrollers.*;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.TopBar;
 
-public class SimpleViewController extends ViewController {
+public class SimpleViewController extends ViewController<FrameLayout> {
 
     public SimpleViewController(final Activity activity, String id) {
         super(activity, id);
+        options = new Options();
     }
 
     @Override
-    protected View createView() {
-        return new View(getActivity());
+    protected FrameLayout createView() {
+        return new SimpleView(getActivity());
     }
 
     @Override
     public String toString() {
         return "SimpleViewController " + getId();
     }
+
+    public class SimpleView extends FrameLayout implements ReactComponent {
+
+        public SimpleView(@NonNull Context context) {
+            super(context);
+        }
+
+        @Override
+        public void applyOptions(Options options) {
+
+        }
+
+        @Override
+        public void drawBehindTopBar() {
+
+        }
+
+        @Override
+        public void drawBelowTopBar(TopBar topBar) {
+
+        }
+
+        @Override
+        public boolean isReady() {
+            return false;
+        }
+
+        @Override
+        public View asView() {
+            return null;
+        }
+
+        @Override
+        public void destroy() {
+
+        }
+
+        @Override
+        public void sendComponentStart() {
+
+        }
+
+        @Override
+        public void sendComponentStop() {
+
+        }
+
+        @Override
+        public void sendOnNavigationButtonPressed(String buttonId) {
+
+        }
+
+        @Override
+        public ScrollEventListener getScrollEventListener() {
+            return null;
+        }
+
+        @Override
+        public void dispatchTouchEventToJs(MotionEvent event) {
+
+        }
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentLayout.java

 import android.content.Context;
 import android.view.MotionEvent;
 import android.view.View;
-import android.view.ViewGroup;
-import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.viewcontrollers.IReactView;
+import com.reactnativenavigation.views.ComponentLayout;
 import com.reactnativenavigation.views.TitleBarButton;
-import com.reactnativenavigation.views.TopBar;
 
-public class TestComponentLayout extends RelativeLayout implements ReactComponent, TitleBarButton.OnClickListener {
+public class TestComponentLayout extends ComponentLayout implements TitleBarButton.OnClickListener {
 
-    private final View contentView;
+    private IReactView reactView;
 
-    public TestComponentLayout(final Context context) {
-        super(context);
-        contentView = new View(context);
-        addView(contentView);
+    public TestComponentLayout(final Context context, IReactView reactView) {
+        super(context, reactView);
+        this.reactView = reactView;
     }
 
-    @Override
-    public void drawBehindTopBar() {
-        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
-        layoutParams.removeRule(BELOW);
-        contentView.setLayoutParams(layoutParams);
-    }
-
-    @Override
-    public void drawBelowTopBar(TopBar topBar) {
-        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
-        layoutParams.addRule(BELOW, topBar.getId());
-        contentView.setLayoutParams(layoutParams);
-    }
 
     @Override
     public boolean isReady() {
 
     @Override
     public void sendComponentStart() {
+        reactView.sendComponentStart();
     }
 
     @Override
     public void sendComponentStop() {
+        reactView.sendComponentStop();
     }
 
     @Override

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentViewCreator.java

 package com.reactnativenavigation.mocks;
 
-import android.app.*;
+import android.app.Activity;
 
-import com.reactnativenavigation.viewcontrollers.*;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.*;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.IReactView;
+import com.reactnativenavigation.views.ComponentLayout;
+import com.reactnativenavigation.views.ReactComponent;
+
+import static org.mockito.Mockito.spy;
 
 public class TestComponentViewCreator implements ReactViewCreator {
     @Override
-    public ComponentViewController.IReactView create(final Activity activity, final String componentId, final String componentName) {
-        return new TestComponentLayout(activity);
+    public ReactComponent create(final Activity activity, final String componentId, final String componentName) {
+        IReactView reactView = spy(new TestReactView(activity));
+        return new ComponentLayout(activity, reactView);
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestReactView.java

+package com.reactnativenavigation.mocks;
+
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+import com.reactnativenavigation.viewcontrollers.IReactView;
+
+public class TestReactView extends FrameLayout implements IReactView {
+
+    public TestReactView(@NonNull Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean isReady() {
+        return false;
+    }
+
+    @Override
+    public View asView() {
+        return this;
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+
+    @Override
+    public void sendComponentStart() {
+
+    }
+
+    @Override
+    public void sendComponentStop() {
+
+    }
+
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+
+    }
+
+    @Override
+    public ScrollEventListener getScrollEventListener() {
+        return null;
+    }
+
+    @Override
+    public void dispatchTouchEventToJs(MotionEvent event) {
+
+    }
+}

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TopTabLayoutMock.java

 import android.view.*;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.viewcontrollers.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.TopBar;
 
-public class TopTabLayoutMock extends View implements ComponentViewController.IReactView {
+public class TopTabLayoutMock extends View implements ReactComponent {
 
     public TopTabLayoutMock(Context context) {
         super(context);
     public void dispatchTouchEventToJs(MotionEvent event) {
 
     }
+
+    @Override
+    public void applyOptions(Options options) {
+
+    }
+
+    @Override
+    public void drawBehindTopBar() {
+
+    }
+
+    @Override
+    public void drawBelowTopBar(TopBar topBar) {
+
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ComponentViewControllerTest.java

 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.mocks.TestComponentLayout;
+import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.views.StackLayout;
 
 
 public class ComponentViewControllerTest extends BaseTest {
     private ComponentViewController uut;
-    private ParentController<StackLayout> parentController;
-    private ComponentViewController.IReactView view;
+    private IReactView view;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
         Activity activity = newActivity();
-        view = spy(new TestComponentLayout(activity));
-        parentController = new StackController(activity, "stack");
+        view = spy(new TestComponentLayout(activity, new TestReactView(activity)));
+        ParentController<StackLayout> parentController = new StackController(activity, "stack");
         uut = new ComponentViewController(activity, "componentId1", "componentName", (activity1, componentId, componentName) -> view, new Options());
         uut.setParentController(parentController);
         parentController.ensureViewIsCreated();
     public void componentViewDestroyedOnDestroy() throws Exception {
         uut.ensureViewIsCreated();
         verify(view, times(0)).destroy();
+        uut.onViewAppeared();
         uut.destroy();
         verify(view, times(1)).destroy();
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/NavigatorTest.java

 
     @Test
     public void setOptions_CallsApplyNavigationOptions() {
-        ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId");
+        ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId", new Options());
         componentVc.setParentController(parentController);
         assertThat(componentVc.getOptions().topBarOptions.title.get("")).isEmpty();
         uut.setRoot(componentVc, new MockPromise());

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsApplyingTest.java

 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.TestComponentLayout;
+import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.parse.Fraction;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.Text;
 
 import javax.annotation.Nullable;
 
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.widget.RelativeLayout.BELOW;
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.Mockito.spy;
     private Activity activity;
     private StackController stackController;
     private ComponentViewController uut;
-    private ComponentViewController.IReactView view;
+    private IReactView view;
     private Options initialNavigationOptions;
 
     @Override
         super.beforeEach();
         activity = newActivity();
         initialNavigationOptions = new Options();
-        view = spy(new TestComponentLayout(activity));
+        view = spy(new TestComponentLayout(activity, new TestReactView(activity)));
+        view.asView().setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
         uut = new ComponentViewController(activity,
                 "componentId1",
                 "componentName",
     @Test
     public void applyNavigationOptionsHandlesNoParentStack() throws Exception {
         uut.setParentController(null);
-        assertThat(uut.getParentStackController()).isNull();
+        assertThat(uut.getParentController()).isNull();
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
-        assertThat(uut.getParentStackController()).isNull();
+        assertThat(uut.getParentController()).isNull();
     }
 
     @Test
 
     @Test
     public void reappliesOptionsOnMerge() throws Exception {
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
 
     @Test
     public void appliesTopBackBackgroundColor() throws Exception {
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
 
         Options opts = new Options();
     public void appliesTopBarTextSize() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title = new Text("the title");
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
 
         Options opts = new Options();
     public void appliesTopBarHidden() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title = new Text("the title");
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
         assertThat(stackController.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
 
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title = new Text("the title");
         initialNavigationOptions.topBarOptions.drawBehind = Options.BooleanOptions.False;
+        uut.ensureViewIsCreated();
         uut.onViewAppeared();
         stackController.animatePush(uut, new MockPromise() {
             @Override

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ParentControllerTest.java

         uut.destroy();
         verify(child1, times(1)).destroy();
     }
+
+    @Test
+    public void optionsAreClearedWhenChildIsAppeared() throws Exception {
+        StackController stackController = spy(new StackController(activity, "stack"));
+        SimpleViewController child1 = new SimpleViewController(activity, "child1");
+        stackController.animatePush(child1, new MockPromise());
+
+        child1.onViewAppeared();
+        verify(stackController, times(1)).clearOptions();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackControllerTest.java

 
     @Test
     public void pushAssignsRefToSelfOnPushedController() throws Exception {
-        assertThat(child1.getParentStackController()).isNull();
+        assertThat(child1.getParentController()).isNull();
         uut.animatePush(child1, new MockPromise());
-        assertThat(child1.getParentStackController()).isEqualTo(uut);
+        assertThat(child1.getParentController()).isEqualTo(uut);
 
         StackController anotherNavController = new StackController(activity, "another");
         anotherNavController.animatePush(child2, new MockPromise());
-        assertThat(child2.getParentStackController()).isEqualTo(anotherNavController);
+        assertThat(child2.getParentController()).isEqualTo(anotherNavController);
     }
 
     @Test

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopTabControllerTest.java

-package com.reactnativenavigation.viewcontrollers;
-
-import android.app.*;
-
-import com.reactnativenavigation.*;
-import com.reactnativenavigation.mocks.*;
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.viewcontrollers.toptabs.*;
-
-import org.junit.*;
-
-import static org.mockito.Mockito.*;
-
-public class TopTabControllerTest extends BaseTest {
-    private TopTabController uut;
-    private TopTabLayoutMock view;
-    private ParentController parentController;
-    private Options initialOptions;
-
-    @Override
-    public void beforeEach() {
-        super.beforeEach();
-        Activity activity = newActivity();
-        view = spy(new TopTabLayoutMock(activity));
-        initialOptions = new Options();
-        uut = new TopTabController(activity,
-                "componentId",
-                "componentName",
-                (activity1, componentId, componentName) -> view,
-                initialOptions
-        );
-        parentController = spy(new TopTabsControllerMock(activity, "parentComponentId"));
-        uut.setParentController(parentController);
-    }
-
-    @Test
-    public void styleIsAppliedOnParentControllerWhenTabIsVisible() throws Exception {
-        uut.ensureViewIsCreated();
-        uut.onViewAppeared();
-        verify(parentController, times(1)).applyOptions(initialOptions);
-    }
-
-    @Test
-    public void styleIsAppliedOnParentControllerWhenOptionsAreSetDynamically() throws Exception {
-        uut.ensureViewIsCreated();
-        uut.onViewAppeared();
-        uut.mergeOptions(new Options());
-        verify(parentController, times(2)).applyOptions(initialOptions);
-    }
-
-}

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopTabsViewControllerTest.java

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.*;
-import android.view.*;
-
-import com.reactnativenavigation.*;
-import com.reactnativenavigation.mocks.*;
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.*;
-import com.reactnativenavigation.viewcontrollers.toptabs.*;
-import com.reactnativenavigation.views.*;
-
-import org.junit.*;
-import org.mockito.*;
-
-import java.util.*;
-
-import static org.mockito.Mockito.*;
+import android.app.Activity;
+import android.support.annotation.NonNull;
+import android.view.ViewGroup;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.TestComponentViewCreator;
+import com.reactnativenavigation.mocks.TestReactView;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.Text;
+import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
+import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
+import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.TopTabsLayoutCreator;
+import com.reactnativenavigation.views.TopTabsViewPager;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 public class TopTabsViewControllerTest extends BaseTest {
 
     private static final int SIZE = 2;
 
+    private StackController parentController;
     private TopTabsController uut;
-    private List<TopTabLayoutMock> tabs = new ArrayList<>(SIZE);
     private List<ViewController> tabControllers = new ArrayList<>(SIZE);
     private List<Options> tabOptions = new ArrayList<>(SIZE);
-    private Options options;
-    private TopTabsLayout topTabsLayout;
+    private final Options options = new Options();
+    private TopTabsViewPager topTabsLayout;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
-        tabControllers.clear();
-        tabs.clear();
-        Activity activity = newActivity();
-        tabControllers = createTabs(activity);
-        options = new Options();
-        topTabsLayout = spy(new TopTabsLayout(activity, tabControllers, new TopTabsAdapter(tabControllers)));
 
+        final Activity activity = newActivity();
+        tabOptions = createOptions();
+        tabControllers = createTabsControllers(activity);
+
+        topTabsLayout = spy(new TopTabsViewPager(activity, tabControllers, new TopTabsAdapter(tabControllers)));
         TopTabsLayoutCreator layoutCreator = Mockito.mock(TopTabsLayoutCreator.class);
         Mockito.when(layoutCreator.create()).thenReturn(topTabsLayout);
-        uut = new TopTabsController(activity, "componentId", tabControllers, layoutCreator, options);
+        uut = spy(new TopTabsController(activity, "componentId", tabControllers, layoutCreator, options));
+        tabControllers.forEach(viewController -> viewController.setParentController(uut));
+
+        parentController = spy(new StackController(activity, "stackId"));
+        uut.setParentController(parentController);
     }
 
-    private List<ViewController> createTabs(Activity activity) {
-        List<ViewController> result = new ArrayList<>(SIZE);
-        tabOptions = new ArrayList<>();
+    @NonNull
+    private ArrayList<Options> createOptions() {
+        ArrayList result = new ArrayList();
         for (int i = 0; i < SIZE; i++) {
-            TopTabLayoutMock reactView = spy(new TopTabLayoutMock(activity));
-            tabs.add(reactView);
-            Options options = new Options();
+            final Options options = new Options();
             options.topTabOptions.title = new Text("Tab " + i);
-            tabOptions.add(options);
-            result.add(spy(new TopTabController(activity,
-                    "idTab" + i,
-                    "tab" + i,
-                    (activity1, componentId, componentName) -> reactView,
-                    options)
-            ));
+            options.topBarOptions.title = new Text("Title " + i);
+            result.add(options);
         }
         return result;
     }
 
+    private List<ViewController> createTabsControllers(Activity activity) {
+        List<ViewController> tabControllers = new ArrayList<>(SIZE);
+        for (int i = 0; i < SIZE; i++) {
+            ComponentViewController viewController = new ComponentViewController(
+                    activity,
+                    "idTab" + i,
+                    "theComponentName",
+                    new TestComponentViewCreator(),
+                    tabOptions.get(i)
+            );
+            tabControllers.add(spy(viewController));
+        }
+        return tabControllers;
+    }
+
+    private ReactComponent tabView(int index) {
+        return (ReactComponent) tabControllers.get(index).getView();
+    }
+
     @Test
     public void createsViewFromComponentViewCreator() throws Exception {
         uut.ensureViewIsCreated();
     @Test
     public void componentViewDestroyedOnDestroy() throws Exception {
         uut.ensureViewIsCreated();
-        TopTabsLayout topTabs = (TopTabsLayout) uut.getView();
+        TopTabsViewPager topTabs = uut.getView();
         for (int i = 0; i < SIZE; i++) {
             verify(tab(topTabs, i), times(0)).destroy();
         }
 
     @Test
     public void lifecycleMethodsSentWhenSelectedTabChanges() throws Exception {
+        parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
-        TopTabLayoutMock initialTab = tabs.get(0);
-        TopTabLayoutMock selectedTab = tabs.get(1);
+        tabControllers.get(0).ensureViewIsCreated();
+        tabControllers.get(1).ensureViewIsCreated();
+
+        tabControllers.get(0).onViewAppeared();
+
         uut.onViewAppeared();
+
+        TestReactView initialTab = getActualTabView(0);
+        TestReactView selectedTab = getActualTabView(1);
+
         uut.switchToTab(1);
         verify(initialTab, times(1)).sendComponentStop();
         verify(selectedTab, times(1)).sendComponentStart();
 
     @Test
     public void lifecycleMethodsSentWhenSelectedPreviouslySelectedTab() throws Exception {
+        parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
         uut.switchToTab(1);
         uut.switchToTab(0);
-        verify(tabs.get(0), times(1)).sendComponentStop();
-        verify(tabs.get(0), times(2)).sendComponentStart();
-        verify(tabs.get(1), times(1)).sendComponentStart();
-        verify(tabs.get(1), times(1)).sendComponentStop();
+
+        verify(getActualTabView(0), times(1)).sendComponentStop();
+        verify(getActualTabView(0), times(2)).sendComponentStart();
+        verify(getActualTabView(1), times(1)).sendComponentStart();
+        verify(getActualTabView(1), times(1)).sendComponentStop();
     }
 
     @Test
     public void setOptionsOfInitialTab() throws Exception {
+        parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
-        verify(tabControllers.get(0), times(1)).applyOptions(tabOptions.get(0));
+        verify(tabControllers.get(0), times(1)).onViewAppeared();
+        verify(tabControllers.get(1), times(0)).onViewAppeared();
+
+        verify(uut, times(1)).applyOptions(tabOptions.get(0), ((ComponentViewController) tabControllers.get(0)).getComponent());
     }
 
     @Test
     public void setOptionsWhenTabChanges() throws Exception {
+        parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
+        tabControllers.get(0).ensureViewIsCreated();
+        tabControllers.get(1).ensureViewIsCreated();
+
         uut.onViewAppeared();
-        verify(tabControllers.get(0), times(1)).applyOptions(tabOptions.get(0));
+        verify(uut, times(1)).applyOptions(tabOptions.get(0), tabView(0));
         uut.switchToTab(1);
-        verify(tabControllers.get(1), times(1)).applyOptions(tabOptions.get(1));
+        verify(uut, times(1)).applyOptions(tabOptions.get(1), tabView(1));
         uut.switchToTab(0);
-        verify(tabControllers.get(0), times(2)).applyOptions(tabOptions.get(0));
+        verify(uut, times(2)).applyOptions(tabOptions.get(0), tabView(0));
+    }
+
+    private TestReactView getActualTabView(int index) {
+        return (TestReactView) tabControllers.get(index).getView().getChildAt(0);
     }
 
     @Test
     public void appliesOptionsOnLayoutWhenVisible() throws Exception {
+        tabControllers.get(0).ensureViewIsCreated();
+        parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
+
         uut.onViewAppeared();
+
         verify(topTabsLayout, times(1)).applyOptions(options);
     }
 
-    private IReactView tab(TopTabsLayout topTabs, final int index) {
+    private IReactView tab(TopTabsViewPager topTabs, final int index) {
         return (IReactView) ((ViewGroup) topTabs.getChildAt(index)).getChildAt(0);
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ViewControllerTest.java

 import android.app.Activity;
 import android.view.View;
 import android.view.ViewParent;
+import android.widget.FrameLayout;
 import android.widget.LinearLayout;
 
 import com.reactnativenavigation.BaseTest;
 
     @Test
     public void canOverrideViewCreation() throws Exception {
-        final View otherView = new View(activity);
+        final FrameLayout otherView = new FrameLayout(activity);
         ViewController myController = new ViewController(activity, "vc") {
             @Override
-            protected View createView() {
+            protected FrameLayout createView() {
                 return otherView;
             }
         };
 
     @Test
     public void holdsAReferenceToStackControllerOrNull() throws Exception {
-        assertThat(uut.getParentStackController()).isNull();
+        assertThat(uut.getParentController()).isNull();
         StackController nav = new StackController(activity, "stack");
         nav.animatePush(uut, new MockPromise());
-        assertThat(uut.getParentStackController()).isEqualTo(nav);
+        assertThat(uut.getParentController()).isEqualTo(nav);
     }
 
     @Test

playground/src/screens/TopTabOptionsScreen.js

   static get options() {
     return {
       topBar: {
-        title: 'Tab 1',
         textColor: 'black',
         textFontSize: 16,
         textFontFamily: 'HelveticaNeue-Italic'

playground/src/screens/TopTabScreen.js

 const React = require('react');
 const { PureComponent } = require('react');
 const { View, Text } = require('react-native');
-const Navigation = require('react-native-navigation');
 
 class TopTabScreen extends PureComponent {
   static get options() {
     };
   }
 
-  constructor(props) {
-    super(props);
-    Navigation.setOptions(this.props.componentId, {
-      topBar: {
-        title: this.props.title
-      }
-    });
-  }
-
   render() {
     return (
       <View style={styles.root}>

playground/src/screens/WelcomeScreen.js

               options: {
                 topTab: {
                   title: 'Tab 1'
+                },
+                topBar: {
+                  title: 'One'
                 }
               }
             }
                 topTab: {
                   title: 'Tab 2',
                   titleFontFamily: 'HelveticaNeue-Italic'
+                },
+                topBar: {
+                  title: 'Two'
                 }
               }
             }
               options: {
                 topTab: {
                   title: 'Tab 3'
+                },
+                topBar: {
+                  title: 'Three'
                 }
               }
             }