CR fixes

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

     @Override
     protected void createContent() {
         contentView = new ContentView(getContext(), screenParams.screenId, screenParams.navigationParams);
-        contentView.setViewMeasurer(new CollapsingContentViewMeasurer((CollapsingTopBar) topBar));
-        setupScrollDetection((CollapsingTopBar) topBar);
+        contentView.setViewMeasurer(new CollapsingContentViewMeasurer((CollapsingTopBar) topBar, this));
+        setupCollapseDetection((CollapsingTopBar) topBar);
         addView(contentView, createLayoutParams());
     }
 
-    private void setupScrollDetection(final CollapsingTopBar topBar) {
-        contentView.setupScrollDetection(new ScrollListener(topBar,
+    private void setupCollapseDetection(final CollapsingTopBar topBar) {
+        contentView.setupCollapseDetection(new ScrollListener(topBar,
                 new ScrollListener.OnScrollListener() {
                     @Override
                     public void onScroll(float amount) {

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

         viewMeasurer = new ViewMeasurer();
     }
 
-    public void setupScrollDetection(ScrollListener scrollListener) {
+    public void setupCollapseDetection(ScrollListener scrollListener) {
         scrollViewDelegate = new ScrollViewDelegate(scrollListener);
     }
 
         }
     }
 
-    private void onScrollViewAdded(ScrollView child) {
+    private void onScrollViewAdded(ScrollView scrollView) {
         if (scrollViewDelegate != null) {
-            scrollViewDelegate.onScrollViewAdded(child);
-            scrollViewAddedListener.onScrollViewAdded(child);
+            scrollViewDelegate.onScrollViewAdded(scrollView);
+            scrollViewAddedListener.onScrollViewAdded(scrollView);
         }
     }
 

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

 package com.reactnativenavigation.views.collapsingToolbar;
 
 public class CollapseAmount {
-    public static CollapseAmount NONE = new CollapseAmount();
+    public final static CollapseAmount None = new CollapseAmount();
     private Float amount;
 
     public CollapseAmount(float amount) {

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

 import android.view.MotionEvent;
 import android.widget.ScrollView;
 
-import com.reactnativenavigation.utils.ViewUtils;
-
 class CollapseCalculator {
     private float collapse;
     private MotionEvent previousTouchEvent;
     private boolean canExpend = false;
     private CollapsingView view;
     protected ScrollView scrollView;
-    private static float finalCollapsedTranslation;
 
     CollapseCalculator(final CollapsingView collapsingView) {
         this.view = collapsingView;
-        ViewUtils.runOnPreDraw(view.asView(), new Runnable() {
-            @Override
-            public void run() {
-                finalCollapsedTranslation = view.getFinalCollapseValue();
-            }
-        });
     }
 
     void setScrollView(ScrollView scrollView) {
     CollapseAmount calculate(MotionEvent event) {
         updateInitialTouchY(event);
         if (!isMoveEvent(event)) {
-            return CollapseAmount.NONE;
+            return CollapseAmount.None;
         }
 
-        if (shouldTranslateTopBarAndScrollView(event)) {
+        if (shouldCollapse(event)) {
             return calculateCollapse(event);
         } else {
             previousCollapseY = -1;
             previousTouchEvent = MotionEvent.obtain(event);
-            return CollapseAmount.NONE;
+            return CollapseAmount.None;
         }
     }
 
-    private boolean shouldTranslateTopBarAndScrollView(MotionEvent event) {
+    private boolean shouldCollapse(MotionEvent event) {
         checkCollapseLimits();
         ScrollDirection.Direction direction = getScrollDirection(event.getRawY());
-        return isMoveEvent(event) &&
-               (isNotCollapsedOrExpended() ||
+        return isNotCollapsedOrExpended() ||
                 (canCollapse && isExpendedAndScrollingUp(direction)) ||
-                (canExpend && isCollapsedAndScrollingDown(direction)));
+                (canExpend && isCollapsedAndScrollingDown(direction));
     }
 
     private ScrollDirection.Direction getScrollDirection(float y) {
     }
 
     private void checkCollapseLimits() {
-        float currentTopBarTranslation = view.getCurrentCollapseValue();
+        float currentCollapse = view.getCurrentCollapseValue();
         float finalExpendedTranslation = 0;
-        isExpended = isExpended(currentTopBarTranslation, finalExpendedTranslation);
-        isCollapsed = isCollapsed(currentTopBarTranslation, finalCollapsedTranslation);
-        canCollapse = calculateCanCollapse(currentTopBarTranslation, finalExpendedTranslation, finalCollapsedTranslation);
-        canExpend = calculateCanExpend(currentTopBarTranslation, finalExpendedTranslation, finalCollapsedTranslation);
+        isExpended = isExpended(currentCollapse, finalExpendedTranslation);
+        isCollapsed = isCollapsed(currentCollapse, view.getFinalCollapseValue());
+        canCollapse = calculateCanCollapse(currentCollapse, finalExpendedTranslation, view.getFinalCollapseValue());
+        canExpend = calculateCanExpend(currentCollapse, finalExpendedTranslation, view.getFinalCollapseValue());
     }
 
     private boolean calculateCanCollapse(float currentTopBarTranslation, float finalExpendedTranslation, float finalCollapsedTranslation) {
 
     private float calculateCollapse(float y) {
         float translation = y - previousCollapseY + view.getCurrentCollapseValue();
-        if (translation < finalCollapsedTranslation) {
-            translation = finalCollapsedTranslation;
+        if (translation < view.getFinalCollapseValue()) {
+            translation = view.getFinalCollapseValue();
         }
         final float expendedTranslation = 0;
         if (translation > expendedTranslation) {

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

 package com.reactnativenavigation.views.collapsingToolbar;
 
+import com.reactnativenavigation.screens.Screen;
+import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.views.utils.ViewMeasurer;
 
 public class CollapsingContentViewMeasurer extends ViewMeasurer {
-    private final float titleBarHeight;
-    public CollapsingContentViewMeasurer(CollapsingTopBar topBar) {
-        titleBarHeight = topBar.getTitleBarHeight();
+    private int titleBarHeight;
+    private int screenHeight;
+
+    public CollapsingContentViewMeasurer(final CollapsingTopBar topBar, final Screen collapsingSingleScreen) {
+        ViewUtils.runOnPreDraw(topBar, new Runnable() {
+            @Override
+            public void run() {
+                titleBarHeight = topBar.getCollapsedHeight();
+            }
+        });
+
+        ViewUtils.runOnPreDraw(collapsingSingleScreen, new Runnable() {
+            @Override
+            public void run() {
+                screenHeight = collapsingSingleScreen.getMeasuredHeight();
+            }
+        });
     }
 
     @Override
     public int getMeasuredHeight(int heightMeasureSpec) {
-        return (int) (super.getMeasuredHeight(heightMeasureSpec) + CollapsingToolBar.MAX_HEIGHT - titleBarHeight);
+        return screenHeight - titleBarHeight;
     }
 }

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

 import android.support.annotation.FloatRange;
 import android.support.v4.widget.TextViewCompat;
 import android.support.v7.widget.TintTypedArray;
+import android.text.TextPaint;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.Interpolator;
 import android.widget.FrameLayout;
     private TextView dummy;
     private String text;
     private Paint paint;
-    private float initialY;
+    private float initialY = -1;
     private float currentY;
     private float collapseY;
     private float collapseFraction;
-    private int[] positionOnScreen;
     private Interpolator scaleInterpolator;
     private float expendedTextSize;
     private float collapsedTextSize;
     }
 
     private void createTextPaint() {
-        paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.LINEAR_TEXT_FLAG);
+        paint = new TextPaint(Paint.ANTI_ALIAS_FLAG | Paint.LINEAR_TEXT_FLAG);
         paint.setColor(Color.GREEN);
         paint.setTextSize(expendedTextSize);
-
-        ViewUtils.runOnPreDraw(dummy, new Runnable() {
-            @Override
-            public void run() {
-                positionOnScreen = new int[2];
-                getLocationInWindow(positionOnScreen);
-                currentY = initialY = positionOnScreen[1] + getMeasuredHeight() - dummy.getMeasuredHeight();
-                float bottomMargin = ViewUtils.convertDpToPixel(10);
-                collapseY = positionOnScreen[1] + bottomMargin;
-                invalidate();
-            }
-        });
     }
 
     public void setText(String text) {
     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
+        if (initialY == -1) {
+            calculateTextPosition();
+        }
         paint.setTextSize(linearInterpolation(expendedTextSize, collapsedTextSize, collapseFraction));
         canvas.drawText(text, 0, currentY, paint);
     }
 
+    private void calculateTextPosition() {
+        final int[] positionOnScreen = new int[2];
+        getLocationInWindow(positionOnScreen);
+        currentY = initialY = positionOnScreen[1] + getMeasuredHeight() - dummy.getMeasuredHeight();
+        float bottomMargin = ViewUtils.convertDpToPixel(10);
+        collapseY = positionOnScreen[1] + bottomMargin;
+    }
+
     private float linearInterpolation(float from, float to, float fraction) {
         fraction = scaleInterpolator.getInterpolation(fraction);
         return from + (fraction * (to - from));

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

 import android.widget.ScrollView;
 
 import com.reactnativenavigation.params.CollapsingTopBarParams;
+import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.views.TitleBar;
 import com.reactnativenavigation.views.TopBar;
 
 public class CollapsingTopBar extends TopBar implements CollapsingView {
-    private CollapsingToolBar collapsingToolBar;
+    private CollapsingTopBarBackground collapsingTopBarBackground;
     private ScrollListener scrollListener;
+    private float finalCollapsedTranslation;
 
     public CollapsingTopBar(Context context, CollapsingTopBarParams params) {
         super(context);
         createCollapsingTopBar(params);
+        ViewUtils.runOnPreDraw(this, new Runnable() {
+            @Override
+            public void run() {
+                finalCollapsedTranslation = getCollapsingTopBarBackground().getCollapsedTopBarHeight() - getHeight();
+            }
+        });
+
     }
 
     public void setScrollListener(ScrollListener scrollListener) {
     }
 
     private void createCollapsingTopBar(CollapsingTopBarParams params) {
-        collapsingToolBar = new CollapsingToolBar(getContext(), params);
-        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, (int) CollapsingToolBar.MAX_HEIGHT);
-        titleBarAndContextualMenuContainer.addView(collapsingToolBar, lp);
+        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(),
-                collapsingToolBar.getCollapsedTopBarHeight(),
+                collapsingTopBarBackground.getCollapsedTopBarHeight(),
                 scrollListener);
     }
 
-    public int getTitleBarHeight() {
-        return titleBar.getMeasuredHeight();
-    }
-
-    public CollapsingToolBar getCollapsingToolBar() {
-        return collapsingToolBar;
+    public CollapsingTopBarBackground getCollapsingTopBarBackground() {
+        return collapsingTopBarBackground;
     }
 
     public void collapse(float collapse) {
         setTranslationY(collapse);
         ((CollapsingTitleBar) titleBar).collapse(collapse);
-        collapsingToolBar.collapse(collapse);
+        collapsingTopBarBackground.collapse(collapse);
     }
 
     public void onScrollViewAdded(ScrollView scrollView) {
 
     @Override
     public float getFinalCollapseValue() {
-        return getCollapsingToolBar().getCollapsedTopBarHeight() - getHeight();
+        return finalCollapsedTranslation;
+    }
+
+    public int getCollapsedHeight() {
+        return collapsingTopBarBackground.getCollapsedTopBarHeight();
     }
 
     @Override

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingToolBar.java → android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingTopBarBackground.java

 import android.widget.ImageView;
 
 import com.facebook.drawee.view.SimpleDraweeView;
-import com.reactnativenavigation.R;
 import com.reactnativenavigation.params.CollapsingTopBarParams;
 import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.views.Scrim;
 
 import static android.widget.FrameLayout.LayoutParams.MATCH_PARENT;
 
-public class CollapsingToolBar extends FrameLayout {
+public class CollapsingTopBarBackground extends FrameLayout {
     public static final float MAX_HEIGHT = ViewUtils.convertDpToPixel(256);
     private final CollapsingTopBarParams params;
     private SimpleDraweeView backdrop;
     private Scrim scrim;
     private int topBarHeight = -1;
 
-    public CollapsingToolBar(Context context, CollapsingTopBarParams params) {
+    public CollapsingTopBarBackground(Context context, CollapsingTopBarParams params) {
         super(context);
         this.params = params;
         setFitsSystemWindows(true);
         return topBarHeight;
     }
     private void calculateTopBarHeight() {
-        int[] attrs = new int[] {R.attr.actionBarSize};
+        int[] attrs = new int[] {android.R.attr.actionBarSize};
         TypedArray ta = getContext().obtainStyledAttributes(attrs);
         topBarHeight = ta.getDimensionPixelSize(0, -1);
         ta.recycle();

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

 
     @Override
     public boolean onTouch(MotionEvent event) {
-        return handleTouch(event);
-    }
-
-    private boolean handleTouch(MotionEvent event) {
         CollapseAmount amount = collapseCalculator.calculate(event);
         if (amount.canCollapse()) {
             scrollListener.onScroll(amount.get());

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

 
     public void onScrollViewAdded(ScrollView scrollView) {
         this.scrollView = scrollView;
-        this.scrollView.setScrollbarFadingEnabled(false);
         listener.onScrollViewAdded(this.scrollView);
     }