src/com/android/camera/widget/FilmstripLayout.java - platform/packages/apps/Camera2 - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.camera.widget;

 import android.animation.Animator;
 import android.animation.TimeInterpolator;
 import android.animation.ValueAnimator;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.ColorFilter;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
 import android.graphics.drawable.Drawable;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.animation.AnimationUtils;
 import android.widget.FrameLayout;

 import com.android.camera.filmstrip.FilmstripContentPanel;
 import com.android.camera.filmstrip.FilmstripController;
 import com.android.camera.ui.FilmstripGestureRecognizer;
 import com.android.camera.util.ApiHelper;
 import com.android.camera.util.Gusterpolator;
 import com.android.camera2.R;

 /**
  * A {@link android.widget.FrameLayout} used for the parent layout of a
  * {@link com.android.camera.widget.FilmstripView} to support animating in/out the
  * filmstrip.
  */
 public class FilmstripLayout extends FrameLayout implements FilmstripContentPanel {

     private static final long DEFAULT_DURATION_MS = 250;
     /**
      *  If the fling velocity exceeds this threshold, open filmstrip at a constant
      *  speed. Unit: pixel/ms.
      */
     private static final float FLING_VELOCITY_THRESHOLD = 4.0f;

     /**
      * The layout containing the {@link com.android.camera.widget.FilmstripView}
      * and other controls.
      */
     private FrameLayout mFilmstripContentLayout;
     private FilmstripView mFilmstripView;
     private FilmstripGestureRecognizer mGestureRecognizer;
     private FilmstripGestureRecognizer.Listener mFilmstripGestureListener;
     private final ValueAnimator mFilmstripAnimator = ValueAnimator.ofFloat(null);
     private int mSwipeTrend;
     private FilmstripBackground mBackgroundDrawable;
     private Handler mHandler;
     // We use this to record the current translation position instead of using
     // the real value because we might set the translation before onMeasure()
     // thus getMeasuredWidth() can be 0.
     private float mFilmstripContentTranslationProgress;

     private Animator.AnimatorListener mFilmstripAnimatorListener = new Animator.AnimatorListener() {
         private boolean mCanceled;

         @Override
         public void onAnimationStart(Animator animator) {
             mCanceled = false;
         }

         @Override
         public void onAnimationEnd(Animator animator) {
             if (!mCanceled) {
                 if (mFilmstripContentTranslationProgress != 0f) {
                     mFilmstripView.getController().goToFilmstrip();
                     setVisibility(INVISIBLE);
                 } else {
                     notifyShown();
                 }
             }
         }

         @Override
         public void onAnimationCancel(Animator animator) {
             mCanceled = true;
         }

         @Override
         public void onAnimationRepeat(Animator animator) {
             // Nothing.
         }
     };

     private ValueAnimator.AnimatorUpdateListener mFilmstripAnimatorUpdateListener =
             new ValueAnimator.AnimatorUpdateListener() {
                 @Override
                 public void onAnimationUpdate(ValueAnimator valueAnimator) {
                     translateContentLayout((Float) valueAnimator.getAnimatedValue());
                     mBackgroundDrawable.invalidateSelf();
                 }
             };
     private Listener mListener;

     public FilmstripLayout(Context context) {
         super(context);
         init(context);
     }

     public FilmstripLayout(Context context, AttributeSet attrs) {
         super(context, attrs);
         init(context);
     }

     public FilmstripLayout(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         init(context);
     }

     private void init(Context context) {
         mGestureRecognizer = new FilmstripGestureRecognizer(context, new OpenFilmstripGesture());
         mFilmstripAnimator.setDuration(DEFAULT_DURATION_MS);
         TimeInterpolator interpolator;
         if (ApiHelper.isLOrHigher()) {
             interpolator = AnimationUtils.loadInterpolator(
                     getContext(), android.R.interpolator.fast_out_slow_in);
         } else {
             interpolator = Gusterpolator.INSTANCE;
         }
         mFilmstripAnimator.setInterpolator(interpolator);
         mFilmstripAnimator.addUpdateListener(mFilmstripAnimatorUpdateListener);
         mFilmstripAnimator.addListener(mFilmstripAnimatorListener);
         mHandler = new Handler(Looper.getMainLooper());
         mBackgroundDrawable = new FilmstripBackground();
         mBackgroundDrawable.setCallback(new Drawable.Callback() {
             @Override
             public void invalidateDrawable(Drawable drawable) {
                 FilmstripLayout.this.invalidate();
             }

             @Override
             public void scheduleDrawable(Drawable drawable, Runnable runnable, long l) {
                 mHandler.postAtTime(runnable, drawable, l);
             }

             @Override
             public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
                 mHandler.removeCallbacks(runnable, drawable);
             }
         });
         setBackground(mBackgroundDrawable);
     }

     @Override
     public void setFilmstripListener(Listener listener) {
         mListener = listener;
         if (getVisibility() == VISIBLE && mFilmstripContentTranslationProgress == 0f) {
             notifyShown();
         } else {
             if (getVisibility() != VISIBLE) {
                 notifyHidden();
             }
         }
         mFilmstripView.getController().setListener(listener);
     }

     @Override
     public void hide() {
         translateContentLayout(1f);
         mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
     }

     @Override
     public void show() {
         translateContentLayout(0f);
         mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
     }

     @Override
     public void setVisibility(int visibility) {
         super.setVisibility(visibility);
         if (visibility != VISIBLE) {
             notifyHidden();
         }
     }

     private void notifyHidden() {
         if (mListener == null) {
             return;
         }
         mListener.onFilmstripHidden();
     }

     private void notifyShown() {
         if (mListener == null) {
             return;
         }
         mListener.onFilmstripShown();
         mFilmstripView.zoomAtIndexChanged();
         FilmstripController controller = mFilmstripView.getController();
         int currentId = controller.getCurrentAdapterIndex();
         if (controller.inFilmstrip()) {
             mListener.onEnterFilmstrip(currentId);
         } else if (controller.inFullScreen()) {
             mListener.onEnterFullScreenUiShown(currentId);
         }
     }

     @Override
     public void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
         if (changed && mFilmstripView != null && getVisibility() == INVISIBLE) {
             hide();
         } else {
             translateContentLayout(mFilmstripContentTranslationProgress);
         }
     }

     @Override
     public boolean onTouchEvent(MotionEvent ev) {
         return mGestureRecognizer.onTouchEvent(ev);
     }

     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
             // TODO: Remove this after the touch flow refactor is done in
             // MainAtivityLayout.
             getParent().requestDisallowInterceptTouchEvent(true);
         }
         return false;
     }

     @Override
     public void onFinishInflate() {
         mFilmstripView = (FilmstripView) findViewById(R.id.filmstrip_view);
         mFilmstripView.setOnTouchListener(new OnTouchListener() {

             @Override
             public boolean onTouch(View view, MotionEvent motionEvent) {
                 // Adjust the coordinates back since they are relative to the
                 // child view.
                 motionEvent.setLocation(motionEvent.getX() + mFilmstripContentLayout.getX(),
                         motionEvent.getY() + mFilmstripContentLayout.getY());
                 mGestureRecognizer.onTouchEvent(motionEvent);
                 return true;
             }
         });
         mFilmstripGestureListener = mFilmstripView.getGestureListener();
         mFilmstripContentLayout = (FrameLayout) findViewById(R.id.camera_filmstrip_content_layout);
     }

     @Override
     public boolean onBackPressed() {
         return animateHide();
     }

     @Override
     public boolean animateHide() {
         if (getVisibility() == VISIBLE) {
             if (!mFilmstripAnimator.isRunning()) {
                 hideFilmstrip();
             }
             return true;
         }
         return false;
     }

     public void hideFilmstrip() {
         // run the same view show/hides and animations
         // that happen with a swipe gesture.
         onSwipeOutBegin();
         runAnimation(mFilmstripContentTranslationProgress, 1f);
     }

     public void showFilmstrip() {
         setVisibility(VISIBLE);
         runAnimation(mFilmstripContentTranslationProgress, 0f);
     }

     private void runAnimation(float begin, float end) {
         if (mFilmstripAnimator.isRunning()) {
             return;
         }
         if (begin == end) {
             // No need to start animation.
             mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
             return;
         }
         mFilmstripAnimator.setFloatValues(begin, end);
         mFilmstripAnimator.start();
     }

     private void translateContentLayout(float fraction) {
         mFilmstripContentTranslationProgress = fraction;
         mFilmstripContentLayout.setTranslationX(fraction * getMeasuredWidth());
     }

     private void translateContentLayoutByPixel(float pixel) {
         mFilmstripContentLayout.setTranslationX(pixel);
         mFilmstripContentTranslationProgress = pixel / getMeasuredWidth();
     }

     private void onSwipeOut() {
         if (mListener != null) {
             mListener.onSwipeOut();
         }
     }

     private void onSwipeOutBegin() {
         if (mListener != null) {
             mListener.onSwipeOutBegin();
         }
     }

     /**
      * A gesture listener which passes all the gestures to the
      * {@code mFilmstripView} by default and only intercepts scroll gestures
      * when the {@code mFilmstripView} is not in full-screen.
      */
     private class OpenFilmstripGesture implements FilmstripGestureRecognizer.Listener {
         @Override
         public boolean onScroll(float x, float y, float dx, float dy) {
             if (mFilmstripView.getController().getCurrentAdapterIndex() == -1) {
                 return true;
             }
             if (mFilmstripAnimator.isRunning()) {
                 return true;
             }
             if (mFilmstripContentLayout.getTranslationX() == 0f &&
                     mFilmstripGestureListener.onScroll(x, y, dx, dy)) {
                 return true;
             }
             mSwipeTrend = (((int) dx) >> 1) + (mSwipeTrend >> 1);
             if (dx < 0 && mFilmstripContentLayout.getTranslationX() == 0) {
                 mBackgroundDrawable.setOffset(0);
                 FilmstripLayout.this.onSwipeOutBegin();
             }

             // When we start translating the filmstrip in, we want the left edge of the
             // first view to always be at the rightmost edge of the screen so that it
             // appears instantly, regardless of the view's distance from the edge of the
             // filmstrip view. To do so, on our first translation, jump the filmstrip view
             // to the correct position, and then smoothly animate the translation from that
             // initial point.
             if (dx > 0 && mFilmstripContentLayout.getTranslationX() == getMeasuredWidth()) {
                 final int currentItemLeft = mFilmstripView.getCurrentItemLeft();
                 dx = currentItemLeft;
                 mBackgroundDrawable.setOffset(currentItemLeft);
             }

             float translate = mFilmstripContentLayout.getTranslationX() - dx;
             if (translate < 0f) {
                 translate = 0f;
             } else {
                 if (translate > getMeasuredWidth()) {
                     translate = getMeasuredWidth();
                 }
             }
             translateContentLayoutByPixel(translate);
             if (translate == 0 && dx > 0) {
                 // This will only happen once since when this condition holds
                 // the onScroll() callback will be forwarded to the filmstrip
                 // view.
                 mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
             }
             mBackgroundDrawable.invalidateSelf();
             return true;
         }

         @Override
         public boolean onMouseScroll(float hscroll, float vscroll) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onMouseScroll(hscroll, vscroll);
             }
             return false;
         }

         @Override
         public boolean onSingleTapUp(float x, float y) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onSingleTapUp(x, y);
             }
             return false;
         }

         @Override
         public boolean onDoubleTap(float x, float y) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onDoubleTap(x, y);
             }
             return false;
         }

         /**
          * @param velocityX The fling velocity in the X direction.
          * @return Whether the filmstrip should be opened,
          * given velocityX and mSwipeTrend.
          */
         private boolean flingShouldOpenFilmstrip(float velocityX) {
             return (mSwipeTrend > 0) &&
                     (velocityX < 0.0f) &&
                     (Math.abs(velocityX / 1000.0f) > FLING_VELOCITY_THRESHOLD);
         }

         @Override
         public boolean onFling(float velocityX, float velocityY) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onFling(velocityX, velocityY);
             } else if (flingShouldOpenFilmstrip(velocityX)) {
                 showFilmstrip();
                 return true;
             }

             return false;
         }

         @Override
         public boolean onScaleBegin(float focusX, float focusY) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onScaleBegin(focusX, focusY);
             }
             return false;
         }

         @Override
         public boolean onScale(float focusX, float focusY, float scale) {
             if (mFilmstripContentTranslationProgress == 0f) {
                 return mFilmstripGestureListener.onScale(focusX, focusY, scale);
             }
             return false;
         }

         @Override
         public boolean onDown(float x, float y) {
             if (mFilmstripContentLayout.getTranslationX() == 0f) {
                 return mFilmstripGestureListener.onDown(x, y);
             }
             return false;
         }

         @Override
         public boolean onUp(float x, float y) {
             if (mFilmstripContentLayout.getTranslationX() == 0f) {
                 return mFilmstripGestureListener.onUp(x, y);
             }
             if (mSwipeTrend < 0) {
                 hideFilmstrip();
                 onSwipeOut();
             } else {
                 if (mFilmstripContentLayout.getTranslationX() >= getMeasuredWidth() / 2) {
                     hideFilmstrip();
                     onSwipeOut();
                 } else {
                     showFilmstrip();
                 }
             }
             mSwipeTrend = 0;
             return false;
         }

         @Override
         public void onLongPress(float x, float y) {
             mFilmstripGestureListener.onLongPress(x, y);
         }

         @Override
         public void onScaleEnd() {
             if (mFilmstripContentLayout.getTranslationX() == 0f) {
                 mFilmstripGestureListener.onScaleEnd();
             }
         }
     }

     private class FilmstripBackground extends Drawable {
         private Paint mPaint;
         private int mOffset;

         public FilmstripBackground() {
             mPaint = new Paint();
             mPaint.setAntiAlias(true);
             mPaint.setColor(getResources().getColor(R.color.camera_gray_background));
             mPaint.setAlpha(255);
         }

         /**
          * Adjust the target width and translation calculation when we start translating
          * from a point where width != translationX so that alpha scales smoothly.
          */
         public void setOffset(int offset) {
             mOffset = offset;
         }

         @Override
         public void setAlpha(int i) {
             mPaint.setAlpha(i);
         }

         private void setAlpha(float a) {
             setAlpha((int) (a*255.0f));
         }

         @Override
         public void setColorFilter(ColorFilter colorFilter) {
             mPaint.setColorFilter(colorFilter);
         }

         @Override
         public int getOpacity() {
             return PixelFormat.TRANSLUCENT;
         }

         @Override
         public void draw(Canvas canvas) {
             int width = getMeasuredWidth() - mOffset;
             float translation = mFilmstripContentLayout.getTranslationX() - mOffset;
             if (translation == width) {
                 return;
             }

             setAlpha(1.0f - mFilmstripContentTranslationProgress);
             canvas.drawRect(0, 0, getMeasuredWidth(), getMeasuredHeight(), mPaint);
         }
     }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.camera.widget;

	import android.animation.Animator;
	import android.animation.TimeInterpolator;
	import android.animation.ValueAnimator;
	import android.content.Context;
	import android.graphics.Canvas;
	import android.graphics.ColorFilter;
	import android.graphics.Paint;
	import android.graphics.PixelFormat;
	import android.graphics.drawable.Drawable;
	import android.os.Handler;
	import android.os.Looper;
	import android.util.AttributeSet;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.animation.AnimationUtils;
	import android.widget.FrameLayout;

	import com.android.camera.filmstrip.FilmstripContentPanel;
	import com.android.camera.filmstrip.FilmstripController;
	import com.android.camera.ui.FilmstripGestureRecognizer;
	import com.android.camera.util.ApiHelper;
	import com.android.camera.util.Gusterpolator;
	import com.android.camera2.R;

	/**
	* A {@link android.widget.FrameLayout} used for the parent layout of a
	* {@link com.android.camera.widget.FilmstripView} to support animating in/out the
	* filmstrip.
	*/
	public class FilmstripLayout extends FrameLayout implements FilmstripContentPanel {

	private static final long DEFAULT_DURATION_MS = 250;
	/**
	* If the fling velocity exceeds this threshold, open filmstrip at a constant
	* speed. Unit: pixel/ms.
	*/
	private static final float FLING_VELOCITY_THRESHOLD = 4.0f;

	/**
	* The layout containing the {@link com.android.camera.widget.FilmstripView}
	* and other controls.
	*/
	private FrameLayout mFilmstripContentLayout;
	private FilmstripView mFilmstripView;
	private FilmstripGestureRecognizer mGestureRecognizer;
	private FilmstripGestureRecognizer.Listener mFilmstripGestureListener;
	private final ValueAnimator mFilmstripAnimator = ValueAnimator.ofFloat(null);
	private int mSwipeTrend;
	private FilmstripBackground mBackgroundDrawable;
	private Handler mHandler;
	// We use this to record the current translation position instead of using
	// the real value because we might set the translation before onMeasure()
	// thus getMeasuredWidth() can be 0.
	private float mFilmstripContentTranslationProgress;

	private Animator.AnimatorListener mFilmstripAnimatorListener = new Animator.AnimatorListener() {
	private boolean mCanceled;

	@Override
	public void onAnimationStart(Animator animator) {
	mCanceled = false;
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	if (!mCanceled) {
	if (mFilmstripContentTranslationProgress != 0f) {
	mFilmstripView.getController().goToFilmstrip();
	setVisibility(INVISIBLE);
	} else {
	notifyShown();
	}
	}
	}

	@Override
	public void onAnimationCancel(Animator animator) {
	mCanceled = true;
	}

	@Override
	public void onAnimationRepeat(Animator animator) {
	// Nothing.
	}
	};

	private ValueAnimator.AnimatorUpdateListener mFilmstripAnimatorUpdateListener =
	new ValueAnimator.AnimatorUpdateListener() {
	@Override
	public void onAnimationUpdate(ValueAnimator valueAnimator) {
	translateContentLayout((Float) valueAnimator.getAnimatedValue());
	mBackgroundDrawable.invalidateSelf();
	}
	};
	private Listener mListener;

	public FilmstripLayout(Context context) {
	super(context);
	init(context);
	}

	public FilmstripLayout(Context context, AttributeSet attrs) {
	super(context, attrs);
	init(context);
	}

	public FilmstripLayout(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	init(context);
	}

	private void init(Context context) {
	mGestureRecognizer = new FilmstripGestureRecognizer(context, new OpenFilmstripGesture());
	mFilmstripAnimator.setDuration(DEFAULT_DURATION_MS);
	TimeInterpolator interpolator;
	if (ApiHelper.isLOrHigher()) {
	interpolator = AnimationUtils.loadInterpolator(
	getContext(), android.R.interpolator.fast_out_slow_in);
	} else {
	interpolator = Gusterpolator.INSTANCE;
	}
	mFilmstripAnimator.setInterpolator(interpolator);
	mFilmstripAnimator.addUpdateListener(mFilmstripAnimatorUpdateListener);
	mFilmstripAnimator.addListener(mFilmstripAnimatorListener);
	mHandler = new Handler(Looper.getMainLooper());
	mBackgroundDrawable = new FilmstripBackground();
	mBackgroundDrawable.setCallback(new Drawable.Callback() {
	@Override
	public void invalidateDrawable(Drawable drawable) {
	FilmstripLayout.this.invalidate();
	}

	@Override
	public void scheduleDrawable(Drawable drawable, Runnable runnable, long l) {
	mHandler.postAtTime(runnable, drawable, l);
	}

	@Override
	public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
	mHandler.removeCallbacks(runnable, drawable);
	}
	});
	setBackground(mBackgroundDrawable);
	}

	@Override
	public void setFilmstripListener(Listener listener) {
	mListener = listener;
	if (getVisibility() == VISIBLE && mFilmstripContentTranslationProgress == 0f) {
	notifyShown();
	} else {
	if (getVisibility() != VISIBLE) {
	notifyHidden();
	}
	}
	mFilmstripView.getController().setListener(listener);
	}

	@Override
	public void hide() {
	translateContentLayout(1f);
	mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
	}

	@Override
	public void show() {
	translateContentLayout(0f);
	mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
	}

	@Override
	public void setVisibility(int visibility) {
	super.setVisibility(visibility);
	if (visibility != VISIBLE) {
	notifyHidden();
	}
	}

	private void notifyHidden() {
	if (mListener == null) {
	return;
	}
	mListener.onFilmstripHidden();
	}

	private void notifyShown() {
	if (mListener == null) {
	return;
	}
	mListener.onFilmstripShown();
	mFilmstripView.zoomAtIndexChanged();
	FilmstripController controller = mFilmstripView.getController();
	int currentId = controller.getCurrentAdapterIndex();
	if (controller.inFilmstrip()) {
	mListener.onEnterFilmstrip(currentId);
	} else if (controller.inFullScreen()) {
	mListener.onEnterFullScreenUiShown(currentId);
	}
	}

	@Override
	public void onLayout(boolean changed, int l, int t, int r, int b) {
	super.onLayout(changed, l, t, r, b);
	if (changed && mFilmstripView != null && getVisibility() == INVISIBLE) {
	hide();
	} else {
	translateContentLayout(mFilmstripContentTranslationProgress);
	}
	}

	@Override
	public boolean onTouchEvent(MotionEvent ev) {
	return mGestureRecognizer.onTouchEvent(ev);
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent ev) {
	if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
	// TODO: Remove this after the touch flow refactor is done in
	// MainAtivityLayout.
	getParent().requestDisallowInterceptTouchEvent(true);
	}
	return false;
	}

	@Override
	public void onFinishInflate() {
	mFilmstripView = (FilmstripView) findViewById(R.id.filmstrip_view);
	mFilmstripView.setOnTouchListener(new OnTouchListener() {

	@Override
	public boolean onTouch(View view, MotionEvent motionEvent) {
	// Adjust the coordinates back since they are relative to the
	// child view.
	motionEvent.setLocation(motionEvent.getX() + mFilmstripContentLayout.getX(),
	motionEvent.getY() + mFilmstripContentLayout.getY());
	mGestureRecognizer.onTouchEvent(motionEvent);
	return true;
	}
	});
	mFilmstripGestureListener = mFilmstripView.getGestureListener();
	mFilmstripContentLayout = (FrameLayout) findViewById(R.id.camera_filmstrip_content_layout);
	}

	@Override
	public boolean onBackPressed() {
	return animateHide();
	}

	@Override
	public boolean animateHide() {
	if (getVisibility() == VISIBLE) {
	if (!mFilmstripAnimator.isRunning()) {
	hideFilmstrip();
	}
	return true;
	}
	return false;
	}

	public void hideFilmstrip() {
	// run the same view show/hides and animations
	// that happen with a swipe gesture.
	onSwipeOutBegin();
	runAnimation(mFilmstripContentTranslationProgress, 1f);
	}

	public void showFilmstrip() {
	setVisibility(VISIBLE);
	runAnimation(mFilmstripContentTranslationProgress, 0f);
	}

	private void runAnimation(float begin, float end) {
	if (mFilmstripAnimator.isRunning()) {
	return;
	}
	if (begin == end) {
	// No need to start animation.
	mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
	return;
	}
	mFilmstripAnimator.setFloatValues(begin, end);
	mFilmstripAnimator.start();
	}

	private void translateContentLayout(float fraction) {
	mFilmstripContentTranslationProgress = fraction;
	mFilmstripContentLayout.setTranslationX(fraction * getMeasuredWidth());
	}

	private void translateContentLayoutByPixel(float pixel) {
	mFilmstripContentLayout.setTranslationX(pixel);
	mFilmstripContentTranslationProgress = pixel / getMeasuredWidth();
	}

	private void onSwipeOut() {
	if (mListener != null) {
	mListener.onSwipeOut();
	}
	}

	private void onSwipeOutBegin() {
	if (mListener != null) {
	mListener.onSwipeOutBegin();
	}
	}

	/**
	* A gesture listener which passes all the gestures to the
	* {@code mFilmstripView} by default and only intercepts scroll gestures
	* when the {@code mFilmstripView} is not in full-screen.
	*/
	private class OpenFilmstripGesture implements FilmstripGestureRecognizer.Listener {
	@Override
	public boolean onScroll(float x, float y, float dx, float dy) {
	if (mFilmstripView.getController().getCurrentAdapterIndex() == -1) {
	return true;
	}
	if (mFilmstripAnimator.isRunning()) {
	return true;
	}
	if (mFilmstripContentLayout.getTranslationX() == 0f &&
	mFilmstripGestureListener.onScroll(x, y, dx, dy)) {
	return true;
	}
	mSwipeTrend = (((int) dx) >> 1) + (mSwipeTrend >> 1);
	if (dx < 0 && mFilmstripContentLayout.getTranslationX() == 0) {
	mBackgroundDrawable.setOffset(0);
	FilmstripLayout.this.onSwipeOutBegin();
	}

	// When we start translating the filmstrip in, we want the left edge of the
	// first view to always be at the rightmost edge of the screen so that it
	// appears instantly, regardless of the view's distance from the edge of the
	// filmstrip view. To do so, on our first translation, jump the filmstrip view
	// to the correct position, and then smoothly animate the translation from that
	// initial point.
	if (dx > 0 && mFilmstripContentLayout.getTranslationX() == getMeasuredWidth()) {
	final int currentItemLeft = mFilmstripView.getCurrentItemLeft();
	dx = currentItemLeft;
	mBackgroundDrawable.setOffset(currentItemLeft);
	}

	float translate = mFilmstripContentLayout.getTranslationX() - dx;
	if (translate < 0f) {
	translate = 0f;
	} else {
	if (translate > getMeasuredWidth()) {
	translate = getMeasuredWidth();
	}
	}
	translateContentLayoutByPixel(translate);
	if (translate == 0 && dx > 0) {
	// This will only happen once since when this condition holds
	// the onScroll() callback will be forwarded to the filmstrip
	// view.
	mFilmstripAnimatorListener.onAnimationEnd(mFilmstripAnimator);
	}
	mBackgroundDrawable.invalidateSelf();
	return true;
	}

	@Override
	public boolean onMouseScroll(float hscroll, float vscroll) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onMouseScroll(hscroll, vscroll);
	}
	return false;
	}

	@Override
	public boolean onSingleTapUp(float x, float y) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onSingleTapUp(x, y);
	}
	return false;
	}

	@Override
	public boolean onDoubleTap(float x, float y) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onDoubleTap(x, y);
	}
	return false;
	}

	/**
	* @param velocityX The fling velocity in the X direction.
	* @return Whether the filmstrip should be opened,
	* given velocityX and mSwipeTrend.
	*/
	private boolean flingShouldOpenFilmstrip(float velocityX) {
	return (mSwipeTrend > 0) &&
	(velocityX < 0.0f) &&
	(Math.abs(velocityX / 1000.0f) > FLING_VELOCITY_THRESHOLD);
	}

	@Override
	public boolean onFling(float velocityX, float velocityY) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onFling(velocityX, velocityY);
	} else if (flingShouldOpenFilmstrip(velocityX)) {
	showFilmstrip();
	return true;
	}

	return false;
	}

	@Override
	public boolean onScaleBegin(float focusX, float focusY) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onScaleBegin(focusX, focusY);
	}
	return false;
	}

	@Override
	public boolean onScale(float focusX, float focusY, float scale) {
	if (mFilmstripContentTranslationProgress == 0f) {
	return mFilmstripGestureListener.onScale(focusX, focusY, scale);
	}
	return false;
	}

	@Override
	public boolean onDown(float x, float y) {
	if (mFilmstripContentLayout.getTranslationX() == 0f) {
	return mFilmstripGestureListener.onDown(x, y);
	}
	return false;
	}

	@Override
	public boolean onUp(float x, float y) {
	if (mFilmstripContentLayout.getTranslationX() == 0f) {
	return mFilmstripGestureListener.onUp(x, y);
	}
	if (mSwipeTrend < 0) {
	hideFilmstrip();
	onSwipeOut();
	} else {
	if (mFilmstripContentLayout.getTranslationX() >= getMeasuredWidth() / 2) {
	hideFilmstrip();
	onSwipeOut();
	} else {
	showFilmstrip();
	}
	}
	mSwipeTrend = 0;
	return false;
	}

	@Override
	public void onLongPress(float x, float y) {
	mFilmstripGestureListener.onLongPress(x, y);
	}

	@Override
	public void onScaleEnd() {
	if (mFilmstripContentLayout.getTranslationX() == 0f) {
	mFilmstripGestureListener.onScaleEnd();
	}
	}
	}

	private class FilmstripBackground extends Drawable {
	private Paint mPaint;
	private int mOffset;

	public FilmstripBackground() {
	mPaint = new Paint();
	mPaint.setAntiAlias(true);
	mPaint.setColor(getResources().getColor(R.color.camera_gray_background));
	mPaint.setAlpha(255);
	}

	/**
	* Adjust the target width and translation calculation when we start translating
	* from a point where width != translationX so that alpha scales smoothly.
	*/
	public void setOffset(int offset) {
	mOffset = offset;
	}

	@Override
	public void setAlpha(int i) {
	mPaint.setAlpha(i);
	}

	private void setAlpha(float a) {
	setAlpha((int) (a*255.0f));
	}

	@Override
	public void setColorFilter(ColorFilter colorFilter) {
	mPaint.setColorFilter(colorFilter);
	}

	@Override
	public int getOpacity() {
	return PixelFormat.TRANSLUCENT;
	}

	@Override
	public void draw(Canvas canvas) {
	int width = getMeasuredWidth() - mOffset;
	float translation = mFilmstripContentLayout.getTranslationX() - mOffset;
	if (translation == width) {
	return;
	}

	setAlpha(1.0f - mFilmstripContentTranslationProgress);
	canvas.drawRect(0, 0, getMeasuredWidth(), getMeasuredHeight(), mPaint);
	}
	}
	}