Search android (#432)

* Move event emmiter logic out of Application

* Implement searchView

Usage:
```js
rightButtons: [
      {
        id: 'searchView',
        label: 'Search',
        hint: 'Search...'
      }
    ]
```

* Translucent TitleBar

* Collapse TopBar

* Less noticeable translucent effect

* Implement ScrollViewDetector

* Collapse on fling

* Collapse on touch up

Complete collapse on touch up instead of fling

android/app/src/main/java/com/reactnativenavigation/NavigationApplication.java

 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.bridge.EventEmitter;
 import com.reactnativenavigation.controllers.ActivityCallbacks;
 import com.reactnativenavigation.react.NavigationReactGateway;
 import com.reactnativenavigation.react.ReactGateway;
     public static NavigationApplication instance;
 
     private NavigationReactGateway reactGateway;
+    private EventEmitter eventEmitter;
     private Handler handler;
     private ActivityCallbacks activityCallbacks;
 
         instance = this;
         handler = new Handler(getMainLooper());
         reactGateway = new NavigationReactGateway();
+        eventEmitter = new EventEmitter(reactGateway);
         activityCallbacks = new ActivityCallbacks();
     }
 
         return reactGateway.getReactNativeHost();
     }
 
+    public EventEmitter getEventEmitter() {
+        return eventEmitter;
+    }
+
     /**
      * @see ReactNativeHost#getJSMainModuleName()
      */
 
     @Nullable
     public abstract List<ReactPackage> createAdditionalReactPackages();
-
-    //TODO move all these navigator junk elsewhere
-    public void sendNavigatorEvent(String eventId, String navigatorEventId) {
-        if (!isReactContextInitialized()) {
-            return;
-        }
-        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
-    }
-
-    public void sendNavigatorEvent(String eventId, String navigatorEventId, WritableMap data) {
-        if (!isReactContextInitialized()) {
-            return;
-        }
-        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, data);
-    }
-
-    public void sendEvent(String eventId, String navigatorEventId) {
-        if (!isReactContextInitialized()) {
-            return;
-        }
-        reactGateway.getReactEventEmitter().sendEvent(eventId, navigatorEventId);
-    }
-
-    public void sendNavigatorEvent(String eventId, WritableMap arguments) {
-        if (!isReactContextInitialized()) {
-            return;
-        }
-        reactGateway.getReactEventEmitter().sendEvent(eventId, arguments);
-    }
 }

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

+package com.reactnativenavigation.bridge;
+
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.react.ReactGateway;
+
+public class EventEmitter {
+    private ReactGateway reactGateway;
+
+    public EventEmitter(ReactGateway reactGateway) {
+        this.reactGateway = reactGateway;
+    }
+
+    public void sendNavigatorEvent(String eventId, String navigatorEventId) {
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
+    }
+
+    public void sendNavigatorEvent(String eventId, String navigatorEventId, WritableMap data) {
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, data);
+    }
+
+    public void sendEvent(String eventId, String navigatorEventId) {
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendEvent(eventId, navigatorEventId);
+    }
+
+    public void sendNavigatorEvent(String eventId, WritableMap arguments) {
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendEvent(eventId, arguments);
+    }
+}

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

             sideMenu.openDrawer();
         } else {
             final String navigatorEventId = getCurrentScreenStack().peek().getNavigatorEventId();
-            NavigationApplication.instance.sendNavigatorEvent("sideMenu", navigatorEventId);
+            NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("sideMenu", navigatorEventId);
         }
     }
 }

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

             sideMenu.openDrawer();
         } else {
             final String navigatorEventId = stack.peek().getNavigatorEventId();
-            NavigationApplication.instance.sendNavigatorEvent("sideMenu", navigatorEventId);
+            NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("sideMenu", navigatorEventId);
         }
     }
 }

android/app/src/main/java/com/reactnativenavigation/params/CollapsingTopBarParams.java

 package com.reactnativenavigation.params;
 
+import android.support.annotation.Nullable;
+
 public class CollapsingTopBarParams {
-    public String imageUri;
+    public enum CollapseBehaviour {TitleBarHideOnScroll, CollapseTopBar}
+
+    public @Nullable String imageUri;
     public StyleParams.Color scrimColor;
+    public CollapseBehaviour collapseBehaviour;
+
+    public boolean hasBackgroundImage() {
+        return imageUri != null;
+    }
 }

android/app/src/main/java/com/reactnativenavigation/params/StyleParams.java

     public boolean drawScreenBelowTopBar;
 
     public boolean titleBarHidden;
+    public boolean titleBarHideOnScroll;
     public boolean topBarTransparent;
+    public boolean topBarTranslucent;
     public Color titleBarTitleColor;
     public Color titleBarSubtitleColor;
     public Color titleBarButtonColor;

android/app/src/main/java/com/reactnativenavigation/params/TitleBarButtonParams.java

     public StyleParams.Color color;
     public StyleParams.Color disabledColor;
     public boolean enabled = true;
+    public String hint;
 
     public void setColorFromScreenStyle(StyleParams.Color titleBarButtonColor) {
         if (!color.hasColor() && titleBarButtonColor.hasColor()) {

android/app/src/main/java/com/reactnativenavigation/params/parsers/CollapsingTopBarParamsParser.java

 import android.os.Bundle;
 
 import com.reactnativenavigation.params.CollapsingTopBarParams;
+import com.reactnativenavigation.params.CollapsingTopBarParams.CollapseBehaviour;
 import com.reactnativenavigation.params.StyleParams;
 
-public class CollapsingTopBarParamsParser extends Parser {
+class CollapsingTopBarParamsParser extends Parser {
     private Bundle params;
 
-    public CollapsingTopBarParamsParser(Bundle params) {
+    CollapsingTopBarParamsParser(Bundle params) {
         this.params = params;
     }
 
     public CollapsingTopBarParams parse() {
-        if (!hasLocalImageResource() && !hasImageUrl()) {
+        if (!hasBackgroundImage() && !shouldHideTitleBarOnScroll()) {
             return null;
         }
 
         CollapsingTopBarParams result = new CollapsingTopBarParams();
-        if (hasLocalImageResource()) {
-            result.imageUri = params.getString("collapsingToolBarImage");
-        } else {
+        if (hasBackgroundImage()) {
             result.imageUri = params.getString("collapsingToolBarImage");
         }
         result.scrimColor = getColor(params, "collapsingToolBarCollapsedColor", new StyleParams.Color(Color.WHITE));
+        result.collapseBehaviour = getCollapseBehaviour();
         return result;
     }
 
-    private boolean hasLocalImageResource() {
+    private CollapseBehaviour getCollapseBehaviour() {
+        return shouldHideTitleBarOnScroll() ? CollapseBehaviour.TitleBarHideOnScroll : CollapseBehaviour.CollapseTopBar;
+    }
+
+    private boolean hasBackgroundImage() {
         return params.containsKey("collapsingToolBarImage");
     }
 
-    private boolean hasImageUrl() {
-        return params.containsKey("collapsingToolBarImageUrl");
+    private boolean shouldHideTitleBarOnScroll() {
+        return params.getBoolean("titleBarHideOnScroll", false);
     }
 }

android/app/src/main/java/com/reactnativenavigation/params/parsers/Parser.java

 import java.util.List;
 
 public class Parser {
-    protected static boolean hasKey(Bundle bundle, String key) {
+    static boolean hasKey(Bundle bundle, String key) {
         return bundle.keySet().contains(key);
     }
 
-    protected static void assertKeyExists(Bundle bundle, String key) {
+    static void assertKeyExists(Bundle bundle, String key) {
         if (!hasKey(bundle, key)) {
             throw new KeyDoesNotExistsException(key);
         }
     }
 
-    public static class KeyDoesNotExistsException extends RuntimeException {
-        public KeyDoesNotExistsException(String key) {
+    private static class KeyDoesNotExistsException extends RuntimeException {
+        KeyDoesNotExistsException(String key) {
             super(key);
         }
     }
 
-    protected interface ParseStrategy<T> {
+    interface ParseStrategy<T> {
         T parse(Bundle params);
     }
 
-    protected <T> List<T> parseBundle(Bundle params, ParseStrategy<T> strategy) {
+    <T> List<T> parseBundle(Bundle params, ParseStrategy<T> strategy) {
         ArrayList<T> result = new ArrayList<>(Collections.nCopies(params.keySet().size(), (T) null));
         for (String key : params.keySet()) {
             result.set(Integer.parseInt(key), strategy.parse(params.getBundle(key)));

android/app/src/main/java/com/reactnativenavigation/params/parsers/StyleParamsParser.java

         result.titleBarHidden = getBoolean("titleBarHidden", getDefaultTopBarHidden());
         result.topBarTransparent = getBoolean("topBarTransparent", getDefaultTopBarHidden());
         result.titleBarTitleColor = getColor("titleBarTitleColor", getDefaultTitleBarColor());
+        result.topBarTranslucent = getBoolean("topBarTranslucent", getDefaultTopBarTranslucent());
+        result.titleBarHideOnScroll = getBoolean("titleBarHideOnScroll", getDefaultTitleBarHideOnScroll());
+
         result.titleBarSubtitleColor = getColor("titleBarSubtitleColor", getDefaultSubtitleBarColor());
         result.titleBarButtonColor = getColor("titleBarButtonColor", getTitleBarButtonColor());
         result.titleBarDisabledButtonColor = getColor("titleBarDisabledButtonColor", getTitleBarDisabledButtonColor());
         return AppStyle.appStyle != null && AppStyle.appStyle.topBarTransparent;
     }
 
+    private boolean getDefaultTopBarTranslucent() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.topBarTranslucent;
+    }
+
+    private boolean getDefaultTitleBarHideOnScroll() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.titleBarHideOnScroll;
+    }
+
     private StyleParams.Color getDefaultTopBarColor() {
         return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.topBarColor;
     }

android/app/src/main/java/com/reactnativenavigation/params/parsers/TitleBarButtonParamsParser.java

     public TitleBarButtonParams parseSingleButton(Bundle bundle) {
         TitleBarButtonParams result = new TitleBarButtonParams();
         result.label = bundle.getString("title");
-        if (hasKey(bundle,"icon")) {
+        if (hasKey(bundle, "icon")) {
             result.icon = ImageLoader.loadImage(bundle.getString("icon"));
         }
         result.color = getColor(bundle, "color", AppStyle.appStyle.titleBarButtonColor);
-        result.disabledColor = getColor(bundle, "disabledColor", AppStyle.appStyle.titleBarDisabledButtonColor);
+        result.disabledColor =
+                getColor(bundle, "disabledColor", AppStyle.appStyle.titleBarDisabledButtonColor);
         result.showAsAction = parseShowAsAction(bundle.getString("showAsAction"));
         result.enabled = bundle.getBoolean("enabled", true);
+        result.hint = bundle.getString("hint", "");
         result.eventId = bundle.getString("id");
         return result;
     }
 
-    protected BaseTitleBarButtonParams.ShowAsAction parseShowAsAction(String showAsAction) {
+    BaseTitleBarButtonParams.ShowAsAction parseShowAsAction(String showAsAction) {
         if (showAsAction == null) {
             return BaseTitleBarButtonParams.ShowAsAction.IfRoom;
         }

android/app/src/main/java/com/reactnativenavigation/screens/CollapsingSingleScreen.java

 import android.support.v7.app.AppCompatActivity;
 import android.widget.ScrollView;
 
+import com.reactnativenavigation.params.CollapsingTopBarParams;
 import com.reactnativenavigation.params.ScreenParams;
-import com.reactnativenavigation.views.ContentView;
+import com.reactnativenavigation.views.CollapsingContentView;
 import com.reactnativenavigation.views.LeftButtonOnClickListener;
+import com.reactnativenavigation.views.collapsingToolbar.CollapseAmount;
+import com.reactnativenavigation.views.collapsingToolbar.CollapseCalculator;
 import com.reactnativenavigation.views.collapsingToolbar.CollapsingContentViewMeasurer;
 import com.reactnativenavigation.views.collapsingToolbar.CollapsingTopBar;
+import com.reactnativenavigation.views.collapsingToolbar.OnScrollListener;
 import com.reactnativenavigation.views.collapsingToolbar.OnScrollViewAddedListener;
 import com.reactnativenavigation.views.collapsingToolbar.ScrollListener;
 
         super(activity, screenParams, titleBarBarBackButtonListener);
     }
 
+    @Override
+    public void destroy() {
+        super.destroy();
+        ((CollapsingContentView) contentView).destroy();
+    }
+
     @Override
     protected void createTopBar() {
         final CollapsingTopBar topBar = new CollapsingTopBar(getContext(), styleParams.collapsingTopBarParams);
-        topBar.setScrollListener(new ScrollListener(topBar,
-                new ScrollListener.OnScrollListener() {
-                    @Override
-                    public void onScroll(float amount) {
-                        contentView.collapse(amount);
-                        topBar.collapse(amount);
-                    }
-                }
-        ));
+        topBar.setScrollListener(getScrollListener(topBar));
         this.topBar = topBar;
     }
 
     @Override
     protected void createContent() {
-        contentView = new ContentView(getContext(), screenParams.screenId, screenParams.navigationParams);
-        contentView.setViewMeasurer(new CollapsingContentViewMeasurer((CollapsingTopBar) topBar, this));
+        contentView = new CollapsingContentView(getContext(), screenParams.screenId, screenParams.navigationParams);
+        if (screenParams.styleParams.drawScreenBelowTopBar) {
+            contentView.setViewMeasurer(new CollapsingContentViewMeasurer((CollapsingTopBar) topBar, this));
+        }
         setupCollapseDetection((CollapsingTopBar) topBar);
         addView(contentView, createLayoutParams());
     }
 
     private void setupCollapseDetection(final CollapsingTopBar topBar) {
-        contentView.setupCollapseDetection(new ScrollListener(topBar,
-                new ScrollListener.OnScrollListener() {
-                    @Override
-                    public void onScroll(float amount) {
-                        contentView.collapse(amount);
-                        topBar.collapse(amount);
-                    }
-                }
-        ));
-        contentView.setOnScrollViewAddedListener(new OnScrollViewAddedListener() {
+        ((CollapsingContentView) contentView).setupCollapseDetection(getScrollListener(topBar), new OnScrollViewAddedListener() {
             @Override
             public void onScrollViewAdded(ScrollView scrollView) {
                 topBar.onScrollViewAdded(scrollView);
             }
         });
     }
+
+    private ScrollListener getScrollListener(final CollapsingTopBar topBar) {
+        return new ScrollListener(new CollapseCalculator(topBar, getCollapseBehaviour()),
+                new OnScrollListener() {
+                    @Override
+                    public void onScroll(CollapseAmount amount) {
+                        if (!screenParams.styleParams.titleBarHideOnScroll) {
+                            ((CollapsingContentView) contentView).collapse(amount);
+                        }
+                        topBar.collapse(amount);
+                    }
+
+                    @Override
+                    public void onFling(CollapseAmount amount) {
+                        topBar.collapse(amount);
+                    }
+                },
+                getCollapseBehaviour()
+        );
+    }
+
+    private CollapsingTopBarParams.CollapseBehaviour getCollapseBehaviour() {
+        return screenParams.styleParams.collapsingTopBarParams.collapseBehaviour;
+    }
 }

android/app/src/main/java/com/reactnativenavigation/screens/ContentViewPagerAdapter.java

     private void sendTabSelectedEventToJs() {
         WritableMap data = Arguments.createMap();
         String navigatorEventId = contentViews.get(currentPosition).getNavigatorEventId();
-        NavigationApplication.instance.sendNavigatorEvent("tabSelected", navigatorEventId, data);
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("tabSelected", navigatorEventId, data);
     }
 }

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

         stack.clear();
     }
 
-    public int getStackSize() {
-        return stack.size();
-    }
-
     public boolean canPop() {
-        return getStackSize() > 1 && !isPreviousScreenAttachedToWindow();
+        return stack.size() > 1 && !isPreviousScreenAttachedToWindow();
     }
 
     private boolean isPreviousScreenAttachedToWindow() {
     public boolean handleBackPressInJs() {
         ScreenParams currentScreen = stack.peek().screenParams;
         if (currentScreen.overrideBackPressInJs) {
-            NavigationApplication.instance.sendNavigatorEvent("backPress", currentScreen.getNavigatorEventId());
+            NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("backPress", currentScreen.getNavigatorEventId());
             return true;
         }
         return false;

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

 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
+import android.support.annotation.Nullable;
 import android.util.DisplayMetrics;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.WindowManager;
 
             }
         }
     }
+
+    /**
+     * Returns the first instance of clazz in root
+     */
+    @Nullable public static <T> T findChildByClass(ViewGroup root, Class clazz) {
+        for (int i = 0; i < root.getChildCount(); i++) {
+            View view = root.getChildAt(i);
+            if (clazz.isAssignableFrom(view.getClass())) {
+                return (T) view;
+            }
+
+            if (view instanceof ViewGroup) {
+                view = findChildByClass((ViewGroup) view, clazz);
+                if (view != null && clazz.isAssignableFrom(view.getClass())) {
+                    return (T) view;
+                }
+            }
+        }
+        return null;
+    }
+
+    public static void performOnChildren(ViewGroup root, PerformOnViewTask task) {
+        for (int i = 0; i < root.getChildCount(); i++) {
+            View child = root.getChildAt(i);
+            if (child instanceof ViewGroup) {
+                performOnChildren((ViewGroup) child, task);
+            }
+            task.runOnView(child);
+        }
+    }
+
+    public interface PerformOnViewTask {
+        void runOnView(View view);
+    }
 }
 

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

+package com.reactnativenavigation.views;
+
+import android.view.Menu;
+import android.view.View;
+
+import com.reactnativenavigation.params.TitleBarButtonParams;
+
+class ButtonFactory {
+
+    public static TitleBarButton create(Menu menu, View parent, TitleBarButtonParams params, String navigatorEventId) {
+        switch (params.eventId) {
+            case TitleBarSearchButton.BUTTON_ID:
+                return new TitleBarSearchButton(menu, parent, params, navigatorEventId);
+            default:
+                return new TitleBarButton(menu, parent, params, navigatorEventId);
+        }
+    }
+}

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

+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.reactnativenavigation.params.NavigationParams;
+import com.reactnativenavigation.views.collapsingToolbar.CollapseAmount;
+import com.reactnativenavigation.views.collapsingToolbar.CollapsingView;
+import com.reactnativenavigation.views.collapsingToolbar.OnScrollViewAddedListener;
+import com.reactnativenavigation.views.collapsingToolbar.ScrollListener;
+import com.reactnativenavigation.views.collapsingToolbar.ScrollViewDelegate;
+import com.reactnativenavigation.views.collapsingToolbar.ViewCollapser;
+import com.reactnativenavigation.views.utils.ScrollViewDetector;
+
+public class CollapsingContentView extends ContentView implements CollapsingView {
+
+    private @Nullable ScrollViewDelegate scrollViewDelegate;
+    private @Nullable ScrollViewDetector scrollViewDetector;
+    private final ViewCollapser viewCollapser;
+
+    public CollapsingContentView(Context context, String screenId, NavigationParams navigationParams) {
+        super(context, screenId, navigationParams);
+        viewCollapser = new ViewCollapser(this);
+    }
+
+    public void setupCollapseDetection(ScrollListener scrollListener, OnScrollViewAddedListener onScrollViewAddedListener) {
+        scrollViewDelegate = new ScrollViewDelegate(scrollListener);
+        scrollViewDetector = new ScrollViewDetector(this, onScrollViewAddedListener, scrollViewDelegate);
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (scrollViewDelegate != null) {
+            boolean consumed = scrollViewDelegate.didInterceptTouchEvent(ev);
+            if (consumed) {
+                return true;
+            }
+        }
+        return super.dispatchTouchEvent(ev);
+    }
+
+    @Override
+    public void onViewAdded(final View child) {
+        super.onViewAdded(child);
+        if (scrollViewDetector != null) {
+            scrollViewDetector.detectScrollViewAdded(child);
+        }
+    }
+
+    public void collapse(CollapseAmount amount) {
+        viewCollapser.collapse(amount);
+    }
+
+    public void destroy() {
+        if (scrollViewDelegate != null) {
+            scrollViewDelegate.destroy();
+        }
+        if (scrollViewDetector != null) {
+            scrollViewDetector.destroy();
+        }
+    }
+
+    @Override
+    public float getFinalCollapseValue() {
+        return 0;
+    }
+
+    @Override
+    public float getCurrentCollapseValue() {
+        return 0;
+    }
+
+    @Override
+    public View asView() {
+        return this;
+    }
+}

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

 package com.reactnativenavigation.views;
 
 import android.content.Context;
-import android.support.annotation.Nullable;
-import android.view.MotionEvent;
 import android.view.View;
-import android.widget.ScrollView;
 
 import com.facebook.react.ReactRootView;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.params.NavigationParams;
 import com.reactnativenavigation.screens.SingleScreen;
 import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.views.collapsingToolbar.OnScrollViewAddedListener;
-import com.reactnativenavigation.views.collapsingToolbar.ScrollListener;
-import com.reactnativenavigation.views.collapsingToolbar.ScrollViewDelegate;
 import com.reactnativenavigation.views.utils.ViewMeasurer;
 
 public class ContentView extends ReactRootView {
 
     boolean isContentVisible = false;
     private SingleScreen.OnDisplayListener onDisplayListener;
-    @Nullable private ScrollViewDelegate scrollViewDelegate;
-    private ViewMeasurer viewMeasurer;
-    private OnScrollViewAddedListener scrollViewAddedListener;
+    protected ViewMeasurer viewMeasurer;
 
     public void setOnDisplayListener(SingleScreen.OnDisplayListener onDisplayListener) {
         this.onDisplayListener = onDisplayListener;
     }
 
-    public void setOnScrollViewAddedListener(OnScrollViewAddedListener scrollViewAddedListener) {
-        this.scrollViewAddedListener = scrollViewAddedListener;
-    }
-
     public ContentView(Context context, String screenId, NavigationParams navigationParams) {
         super(context);
         this.screenId = screenId;
         viewMeasurer = new ViewMeasurer();
     }
 
-    public void setupCollapseDetection(ScrollListener scrollListener) {
-        scrollViewDelegate = new ScrollViewDelegate(scrollListener);
-    }
-
     public void setViewMeasurer(ViewMeasurer viewMeasurer) {
         this.viewMeasurer = viewMeasurer;
     }
                 viewMeasurer.getMeasuredHeight(heightMeasureSpec));
     }
 
-    @Override
-    public boolean dispatchTouchEvent(MotionEvent ev) {
-        if (scrollViewDelegate != null) {
-            boolean consumed = scrollViewDelegate.didInterceptTouchEvent(ev);
-            if (consumed) {
-                return true;
-            }
-        }
-        return super.dispatchTouchEvent(ev);
-    }
-
     @Override
     public void onViewAdded(final View child) {
         super.onViewAdded(child);
         detectContentViewVisible(child);
-        if (child instanceof ScrollView) {
-            onScrollViewAdded((ScrollView) child);
-        }
-    }
-
-    private void onScrollViewAdded(ScrollView scrollView) {
-        if (scrollViewDelegate != null) {
-            scrollViewDelegate.onScrollViewAdded(scrollView);
-            scrollViewAddedListener.onScrollViewAdded(scrollView);
-        }
     }
 
     private void detectContentViewVisible(View child) {
             });
         }
     }
-
-    public void collapse(float collapse) {
-        setTranslationY(collapse);
-    }
 }

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

                 ((ViewManager) getParent()).removeView(ContextualMenu.this);
             }
         });
-        NavigationApplication.instance.sendNavigatorEvent("contextualMenuDismissed", navigatorEventId);
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("contextualMenuDismissed", navigatorEventId);
     }
 }

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

                     fabAnimator.showExpended();
                     showActions();
                 }
-                NavigationApplication.instance.sendNavigatorEvent(params.collapsedId, params.navigatorEventId);
+                NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(params.collapsedId, params.navigatorEventId);
             }
         });
     }
             @Override
             public void onClick(View v) {
                 fabAnimator.collapse();
-                NavigationApplication.instance.sendNavigatorEvent(params.expendedId, params.navigatorEventId);
+                NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(params.expendedId, params.navigatorEventId);
             }
         });
     }
         action.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                NavigationApplication.instance.sendNavigatorEvent(actionParams.id, actionParams.navigatorEventId);
+                NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(actionParams.id, actionParams.navigatorEventId);
                 fabAnimator.collapse();
             }
         });

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

 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 
-public class LeftButton extends MaterialMenuDrawable implements View.OnClickListener {
+class LeftButton extends MaterialMenuDrawable implements View.OnClickListener {
 
     private static int getColor(TitleBarButtonParams params) {
         return params != null && params.color.hasColor() ?
     private final String navigatorEventId;
     private final boolean overrideBackPressInJs;
 
-    public LeftButton(Context context,
-                      TitleBarLeftButtonParams params,
-                      LeftButtonOnClickListener onClickListener,
-                      String navigatorEventId,
-                      boolean overrideBackPressInJs) {
+    LeftButton(Context context,
+               TitleBarLeftButtonParams params,
+               LeftButtonOnClickListener onClickListener,
+               String navigatorEventId,
+               boolean overrideBackPressInJs) {
         super(context, getColor(params), Stroke.THIN);
         this.params = params;
         this.onClickListener = onClickListener;
         setInitialState();
     }
 
-    public void setIconState(TitleBarLeftButtonParams params) {
+    void setIconState(TitleBarLeftButtonParams params) {
         this.params = params;
         if (params.color.hasColor()) {
             setColor(params.color.getColor());
 
     private void handleBackButtonClick() {
         if (overrideBackPressInJs) {
-            NavigationApplication.instance.sendNavigatorEvent("backPress", navigatorEventId);
+            NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("backPress", navigatorEventId);
         } else {
             onClickListener.onTitleBarBackButtonClick();
         }
     }
 
     private void sendClickEvent() {
-        NavigationApplication.instance.sendNavigatorEvent(params.eventId, navigatorEventId);
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(params.eventId, navigatorEventId);
     }
 }

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

 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.params.SnackbarParams;
 
-public class Snakbar {
+class Snakbar {
     private final OnDismissListener parent;
     private final String navigatorEventId;
     private final SnackbarParams params;
     private Snackbar snackbar;
 
-    public interface OnDismissListener {
+    interface OnDismissListener {
         void onDismiss(Snakbar snakbar);
     }
 
         snackbar.show();
     }
 
-    public void dismiss() {
+    void dismiss() {
         snackbar.dismiss();
     }
 
         return snackbar.getView();
     }
 
-    public Snakbar(OnDismissListener parent, String navigatorEventId, SnackbarParams params) {
+    Snakbar(OnDismissListener parent, String navigatorEventId, SnackbarParams params) {
         this.parent = parent;
         this.navigatorEventId = navigatorEventId;
         this.params = params;
             snackbar.setAction(params.buttonText, new View.OnClickListener() {
                 @Override
                 public void onClick(View v) {
-                    NavigationApplication.instance.sendNavigatorEvent(params.eventId, navigatorEventId);
+                    NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(params.eventId, navigatorEventId);
                 }
             });
         }

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

         setTitleTextColor(params);
         setSubtitleTextColor(params);
         colorOverflowButton(params);
+        setTranslucent(params);
     }
 
     private void colorOverflowButton(StyleParams params) {
         }
     }
 
+    private void setTranslucent(StyleParams params) {
+        if (params.topBarTranslucent) {
+            setBackground(new TranslucentTitleBarBackground());
+        }
+    }
+
     private boolean shouldColorOverflowButton(StyleParams params, Drawable overflowIcon) {
         return overflowIcon != null && params.titleBarButtonColor.hasColor();
     }
 
     private void addButtonsToTitleBar(List<TitleBarButtonParams> rightButtons, String navigatorEventId, Menu menu) {
         for (int i = 0; i < rightButtons.size(); i++) {
-            final TitleBarButton button = new TitleBarButton(menu, this, rightButtons.get(i), navigatorEventId);
+            final TitleBarButton button = ButtonFactory.create(menu, this, rightButtons.get(i), navigatorEventId);
             addButtonInReverseOrder(rightButtons, i, button);
         }
     }

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

 
 class TitleBarButton implements MenuItem.OnMenuItemClickListener {
 
-    private final Menu menu;
-    private final View parent;
+    protected final Menu menu;
+    protected final View parent;
     protected TitleBarButtonParams buttonParams;
-    @Nullable private String navigatorEventId;
+    @Nullable protected String navigatorEventId;
 
     TitleBarButton(Menu menu, View parent, TitleBarButtonParams buttonParams, @Nullable String navigatorEventId) {
         this.menu = menu;
 
     @Override
     public boolean onMenuItemClick(MenuItem item) {
-        NavigationApplication.instance.sendNavigatorEvent(buttonParams.eventId, navigatorEventId);
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(buttonParams.eventId, navigatorEventId);
         return true;
     }
 }

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

+package com.reactnativenavigation.views;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.Nullable;
+import android.support.v4.view.MenuItemCompat;
+import android.support.v7.widget.SearchView;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.EditText;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.utils.ReflectionUtils;
+import com.reactnativenavigation.utils.ViewUtils;
+
+class TitleBarSearchButton extends TitleBarButton implements SearchView.OnQueryTextListener, View.OnFocusChangeListener, View.OnClickListener {
+    static final String BUTTON_ID = "searchView";
+    private SearchView searchView;
+
+    TitleBarSearchButton(Menu menu, View parent, TitleBarButtonParams buttonParams, @Nullable String navigatorEventId) {
+        super(menu, parent, buttonParams, navigatorEventId);
+    }
+
+    MenuItem addToMenu(int index) {
+        ((Activity) parent.getContext()).getMenuInflater().inflate(R.menu.search_item, menu);
+        MenuItem item = menu.findItem(R.id.toolbar_action_search);
+        item.setOnMenuItemClickListener(this);
+        if (buttonParams.icon != null) {
+            item.setIcon(buttonParams.icon);
+        }
+        searchView = (SearchView) MenuItemCompat.getActionView(item);
+        searchView.setQueryHint(buttonParams.hint);
+        searchView.setOnQueryTextFocusChangeListener(this);
+        searchView.setOnQueryTextListener(this);
+        searchView.setOnSearchClickListener(this);
+        setColor();
+        return item;
+    }
+
+    private void setColor() {
+        EditText searchEditText = ViewUtils.findChildByClass(searchView, EditText.class);
+        if (searchEditText != null) {
+            if (buttonParams.color.hasColor()) {
+                searchEditText.setTextColor(buttonParams.color.getColor());
+                searchEditText.setHintTextColor(buttonParams.color.getColor());
+            }
+            colorCloseButton(searchEditText);
+            setImagePlateColor();
+        }
+    }
+
+    private void colorCloseButton(EditText searchEditText) {
+        ViewUtils.performOnChildren((ViewGroup) searchEditText.getParent(), new ViewUtils.PerformOnViewTask() {
+            @Override
+            public void runOnView(View view) {
+                if (view instanceof ImageView) {
+                    if (buttonParams.color.hasColor()) {
+                        ((ImageView) view).setColorFilter(buttonParams.color.getColor());
+                    }
+                }
+            }
+        });
+    }
+
+    private void setImagePlateColor() {
+        if (buttonParams.color.hasColor()) {
+            Object mSearchPlate = ReflectionUtils.getDeclaredField(searchView, "mSearchPlate");
+            if (mSearchPlate != null) {
+                Drawable background = ((View) mSearchPlate).getBackground();
+                if (background != null) {
+                    ViewUtils.tintDrawable(background, buttonParams.color.getColor(), true);
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean onMenuItemClick(MenuItem item) {
+        setupBackButtonAfterSearchViewIsExpended();
+        return false;
+    }
+
+    private void setupBackButtonAfterSearchViewIsExpended() {
+        ViewUtils.runOnPreDraw(searchView, new Runnable() {
+            @Override
+            public void run() {
+                Object backButton = ViewUtils.findChildByClass((ViewGroup) searchView.getParent(), ImageButton.class);
+                if (backButton != null) {
+                    setBackButtonClickListener((View) backButton);
+                    colorBackButton((ImageView) backButton);
+                }
+            }
+
+            private void colorBackButton(ImageView backButton) {
+                if (buttonParams.color.hasColor()) {
+                    ViewUtils.tintDrawable(backButton.getDrawable(), buttonParams.color.getColor(), true);
+                }
+            }
+
+            private void setBackButtonClickListener(View backButton) {
+                backButton.setOnClickListener(new View.OnClickListener() {
+                    @Override
+                    public void onClick(View v) {
+                        ((Toolbar) searchView.getParent()).collapseActionView();
+                        sendEvent("searchViewHidden");
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public boolean onQueryTextSubmit(String query) {
+        WritableMap arguments = Arguments.createMap();
+        arguments.putString("query", query);
+        sendEvent("searchQuerySubmit", arguments);
+        return false;
+    }
+
+    @Override
+    public boolean onQueryTextChange(String newText) {
+        WritableMap arguments = Arguments.createMap();
+        arguments.putString("query", newText);
+        sendEvent("searchQueryChange", arguments);
+        return false;
+    }
+
+    @Override
+    public void onFocusChange(View v, boolean hasFocus) {
+        WritableMap arguments = Arguments.createMap();
+        arguments.putBoolean("hasFocus", hasFocus);
+        sendEvent("searchFocusChange", arguments);
+    }
+
+    @Override
+    public void onClick(View v) {
+        sendEvent("searchViewShown");
+    }
+
+    private void sendEvent(String eventId, WritableMap arguments) {
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, arguments);
+    }
+
+    private void sendEvent(String eventId) {
+        NavigationApplication.instance.getEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
+    }
+}

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

     private void setTransparent() {
         setBackgroundColor(Color.TRANSPARENT);
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            setElevation(0);
             setOutlineProvider(null);
         }
     }

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

+package com.reactnativenavigation.views;
+
+import android.graphics.Color;
+import android.graphics.LinearGradient;
+import android.graphics.Shader;
+import android.graphics.drawable.PaintDrawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RectShape;
+
+class TranslucentTitleBarBackground extends PaintDrawable {
+
+    TranslucentTitleBarBackground() {
+        setShape(new RectShape());
+        createShader();
+    }
+
+    private void createShader() {
+        ShapeDrawable.ShaderFactory sf = new ShapeDrawable.ShaderFactory() {
+            @Override
+            public Shader resize(int width, int height) {
+                double angleInRadians = Math.toRadians(90);
+
+                int x1 = (int) (Math.cos(angleInRadians) * width);
+                int y1 = (int) (Math.sin(angleInRadians) * height);
+                int[] colors = new int[]{Color.argb(90, 0, 0, 0), Color.argb(15, 0, 0, 0), Color.TRANSPARENT};
+                float[] positions = {0, 0.78f, 1};
+                LinearGradient lg = new LinearGradient(0, 0, x1, y1,
+                        colors,
+                        positions,
+                        Shader.TileMode.REPEAT);
+                return lg;
+            }
+        };
+        setShaderFactory(sf);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapseAmount.java

 package com.reactnativenavigation.views.collapsingToolbar;
 
 public class CollapseAmount {
-    public final static CollapseAmount None = new CollapseAmount();
+    final static CollapseAmount None = new CollapseAmount();
+
+    private CollapseAmount() {}
+
     private Float amount;
+    private CollapseCalculator.Direction direction;
 
-    public CollapseAmount(float amount) {
+    CollapseAmount(float amount) {
         this.amount = amount;
     }
 
-    private CollapseAmount() {
+    CollapseAmount(CollapseCalculator.Direction direction) {
+        this.direction = direction;
+    }
+
+    boolean canCollapse() {
+        return amount != null || this != None;
+    }
 
+    boolean collapseToTop() {
+        return direction == CollapseCalculator.Direction.Up;
     }
 
-    public boolean canCollapse() {
-        return amount != null;
+    boolean collapseToBottom() {
+        return direction == CollapseCalculator.Direction.Down;
     }
 
     public float get() {

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapseCalculator.java

 
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.widget.ScrollView;
 
-class CollapseCalculator {
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.CollapsingTopBarParams.CollapseBehaviour;
+
+import static com.reactnativenavigation.params.CollapsingTopBarParams.CollapseBehaviour.TitleBarHideOnScroll;
+
+public class CollapseCalculator {
+    enum Direction {
+        Up, Down, None
+    }
+
     private float collapse;
     private MotionEvent previousTouchEvent;
     private float touchDownY = -1;
     private boolean canCollapse = true;
     private boolean canExpend = false;
     private CollapsingView view;
+    private CollapseBehaviour collapseBehaviour;
     protected ScrollView scrollView;
+    private GestureDetector flingDetector;
+    private OnFlingListener flingListener;
+    private int scrollY = 0;
+    private int totalCollapse = 0;
 
-    CollapseCalculator(final CollapsingView collapsingView) {
+    public CollapseCalculator(final CollapsingView collapsingView, CollapseBehaviour collapseBehaviour) {
         this.view = collapsingView;
+        this.collapseBehaviour = collapseBehaviour;
+        setFlingDetector(collapseBehaviour);
+    }
+
+    private void setFlingDetector(CollapseBehaviour collapseBehaviour) {
+        if (collapseBehaviour == TitleBarHideOnScroll) {
+            flingDetector =
+                    new GestureDetector(NavigationApplication.instance, new GestureDetector.SimpleOnGestureListener() {
+                        @Override
+                        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+                            final Direction direction = getScrollDirection(e1, e2);
+                            if (canCollapse(direction) && totalCollapse != 0) {
+                                flingListener.onFling(new CollapseAmount(direction));
+                                return true;
+                            }
+                            return false;
+                        }
+
+                        private Direction getScrollDirection(MotionEvent e1, MotionEvent e2) {
+                            if (e1.getRawY() == e2.getRawY()) {
+                                return Direction.None;
+                            }
+                            return e1.getRawY() - e2.getRawY() > 0 ? Direction.Up : Direction.Down;
+                        }
+                    });
+        }
     }
 
     void setScrollView(ScrollView scrollView) {
         this.scrollView = scrollView;
     }
 
+    void setFlingListener(OnFlingListener flingListener) {
+        this.flingListener = flingListener;
+    }
+
     @NonNull
     CollapseAmount calculate(MotionEvent event) {
         updateInitialTouchY(event);
+        CollapseAmount touchUpCollapse = shouldCollapseOnTouchUp(event);
+        if (touchUpCollapse != CollapseAmount.None) {
+            previousTouchEvent = MotionEvent.obtain(event);
+            return touchUpCollapse;
+        }
+
         if (!isMoveEvent(event)) {
+            previousTouchEvent = MotionEvent.obtain(event);
             return CollapseAmount.None;
         }
 
-        if (shouldCollapse(event)) {
+        final Direction direction = calculateScrollDirection(event.getRawY());
+        if (shouldCollapseAfterMoveEvent(direction)) {
             return calculateCollapse(event);
         } else {
             previousCollapseY = -1;
         }
     }
 
-    private boolean shouldCollapse(MotionEvent event) {
+    private CollapseAmount shouldCollapseOnTouchUp(MotionEvent event) {
+        if (collapseBehaviour == TitleBarHideOnScroll && !flingDetector.onTouchEvent(event) && isTouchUp(event)) {
+            final float visibilityPercentage = view.getCurrentCollapseValue() / view.getFinalCollapseValue();
+            Direction direction = visibilityPercentage >= 0.5f ? Direction.Up : Direction.Down;
+            if (canCollapse(direction) && totalCollapse != 0) {
+                return new CollapseAmount(direction);
+            }
+        }
+        return CollapseAmount.None;
+    }
+
+    private boolean shouldCollapseAfterMoveEvent(Direction direction) {
+        if (collapseBehaviour == CollapseBehaviour.TitleBarHideOnScroll && !isScrolling()) {
+            return false;
+        }
+        return canCollapse(direction);
+    }
+
+    private boolean canCollapse(Direction direction) {
         checkCollapseLimits();
-        ScrollDirection.Direction direction = getScrollDirection(event.getRawY());
-        return isNotCollapsedOrExpended() ||
-                (canCollapse && isExpendedAndScrollingUp(direction)) ||
-                (canExpend && isCollapsedAndScrollingDown(direction));
+        return (isNotCollapsedOrExpended() ||
+               (canCollapse && isExpendedAndScrollingUp(direction)) ||
+               (canExpend && isCollapsedAndScrollingDown(direction)));
+    }
+
+    private boolean isScrolling() {
+        final int currentScrollY = scrollView.getScrollY();
+        final boolean isScrolling = currentScrollY != scrollY;
+        scrollY = currentScrollY;
+        return isScrolling;
     }
 
-    private ScrollDirection.Direction getScrollDirection(float y) {
+    private Direction calculateScrollDirection(float y) {
         if (y == (previousCollapseY == -1 ? touchDownY : previousCollapseY)) {
-            return ScrollDirection.Direction.None;
+            return Direction.None;
         }
         if (previousTouchEvent == null) {
-            return ScrollDirection.Direction.None;
+            return Direction.None;
         }
         return y < previousTouchEvent.getRawY() ?
-                ScrollDirection.Direction.Up :
-                ScrollDirection.Direction.Down;
+                Direction.Up :
+                Direction.Down;
     }
 
     private void checkCollapseLimits() {
     private boolean calculateCanExpend(float currentTopBarTranslation, float finalExpendedTranslation, float finalCollapsedTranslation) {
         return currentTopBarTranslation >= finalCollapsedTranslation &&
                currentTopBarTranslation < finalExpendedTranslation &&
-               scrollView.getScrollY() == 0;
+               (scrollView.getScrollY() == 0 || collapseBehaviour == CollapseBehaviour.TitleBarHideOnScroll);
     }
 
-    private boolean isCollapsedAndScrollingDown(ScrollDirection.Direction direction) {
-        return isCollapsed && direction == ScrollDirection.Direction.Down;
+    private boolean isCollapsedAndScrollingDown(Direction direction) {
+        return isCollapsed && direction == Direction.Down;
     }
 
-    private boolean isExpendedAndScrollingUp(ScrollDirection.Direction direction) {
-        return isExpended && direction == ScrollDirection.Direction.Up;
+    private boolean isExpendedAndScrollingUp(Direction direction) {
+        return isExpended && direction == Direction.Up;
     }
 
-    private  boolean isNotCollapsedOrExpended() {
+    private boolean isNotCollapsedOrExpended() {
         return canExpend && canCollapse;
     }
 
             previousCollapseY = y;
         }
         collapse = calculateCollapse(y);
+        totalCollapse += collapse;
         previousCollapseY = y;
         previousTouchEvent = MotionEvent.obtain(event);
         return new CollapseAmount(collapse);
     }
 
     private void saveInitialTouchY(MotionEvent event) {
+        totalCollapse = 0;
         touchDownY = event.getRawY();
+        scrollY = scrollView.getScrollY();
         previousCollapseY = touchDownY;
     }
 
     private void clearInitialTouchY() {
-        touchDownY = -1;
         previousCollapseY = -1;
         collapse = 0;
     }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingTopBar.java

     private CollapsingTopBarBackground collapsingTopBarBackground;
     private ScrollListener scrollListener;
     private float finalCollapsedTranslation;
+    private CollapsingTopBarParams params;
+    private final ViewCollapser viewCollapser;
 
-    public CollapsingTopBar(Context context, CollapsingTopBarParams params) {
+    public CollapsingTopBar(Context context, final CollapsingTopBarParams params) {
         super(context);
+        this.params = params;
         createCollapsingTopBar(params);
+        calculateFinalCollapsedTranslation(params);
+        viewCollapser = new ViewCollapser(this);
+    }
+
+    private void calculateFinalCollapsedTranslation(final CollapsingTopBarParams params) {
         ViewUtils.runOnPreDraw(this, new Runnable() {
             @Override
             public void run() {
-                finalCollapsedTranslation = getCollapsingTopBarBackground().getCollapsedTopBarHeight() - getHeight();
+                if (params.hasBackgroundImage()) {
+                    finalCollapsedTranslation =
+                            getCollapsingTopBarBackground().getCollapsedTopBarHeight() - getHeight();
+                } else {
+                    finalCollapsedTranslation = -titleBar.getHeight();
+                }
             }
         });
-
     }
 
     public void setScrollListener(ScrollListener scrollListener) {
     }
 
     private void createCollapsingTopBar(CollapsingTopBarParams params) {
-        collapsingTopBarBackground = new CollapsingTopBarBackground(getContext(), params);
-        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, (int) CollapsingTopBarBackground.MAX_HEIGHT);
-        titleBarAndContextualMenuContainer.addView(collapsingTopBarBackground, lp);
+        if (params.hasBackgroundImage()) {
+            collapsingTopBarBackground = new CollapsingTopBarBackground(getContext(), params);
+            LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, (int) CollapsingTopBarBackground.MAX_HEIGHT);
+            titleBarAndContextualMenuContainer.addView(collapsingTopBarBackground, lp);
+        }
     }
 
     @Override
     protected TitleBar createTitleBar() {
-        return new CollapsingTitleBar(getContext(),
-                collapsingTopBarBackground.getCollapsedTopBarHeight(),
-                scrollListener);
+        if (params.hasBackgroundImage()) {
+            return new CollapsingTitleBar(getContext(),
+                    collapsingTopBarBackground.getCollapsedTopBarHeight(),
+                    scrollListener);
+        } else {
+            return super.createTitleBar();
+        }
     }
 
     public CollapsingTopBarBackground getCollapsingTopBarBackground() {
         return collapsingTopBarBackground;
     }
 
-    public void collapse(float collapse) {
-        setTranslationY(collapse);
-        ((CollapsingTitleBar) titleBar).collapse(collapse);
-        collapsingTopBarBackground.collapse(collapse);
+    public void collapse(CollapseAmount amount) {
+        viewCollapser.collapse(amount);
+        if (titleBar instanceof CollapsingTitleBar) {
+            ((CollapsingTitleBar) titleBar).collapse(amount.get());
+        }
+        if (collapsingTopBarBackground != null) {
+            collapsingTopBarBackground.collapse(amount.get());
+        }
     }
 
     public void onScrollViewAdded(ScrollView scrollView) {
     }
 
     public int getCollapsedHeight() {
-        return collapsingTopBarBackground.getCollapsedTopBarHeight();
+        return params.hasBackgroundImage() ?
+                collapsingTopBarBackground.getCollapsedTopBarHeight() :
+                titleBar.getHeight();
     }
 
     @Override

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/OnFlingListener.java

+package com.reactnativenavigation.views.collapsingToolbar;
+
+interface OnFlingListener {
+    void onFling(CollapseAmount amount);
+}

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/OnScrollListener.java

+package com.reactnativenavigation.views.collapsingToolbar;
+
+public interface  OnScrollListener extends OnFlingListener {
+    void onScroll(CollapseAmount amount);
+}

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/ScrollDirection.java

-package com.reactnativenavigation.views.collapsingToolbar;
-
-import android.widget.ScrollView;
-
-public class ScrollDirection {
-
-    public enum Direction {
-        Up, Down, None
-    }
-
-    private final ScrollView scrollView;
-    private int lastScrollY = 0;
-
-    public ScrollDirection(ScrollView scrollView) {
-        this.scrollView = scrollView;
-    }
-
-    public Direction getScrollDirection() {
-        Direction direction = Direction.None;
-
-        final int scrollY = scrollView.getScrollY();
-        if (isScrollPositionChanged(scrollY) && !isTopOverscroll(scrollY) && !isBottomOverscroll(scrollY)) {
-            direction = getScrollDirection(scrollY);
-            lastScrollY = scrollY;
-        }
-        return direction;
-    }
-
-    public int getScrollDelta() {
-        return scrollView.getScrollY() - lastScrollY;
-    }
-
-
-    private Direction getScrollDirection(int scrollY) {
-        return scrollY > lastScrollY ? Direction.Up : Direction.Down;
-    }
-
-    private boolean isBottomOverscroll(int scrollY) {
-        return scrollY >= (scrollView.getChildAt(0).getHeight() - scrollView.getHeight());
-    }
-
-    private boolean isTopOverscroll(int scrollY) {
-        return scrollY <= 0;
-    }
-
-    private boolean isScrollPositionChanged(int scrollY) {
-        return scrollY != lastScrollY;
-    }
-
-}

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/ScrollListener.java

 import android.view.MotionEvent;
 import android.widget.ScrollView;
 
-public class ScrollListener implements ScrollViewDelegate.OnScrollListener {
+import com.reactnativenavigation.params.CollapsingTopBarParams.CollapseBehaviour;
+
+public class ScrollListener {
     private CollapseCalculator collapseCalculator;
     private OnScrollListener scrollListener;
+    private CollapseBehaviour collapseBehaviour;
 
-    public interface  OnScrollListener {
-        void onScroll(float amount);
-    }
-
-    public ScrollListener(CollapsingView collapsingView, OnScrollListener scrollListener) {
-        this.collapseCalculator = new CollapseCalculator(collapsingView);
+    public ScrollListener(CollapseCalculator collapseCalculator, OnScrollListener scrollListener,
+                          CollapseBehaviour collapseBehaviour) {
+        this.collapseCalculator = collapseCalculator;
         this.scrollListener = scrollListener;
+        this.collapseBehaviour = collapseBehaviour;
+        collapseCalculator.setFlingListener(scrollListener);
     }
 
-    @Override
-    public void onScrollViewAdded(ScrollView scrollView) {
+    void onScrollViewAdded(ScrollView scrollView) {
         collapseCalculator.setScrollView(scrollView);
     }
 
-    @Override
-    public boolean onTouch(MotionEvent event) {
+    boolean onTouch(MotionEvent event) {
         CollapseAmount amount = collapseCalculator.calculate(event);
         if (amount.canCollapse()) {
-            scrollListener.onScroll(amount.get());
-            return true;
+            scrollListener.onScroll(amount);
+            return CollapseBehaviour.CollapseTopBar.equals(collapseBehaviour);
         }
         return false;
     }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/ScrollViewDelegate.java

 import android.widget.ScrollView;
 
 public class ScrollViewDelegate implements View.OnTouchListener {
-    interface OnScrollListener {
-        boolean onTouch(MotionEvent event);
+    private ScrollView scrollView;
+    private ScrollListener listener;
 
-        void onScrollViewAdded(ScrollView scrollView);
+    public ScrollViewDelegate(ScrollListener scrollListener) {
+        listener = scrollListener;
     }
 
-    private ScrollView scrollView;
-    private OnScrollListener listener;
-    private Boolean didInterceptLastTouchEvent = null;
+    public boolean hasScrollView() {
+        return scrollView != null;
+    }
 
-    public ScrollViewDelegate(OnScrollListener scrollListener) {
-        listener = scrollListener;
+    public ScrollView getScrollView() {
+        return scrollView;
     }
 
     public void onScrollViewAdded(ScrollView scrollView) {
         listener.onScrollViewAdded(this.scrollView);
     }
 
+    public void onScrollViewRemoved() {
+        this.scrollView = null;
+    }
+
     public boolean didInterceptTouchEvent(MotionEvent ev) {
             return listener.onTouch(ev);
     }
 
     @Override
     public boolean onTouch(View view, MotionEvent event) {
-        if (!didInterceptLastTouchEvent) {
-            scrollView.onTouchEvent(event);
-        }
+        scrollView.onTouchEvent(event);
         return this.listener.onTouch(event);
     }
+
+    public void destroy() {
+        scrollView = null;
+    }
 }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/ViewCollapser.java

+package com.reactnativenavigation.views.collapsingToolbar;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+
+public class ViewCollapser {
+    private static final int DURATION = 160;
+    private CollapsingView view;
+    private boolean animating;
+
+    public ViewCollapser(CollapsingView view) {
+        this.view = view;
+    }
+
+    public void collapse(CollapseAmount amount) {
+        if (amount.collapseToTop()) {
+            collapseView(true, view.getFinalCollapseValue());
+        } else if (amount.collapseToBottom()) {
+            collapseView(true, 0);
+        } else {
+            collapse(amount.get());
+        }
+    }
+
+    public void collapse(float amount) {
+        view.asView().setTranslationY(amount);
+    }
+
+    private void collapseView(boolean animate, float translation) {
+        if (animate) {
+            animate(translation);
+        } else {
+            view.asView().setTranslationY(translation);
+        }
+    }
+
+    private void animate(final float translation) {
+        if (animating) {
+            return;
+        }
+        view.asView().animate()
+                .translationY(translation)
+                .setDuration(DURATION)
+                .setListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationStart(Animator animation) {
+                        animating = true;
+                    }
+
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        animating = false;
+                    }
+                })
+                .start();
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/utils/ScrollViewDetector.java

+package com.reactnativenavigation.views.utils;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ScrollView;
+
+import com.reactnativenavigation.utils.ViewUtils;
+import com.reactnativenavigation.views.ContentView;
+import com.reactnativenavigation.views.collapsingToolbar.OnScrollViewAddedListener;
+import com.reactnativenavigation.views.collapsingToolbar.ScrollViewDelegate;
+
+public class ScrollViewDetector {
+    private OnScrollViewAddedListener scrollViewAddedListener;
+    private ScrollViewDelegate scrollViewDelegate;
+    private View.OnAttachStateChangeListener stateChangeListener;
+
+    public ScrollViewDetector(final ContentView contentView,
+                              OnScrollViewAddedListener onScrollViewAddedListener,
+                              final ScrollViewDelegate scrollViewDelegate) {
+        this.scrollViewAddedListener = onScrollViewAddedListener;
+        this.scrollViewDelegate = scrollViewDelegate;
+        stateChangeListener = new View.OnAttachStateChangeListener() {
+            @Override
+            public void onViewAttachedToWindow(View v) {
+
+            }
+
+            @Override
+            public void onViewDetachedFromWindow(View v) {
+                scrollViewDelegate.getScrollView().removeOnAttachStateChangeListener(this);
+                scrollViewDelegate.onScrollViewRemoved();
+                contentView.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        detectScrollViewAdded(contentView);
+                    }
+                });
+            }
+        };
+    }
+
+    public void detectScrollViewAdded(View child) {
+        if (child instanceof ScrollView) {
+            onScrollViewAdded((ScrollView) child);
+        } else if (child instanceof ViewGroup) {
+            Object maybeScrollView = ViewUtils.findChildByClass((ViewGroup) child, ScrollView.class);
+            if (maybeScrollView instanceof ScrollView) {
+                onScrollViewAdded((ScrollView) maybeScrollView);
+            }
+        }
+    }
+
+    private void onScrollViewAdded(final ScrollView scrollView) {
+        if (scrollViewDelegate != null && !scrollViewDelegate.hasScrollView()) {
+            scrollViewDelegate.onScrollViewAdded(scrollView);
+            scrollViewAddedListener.onScrollViewAdded(scrollView);
+            scrollView.addOnAttachStateChangeListener(stateChangeListener);
+        }
+    }
+
+    public void destroy() {
+        scrollViewDelegate.getScrollView().removeOnAttachStateChangeListener(stateChangeListener);
+    }
+}

android/app/src/main/res/menu/search_item.xml

+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:id="@+id/toolbar_action_search"
+        android:title="Search"
+        android:icon="@drawable/search"
+        app:showAsAction="always|collapseActionView"
+        android:iconifiedByDefault="true"
+        app:actionViewClass="android.support.v7.widget.SearchView"/>
+</menu>

src/deprecated/platformSpecificDeprecated.android.js

     statusBarColor: originalStyleObject.statusBarColor,
     topBarColor: originalStyleObject.navBarBackgroundColor,
     topBarTransparent: originalStyleObject.navBarTransparent,
+    topBarTranslucent: originalStyleObject.navBarTranslucent,
     collapsingToolBarImage: originalStyleObject.collapsingToolBarImage,
     collapsingToolBarCollapsedColor: originalStyleObject.collapsingToolBarCollapsedColor,
     titleBarHidden: originalStyleObject.navBarHidden,
+    titleBarHideOnScroll: originalStyleObject.navBarHideOnScroll,
     titleBarTitleColor: originalStyleObject.navBarTextColor,
     titleBarSubtitleColor: originalStyleObject.navBarTextSubtitleColor,
     titleBarButtonColor: originalStyleObject.navBarButtonColor,