| /* |
| * Copyright (C) 2012 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.dreams.phototable; |
| |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.PointF; |
| import android.graphics.PorterDuff; |
| import android.graphics.Rect; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.drawable.LayerDrawable; |
| import android.os.AsyncTask; |
| import android.service.dreams.DreamService; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ViewPropertyAnimator; |
| import android.view.animation.DecelerateInterpolator; |
| import android.view.animation.Interpolator; |
| import android.widget.FrameLayout; |
| import android.widget.ImageView; |
| |
| import java.util.ArrayList; |
| import java.util.Formatter; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Random; |
| import java.util.Set; |
| |
| /** |
| * A surface where photos sit. |
| */ |
| public class PhotoTable extends FrameLayout { |
| private static final String TAG = "PhotoTable"; |
| private static final boolean DEBUG = false; |
| |
| class Launcher implements Runnable { |
| @Override |
| public void run() { |
| PhotoTable.this.scheduleNext(mDropPeriod); |
| PhotoTable.this.launch(); |
| } |
| } |
| |
| class FocusReaper implements Runnable { |
| @Override |
| public void run() { |
| PhotoTable.this.clearFocus(); |
| } |
| } |
| |
| class SelectionReaper implements Runnable { |
| @Override |
| public void run() { |
| PhotoTable.this.clearSelection(); |
| } |
| } |
| |
| private static final int NEXT = 1; |
| private static final int PREV = 0; |
| private static Random sRNG = new Random(); |
| |
| private final Launcher mLauncher; |
| private final FocusReaper mFocusReaper; |
| private final SelectionReaper mSelectionReaper; |
| private final LinkedList<View> mOnTable; |
| private final int mDropPeriod; |
| private final int mFastDropPeriod; |
| private final int mNowDropDelay; |
| private final float mImageRatio; |
| private final float mTableRatio; |
| private final float mImageRotationLimit; |
| private final float mThrowRotation; |
| private final float mThrowSpeed; |
| private final boolean mTapToExit; |
| private final int mTableCapacity; |
| private final int mRedealCount; |
| private final int mInset; |
| private final PhotoSource mPhotoSource; |
| private final Resources mResources; |
| private final Interpolator mThrowInterpolator; |
| private final Interpolator mDropInterpolator; |
| private final DragGestureDetector mDragGestureDetector; |
| private final EdgeSwipeDetector mEdgeSwipeDetector; |
| private final KeyboardInterpreter mKeyboardInterpreter; |
| private final boolean mStoryModeEnabled; |
| private final long mPickUpDuration; |
| private final int mMaxSelectionTime; |
| private final int mMaxFocusTime; |
| private final List<View> mAnimating; |
| |
| private DreamService mDream; |
| private PhotoLaunchTask mPhotoLaunchTask; |
| private LoadNaturalSiblingTask mLoadOnDeckTasks[]; |
| private boolean mStarted; |
| private boolean mIsLandscape; |
| private int mLongSide; |
| private int mShortSide; |
| private int mWidth; |
| private int mHeight; |
| private View mSelection; |
| private View mOnDeck[]; |
| private View mFocus; |
| private int mHighlightColor; |
| private ViewGroup mBackground; |
| private ViewGroup mStageLeft; |
| |
| public PhotoTable(Context context, AttributeSet as) { |
| super(context, as); |
| mResources = getResources(); |
| mInset = mResources.getDimensionPixelSize(R.dimen.photo_inset); |
| mDropPeriod = mResources.getInteger(R.integer.table_drop_period); |
| mFastDropPeriod = mResources.getInteger(R.integer.fast_drop); |
| mNowDropDelay = mResources.getInteger(R.integer.now_drop); |
| mImageRatio = mResources.getInteger(R.integer.image_ratio) / 1000000f; |
| mTableRatio = mResources.getInteger(R.integer.table_ratio) / 1000000f; |
| mImageRotationLimit = (float) mResources.getInteger(R.integer.max_image_rotation); |
| mThrowSpeed = mResources.getDimension(R.dimen.image_throw_speed); |
| mPickUpDuration = mResources.getInteger(R.integer.photo_pickup_duration); |
| mThrowRotation = (float) mResources.getInteger(R.integer.image_throw_rotatioan); |
| mTableCapacity = mResources.getInteger(R.integer.table_capacity); |
| mRedealCount = mResources.getInteger(R.integer.redeal_count); |
| mTapToExit = mResources.getBoolean(R.bool.enable_tap_to_exit); |
| mStoryModeEnabled = mResources.getBoolean(R.bool.enable_story_mode); |
| mHighlightColor = mResources.getColor(R.color.highlight_color); |
| mMaxSelectionTime = mResources.getInteger(R.integer.max_selection_time); |
| mMaxFocusTime = mResources.getInteger(R.integer.max_focus_time); |
| mThrowInterpolator = new SoftLandingInterpolator( |
| mResources.getInteger(R.integer.soft_landing_time) / 1000000f, |
| mResources.getInteger(R.integer.soft_landing_distance) / 1000000f); |
| mDropInterpolator = new DecelerateInterpolator( |
| (float) mResources.getInteger(R.integer.drop_deceleration_exponent)); |
| mOnTable = new LinkedList<View>(); |
| mPhotoSource = new PhotoSourcePlexor(getContext(), |
| getContext().getSharedPreferences(PhotoTableDreamSettings.PREFS_NAME, 0)); |
| mAnimating = new ArrayList<View>(); |
| mLauncher = new Launcher(); |
| mFocusReaper = new FocusReaper(); |
| mSelectionReaper = new SelectionReaper(); |
| mDragGestureDetector = new DragGestureDetector(context, this); |
| mEdgeSwipeDetector = new EdgeSwipeDetector(context, this); |
| mKeyboardInterpreter = new KeyboardInterpreter(this); |
| mLoadOnDeckTasks = new LoadNaturalSiblingTask[2]; |
| mOnDeck = new View[2]; |
| mStarted = false; |
| } |
| |
| @Override |
| public void onFinishInflate() { |
| mBackground = (ViewGroup) findViewById(R.id.background); |
| mStageLeft = (ViewGroup) findViewById(R.id.stageleft); |
| } |
| |
| public void setDream(DreamService dream) { |
| mDream = dream; |
| } |
| |
| public boolean hasSelection() { |
| return mSelection != null; |
| } |
| |
| public View getSelection() { |
| return mSelection; |
| } |
| |
| public void clearSelection() { |
| if (hasSelection()) { |
| dropOnTable(mSelection); |
| mPhotoSource.donePaging(getBitmap(mSelection)); |
| if (mStoryModeEnabled) { |
| fadeInBackground(mSelection); |
| } |
| mSelection = null; |
| } |
| for (int slot = 0; slot < mOnDeck.length; slot++) { |
| if (mOnDeck[slot] != null) { |
| fadeAway(mOnDeck[slot], false); |
| mOnDeck[slot] = null; |
| } |
| if (mLoadOnDeckTasks[slot] != null && |
| mLoadOnDeckTasks[slot].getStatus() != AsyncTask.Status.FINISHED) { |
| mLoadOnDeckTasks[slot].cancel(true); |
| mLoadOnDeckTasks[slot] = null; |
| } |
| } |
| } |
| |
| public void setSelection(View selected) { |
| if (selected != null) { |
| clearSelection(); |
| mSelection = selected; |
| promoteSelection(); |
| if (mStoryModeEnabled) { |
| fadeOutBackground(mSelection); |
| } |
| } |
| } |
| |
| public void selectNext() { |
| if (mStoryModeEnabled) { |
| log("selectNext"); |
| if (hasSelection() && mOnDeck[NEXT] != null) { |
| placeOnDeck(mSelection, PREV); |
| mSelection = mOnDeck[NEXT]; |
| mOnDeck[NEXT] = null; |
| promoteSelection(); |
| } |
| } else { |
| clearSelection(); |
| } |
| } |
| |
| public void selectPrevious() { |
| if (mStoryModeEnabled) { |
| log("selectPrevious"); |
| if (hasSelection() && mOnDeck[PREV] != null) { |
| placeOnDeck(mSelection, NEXT); |
| mSelection = mOnDeck[PREV]; |
| mOnDeck[PREV] = null; |
| promoteSelection(); |
| } |
| } else { |
| clearSelection(); |
| } |
| } |
| |
| private void promoteSelection() { |
| if (hasSelection()) { |
| scheduleSelectionReaper(mMaxSelectionTime); |
| mSelection.animate().cancel(); |
| mSelection.setAlpha(1f); |
| moveToTopOfPile(mSelection); |
| pickUp(mSelection); |
| if (mStoryModeEnabled) { |
| for (int slot = 0; slot < mOnDeck.length; slot++) { |
| if (mLoadOnDeckTasks[slot] != null && |
| mLoadOnDeckTasks[slot].getStatus() != AsyncTask.Status.FINISHED) { |
| mLoadOnDeckTasks[slot].cancel(true); |
| } |
| if (mOnDeck[slot] == null) { |
| mLoadOnDeckTasks[slot] = new LoadNaturalSiblingTask(slot); |
| mLoadOnDeckTasks[slot].execute(mSelection); |
| } |
| } |
| } |
| } |
| } |
| |
| public boolean hasFocus() { |
| return mFocus != null; |
| } |
| |
| public View getFocus() { |
| return mFocus; |
| } |
| |
| public void clearFocus() { |
| if (hasFocus()) { |
| setHighlight(getFocus(), false); |
| } |
| mFocus = null; |
| } |
| |
| public void setDefaultFocus() { |
| setFocus(mOnTable.getLast()); |
| } |
| |
| public void setFocus(View focus) { |
| assert(focus != null); |
| clearFocus(); |
| mFocus = focus; |
| moveToTopOfPile(focus); |
| setHighlight(focus, true); |
| scheduleFocusReaper(mMaxFocusTime); |
| } |
| |
| static float lerp(float a, float b, float f) { |
| return (b-a)*f + a; |
| } |
| |
| static float randfrange(float a, float b) { |
| return lerp(a, b, sRNG.nextFloat()); |
| } |
| |
| static PointF randFromCurve(float t, PointF[] v) { |
| PointF p = new PointF(); |
| if (v.length == 4 && t >= 0f && t <= 1f) { |
| float a = (float) Math.pow(1f-t, 3f); |
| float b = (float) Math.pow(1f-t, 2f) * t; |
| float c = (1f-t) * (float) Math.pow(t, 2f); |
| float d = (float) Math.pow(t, 3f); |
| |
| p.x = a * v[0].x + 3 * b * v[1].x + 3 * c * v[2].x + d * v[3].x; |
| p.y = a * v[0].y + 3 * b * v[1].y + 3 * c * v[2].y + d * v[3].y; |
| } |
| return p; |
| } |
| |
| private static PointF randMultiDrop(int n, float i, float j, int width, int height) { |
| log("randMultiDrop (%d, %f, %f, %d, %d)", n, i, j, width, height); |
| final float[] cx = {0.3f, 0.3f, 0.5f, 0.7f, 0.7f}; |
| final float[] cy = {0.3f, 0.7f, 0.5f, 0.3f, 0.7f}; |
| n = Math.abs(n); |
| float x = cx[n % cx.length]; |
| float y = cy[n % cx.length]; |
| PointF p = new PointF(); |
| p.x = x * width + 0.05f * width * i; |
| p.y = y * height + 0.05f * height * j; |
| log("randInCenter returning %f, %f", p.x, p.y); |
| return p; |
| } |
| |
| private double cross(double[] a, double[] b) { |
| return a[0] * b[1] - a[1] * b[0]; |
| } |
| |
| private double norm(double[] a) { |
| return Math.hypot(a[0], a[1]); |
| } |
| |
| private double[] getCenter(View photo) { |
| float width = (float) ((Integer) photo.getTag(R.id.photo_width)).intValue(); |
| float height = (float) ((Integer) photo.getTag(R.id.photo_height)).intValue(); |
| double[] center = { photo.getX() + width / 2f, |
| - (photo.getY() + height / 2f) }; |
| return center; |
| } |
| |
| public View moveFocus(View focus, float direction) { |
| return moveFocus(focus, direction, 90f); |
| } |
| |
| public View moveFocus(View focus, float direction, float angle) { |
| if (focus == null) { |
| setFocus(mOnTable.getLast()); |
| } else { |
| final double alpha = Math.toRadians(direction); |
| final double beta = Math.toRadians(Math.min(angle, 180f) / 2f); |
| final double[] left = { Math.sin(alpha - beta), |
| Math.cos(alpha - beta) }; |
| final double[] right = { Math.sin(alpha + beta), |
| Math.cos(alpha + beta) }; |
| final double[] a = getCenter(focus); |
| View bestFocus = null; |
| double bestDistance = Double.MAX_VALUE; |
| for (View candidate: mOnTable) { |
| if (candidate != focus) { |
| final double[] b = getCenter(candidate); |
| final double[] delta = { b[0] - a[0], |
| b[1] - a[1] }; |
| if (cross(delta, left) > 0.0 && cross(delta, right) < 0.0) { |
| final double distance = norm(delta); |
| if (bestDistance > distance) { |
| bestDistance = distance; |
| bestFocus = candidate; |
| } |
| } |
| } |
| } |
| if (bestFocus == null) { |
| if (angle < 180f) { |
| return moveFocus(focus, direction, 180f); |
| } |
| } else { |
| setFocus(bestFocus); |
| } |
| } |
| return getFocus(); |
| } |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| return mKeyboardInterpreter.onKeyDown(keyCode, event); |
| } |
| |
| @Override |
| public boolean onGenericMotionEvent(MotionEvent event) { |
| return mEdgeSwipeDetector.onTouchEvent(event) || mDragGestureDetector.onTouchEvent(event); |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent event) { |
| if (event.getActionMasked() == MotionEvent.ACTION_DOWN) { |
| if (hasSelection()) { |
| clearSelection(); |
| } else { |
| if (mTapToExit && mDream != null) { |
| mDream.finish(); |
| } |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| log("onLayout (%d, %d, %d, %d)", left, top, right, bottom); |
| |
| mHeight = bottom - top; |
| mWidth = right - left; |
| |
| mLongSide = (int) (mImageRatio * Math.max(mWidth, mHeight)); |
| mShortSide = (int) (mImageRatio * Math.min(mWidth, mHeight)); |
| |
| boolean isLandscape = mWidth > mHeight; |
| if (mIsLandscape != isLandscape) { |
| for (View photo: mOnTable) { |
| if (photo != getSelection()) { |
| dropOnTable(photo); |
| } |
| } |
| if (hasSelection()) { |
| pickUp(getSelection()); |
| for (int slot = 0; slot < mOnDeck.length; slot++) { |
| if (mOnDeck[slot] != null) { |
| placeOnDeck(mOnDeck[slot], slot); |
| } |
| } |
| } |
| mIsLandscape = isLandscape; |
| } |
| start(); |
| } |
| |
| @Override |
| public boolean isOpaque() { |
| return true; |
| } |
| |
| /** Put a nice border on the bitmap. */ |
| private static View applyFrame(final PhotoTable table, final BitmapFactory.Options options, |
| Bitmap decodedPhoto) { |
| LayoutInflater inflater = (LayoutInflater) table.getContext() |
| .getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| View photo = inflater.inflate(R.layout.photo, null); |
| ImageView image = (ImageView) photo; |
| Drawable[] layers = new Drawable[2]; |
| int photoWidth = options.outWidth; |
| int photoHeight = options.outHeight; |
| if (decodedPhoto == null || options.outWidth <= 0 || options.outHeight <= 0) { |
| photo = null; |
| } else { |
| decodedPhoto.setHasMipMap(true); |
| layers[0] = new BitmapDrawable(table.mResources, decodedPhoto); |
| layers[1] = table.mResources.getDrawable(R.drawable.frame); |
| LayerDrawable layerList = new LayerDrawable(layers); |
| layerList.setLayerInset(0, table.mInset, table.mInset, |
| table.mInset, table.mInset); |
| image.setImageDrawable(layerList); |
| |
| photo.setTag(R.id.photo_width, Integer.valueOf(photoWidth)); |
| photo.setTag(R.id.photo_height, Integer.valueOf(photoHeight)); |
| |
| photo.setOnTouchListener(new PhotoTouchListener(table.getContext(), |
| table)); |
| } |
| return photo; |
| } |
| |
| private class LoadNaturalSiblingTask extends AsyncTask<View, Void, View> { |
| private final BitmapFactory.Options mOptions; |
| private final int mSlot; |
| private View mParent; |
| |
| public LoadNaturalSiblingTask (int slot) { |
| mOptions = new BitmapFactory.Options(); |
| mOptions.inTempStorage = new byte[32768]; |
| mSlot = slot; |
| } |
| |
| @Override |
| public View doInBackground(View... views) { |
| log("load natural %s", (mSlot == NEXT ? "next" : "previous")); |
| final PhotoTable table = PhotoTable.this; |
| mParent = views[0]; |
| final Bitmap current = getBitmap(mParent); |
| Bitmap decodedPhoto; |
| if (mSlot == NEXT) { |
| decodedPhoto = table.mPhotoSource.naturalNext(current, |
| mOptions, table.mLongSide, table.mShortSide); |
| } else { |
| decodedPhoto = table.mPhotoSource.naturalPrevious(current, |
| mOptions, table.mLongSide, table.mShortSide); |
| } |
| return applyFrame(PhotoTable.this, mOptions, decodedPhoto); |
| } |
| |
| @Override |
| public void onPostExecute(View photo) { |
| if (photo != null) { |
| if (hasSelection() && getSelection() == mParent) { |
| log("natural %s being rendered", (mSlot == NEXT ? "next" : "previous")); |
| PhotoTable.this.addView(photo, new LayoutParams(LayoutParams.WRAP_CONTENT, |
| LayoutParams.WRAP_CONTENT)); |
| PhotoTable.this.mOnDeck[mSlot] = photo; |
| float width = (float) ((Integer) photo.getTag(R.id.photo_width)).intValue(); |
| float height = (float) ((Integer) photo.getTag(R.id.photo_height)).intValue(); |
| photo.setX(mSlot == PREV ? -2 * width : mWidth + 2 * width); |
| photo.setY((mHeight - height) / 2); |
| photo.addOnLayoutChangeListener(new OnLayoutChangeListener() { |
| @Override |
| public void onLayoutChange(View v, int left, int top, int right, int bottom, |
| int oldLeft, int oldTop, int oldRight, int oldBottom) { |
| PhotoTable.this.placeOnDeck(v, mSlot); |
| v.removeOnLayoutChangeListener(this); |
| } |
| }); |
| } else { |
| recycle(photo); |
| } |
| } else { |
| log("natural, %s was null!", (mSlot == NEXT ? "next" : "previous")); |
| } |
| } |
| }; |
| |
| private class PhotoLaunchTask extends AsyncTask<Void, Void, View> { |
| private final BitmapFactory.Options mOptions; |
| |
| public PhotoLaunchTask () { |
| mOptions = new BitmapFactory.Options(); |
| mOptions.inTempStorage = new byte[32768]; |
| } |
| |
| @Override |
| public View doInBackground(Void... unused) { |
| log("load a new photo"); |
| final PhotoTable table = PhotoTable.this; |
| return applyFrame(PhotoTable.this, mOptions, |
| table.mPhotoSource.next(mOptions, |
| table.mLongSide, table.mShortSide)); |
| } |
| |
| @Override |
| public void onPostExecute(View photo) { |
| if (photo != null) { |
| final PhotoTable table = PhotoTable.this; |
| |
| table.addView(photo, new LayoutParams(LayoutParams.WRAP_CONTENT, |
| LayoutParams.WRAP_CONTENT)); |
| if (table.hasSelection()) { |
| for (int slot = 0; slot < mOnDeck.length; slot++) { |
| if (mOnDeck[slot] != null) { |
| table.moveToTopOfPile(mOnDeck[slot]); |
| } |
| } |
| table.moveToTopOfPile(table.getSelection()); |
| } |
| |
| log("drop it"); |
| table.throwOnTable(photo); |
| |
| if (mOnTable.size() > mTableCapacity) { |
| int targetSize = Math.max(0, mOnTable.size() - mRedealCount); |
| while (mOnTable.size() > targetSize) { |
| fadeAway(mOnTable.poll(), false); |
| } |
| } |
| |
| if(table.mOnTable.size() < table.mTableCapacity) { |
| table.scheduleNext(table.mFastDropPeriod); |
| } |
| } |
| } |
| }; |
| |
| /** Bring a new photo onto the table. */ |
| public void launch() { |
| log("launching"); |
| setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE); |
| if (!hasSelection()) { |
| log("inflate it"); |
| if (mPhotoLaunchTask == null || |
| mPhotoLaunchTask.getStatus() == AsyncTask.Status.FINISHED) { |
| mPhotoLaunchTask = new PhotoLaunchTask(); |
| mPhotoLaunchTask.execute(); |
| } |
| } |
| } |
| |
| /** De-emphasize the other photos on the table. */ |
| public void fadeOutBackground(final View photo) { |
| mBackground.animate() |
| .withLayer() |
| .setDuration(mPickUpDuration) |
| .alpha(0f); |
| } |
| |
| |
| /** Return the other photos to foreground status. */ |
| public void fadeInBackground(final View photo) { |
| mAnimating.add(photo); |
| mBackground.animate() |
| .withLayer() |
| .setDuration(mPickUpDuration) |
| .alpha(1f) |
| .withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| mAnimating.remove(photo); |
| if (!mAnimating.contains(photo)) { |
| moveToBackground(photo); |
| } |
| } |
| }); |
| } |
| |
| /** Dispose of the photo gracefully, in case we can see some of it. */ |
| public void fadeAway(final View photo, final boolean replace) { |
| // fade out of view |
| mOnTable.remove(photo); |
| exitStageLeft(photo); |
| photo.setOnTouchListener(null); |
| photo.animate().cancel(); |
| photo.animate() |
| .withLayer() |
| .alpha(0f) |
| .setDuration(mPickUpDuration) |
| .withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| if (photo == getFocus()) { |
| clearFocus(); |
| } |
| mStageLeft.removeView(photo); |
| recycle(photo); |
| if (replace) { |
| scheduleNext(mNowDropDelay); |
| } |
| } |
| }); |
| } |
| |
| /** Visually on top, and also freshest, for the purposes of timeouts. */ |
| public void moveToTopOfPile(View photo) { |
| // make this photo the last to be removed. |
| if (isInBackground(photo)) { |
| mBackground.bringChildToFront(photo); |
| } else { |
| bringChildToFront(photo); |
| } |
| invalidate(); |
| mOnTable.remove(photo); |
| mOnTable.offer(photo); |
| } |
| |
| /** On deck is to the left or right of the selected photo. */ |
| private void placeOnDeck(final View photo, final int slot ) { |
| if (slot < mOnDeck.length) { |
| if (mOnDeck[slot] != null && mOnDeck[slot] != photo) { |
| fadeAway(mOnDeck[slot], false); |
| } |
| mOnDeck[slot] = photo; |
| float photoWidth = photo.getWidth(); |
| float photoHeight = photo.getHeight(); |
| float scale = Math.min(getHeight() / photoHeight, getWidth() / photoWidth); |
| |
| float x = (getWidth() - photoWidth) / 2f; |
| float y = (getHeight() - photoHeight) / 2f; |
| |
| float offset = (((float) mWidth + scale * (photoWidth - 2f * mInset)) / 2f); |
| x += (slot == NEXT? 1f : -1f) * offset; |
| |
| photo.animate() |
| .withLayer() |
| .rotation(0f) |
| .rotationY(0f) |
| .scaleX(scale) |
| .scaleY(scale) |
| .x(x) |
| .y(y) |
| .setDuration(mPickUpDuration) |
| .setInterpolator(new DecelerateInterpolator(2f)); |
| } |
| } |
| |
| /** Move in response to touch. */ |
| public void move(final View photo, float x, float y, float a) { |
| photo.animate().cancel(); |
| photo.setAlpha(1f); |
| photo.setX((int) x); |
| photo.setY((int) y); |
| photo.setRotation((int) a); |
| } |
| |
| /** Wind up off screen, so we can animate in. */ |
| private void throwOnTable(final View photo) { |
| mOnTable.offer(photo); |
| log("start offscreen"); |
| photo.setRotation(mThrowRotation); |
| photo.setX(-mLongSide); |
| photo.setY(-mLongSide); |
| |
| dropOnTable(photo, mThrowInterpolator); |
| } |
| |
| public void move(final View photo, float dx, float dy, boolean drop) { |
| if (photo != null) { |
| final float x = photo.getX() + dx; |
| final float y = photo.getY() + dy; |
| photo.setX(x); |
| photo.setY(y); |
| Log.d(TAG, "[" + photo.getX() + ", " + photo.getY() + "] + (" + dx + "," + dy + ")"); |
| if (drop && photoOffTable(photo)) { |
| fadeAway(photo, true); |
| } |
| } |
| } |
| |
| /** Fling with no touch hints, then land off screen. */ |
| public void fling(final View photo) { |
| final float[] o = { mWidth + mLongSide / 2f, |
| mHeight + mLongSide / 2f }; |
| final float[] a = { photo.getX(), photo.getY() }; |
| final float[] b = { o[0], a[1] + o[0] - a[0] }; |
| final float[] c = { a[0] + o[1] - a[1], o[1] }; |
| float[] delta = { 0f, 0f }; |
| if (Math.hypot(b[0] - a[0], b[1] - a[1]) < Math.hypot(c[0] - a[0], c[1] - a[1])) { |
| delta[0] = b[0] - a[0]; |
| delta[1] = b[1] - a[1]; |
| } else { |
| delta[0] = c[0] - a[0]; |
| delta[1] = c[1] - a[1]; |
| } |
| |
| final float dist = (float) Math.hypot(delta[0], delta[1]); |
| final int duration = (int) (1000f * dist / mThrowSpeed); |
| fling(photo, delta[0], delta[1], duration, true); |
| } |
| |
| /** Continue dynamically after a fling gesture, possibly off the screen. */ |
| public void fling(final View photo, float dx, float dy, int duration, boolean spin) { |
| if (photo == getFocus()) { |
| if (moveFocus(photo, 0f) == null) { |
| moveFocus(photo, 180f); |
| } |
| } |
| moveToForeground(photo); |
| ViewPropertyAnimator animator = photo.animate() |
| .withLayer() |
| .xBy(dx) |
| .yBy(dy) |
| .setDuration(duration) |
| .setInterpolator(new DecelerateInterpolator(2f)); |
| |
| if (spin) { |
| animator.rotation(mThrowRotation); |
| } |
| |
| if (photoOffTable(photo, (int) dx, (int) dy)) { |
| log("fling away"); |
| animator.withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| fadeAway(photo, true); |
| } |
| }); |
| } |
| } |
| public boolean photoOffTable(final View photo) { |
| return photoOffTable(photo, 0, 0); |
| } |
| |
| public boolean photoOffTable(final View photo, final int dx, final int dy) { |
| Rect hit = new Rect(); |
| photo.getHitRect(hit); |
| hit.offset(dx, dy); |
| return (hit.bottom < 0f || hit.top > getHeight() || |
| hit.right < 0f || hit.left > getWidth()); |
| } |
| |
| /** Animate to a random place and orientation, down on the table (visually small). */ |
| public void dropOnTable(final View photo) { |
| dropOnTable(photo, mDropInterpolator); |
| } |
| |
| /** Animate to a random place and orientation, down on the table (visually small). */ |
| public void dropOnTable(final View photo, final Interpolator interpolator) { |
| float angle = randfrange(-mImageRotationLimit, mImageRotationLimit); |
| PointF p = randMultiDrop(sRNG.nextInt(), |
| (float) sRNG.nextGaussian(), (float) sRNG.nextGaussian(), |
| mWidth, mHeight); |
| float x = p.x; |
| float y = p.y; |
| |
| log("drop it at %f, %f", x, y); |
| |
| float x0 = photo.getX(); |
| float y0 = photo.getY(); |
| |
| x -= mLongSide / 2f; |
| y -= mShortSide / 2f; |
| log("fixed offset is %f, %f ", x, y); |
| |
| float dx = x - x0; |
| float dy = y - y0; |
| |
| float dist = (float) Math.hypot(dx, dy); |
| int duration = (int) (1000f * dist / mThrowSpeed); |
| duration = Math.max(duration, 1000); |
| |
| log("animate it"); |
| // toss onto table |
| mAnimating.add(photo); |
| photo.animate() |
| .withLayer() |
| .scaleX(mTableRatio / mImageRatio) |
| .scaleY(mTableRatio / mImageRatio) |
| .rotation(angle) |
| .x(x) |
| .y(y) |
| .setDuration(duration) |
| .setInterpolator(interpolator) |
| .withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| mAnimating.remove(photo); |
| if (!mAnimating.contains(photo)) { |
| moveToBackground(photo); |
| } |
| } |
| }); |
| } |
| |
| private void moveToBackground(View photo) { |
| if (!isInBackground(photo)) { |
| removeView(photo); |
| mBackground.addView(photo, new LayoutParams(LayoutParams.WRAP_CONTENT, |
| LayoutParams.WRAP_CONTENT)); |
| } |
| } |
| |
| private void exitStageLeft(View photo) { |
| if (isInBackground(photo)) { |
| mBackground.removeView(photo); |
| } else { |
| removeView(photo); |
| } |
| mStageLeft.addView(photo, new LayoutParams(LayoutParams.WRAP_CONTENT, |
| LayoutParams.WRAP_CONTENT)); |
| } |
| |
| private void moveToForeground(View photo) { |
| if (isInBackground(photo)) { |
| mBackground.removeView(photo); |
| addView(photo, new LayoutParams(LayoutParams.WRAP_CONTENT, |
| LayoutParams.WRAP_CONTENT)); |
| } |
| } |
| |
| private boolean isInBackground(View photo) { |
| return mBackground.indexOfChild(photo) != -1; |
| } |
| |
| /** wrap all orientations to the interval [-180, 180). */ |
| private float wrapAngle(float angle) { |
| float result = angle + 180; |
| result = ((result % 360) + 360) % 360; // catch negative numbers |
| result -= 180; |
| return result; |
| } |
| |
| /** Animate the selected photo to the foregound: zooming in to bring it foreward. */ |
| private void pickUp(final View photo) { |
| float photoWidth = photo.getWidth(); |
| float photoHeight = photo.getHeight(); |
| |
| float scale = Math.min(getHeight() / photoHeight, getWidth() / photoWidth); |
| |
| log("scale is %f", scale); |
| log("target it"); |
| float x = (getWidth() - photoWidth) / 2f; |
| float y = (getHeight() - photoHeight) / 2f; |
| |
| photo.setRotation(wrapAngle(photo.getRotation())); |
| |
| log("animate it"); |
| // lift up to the glass for a good look |
| moveToForeground(photo); |
| photo.animate() |
| .withLayer() |
| .rotation(0f) |
| .rotationY(0f) |
| .alpha(1f) |
| .scaleX(scale) |
| .scaleY(scale) |
| .x(x) |
| .y(y) |
| .setDuration(mPickUpDuration) |
| .setInterpolator(new DecelerateInterpolator(2f)) |
| .withEndAction(new Runnable() { |
| @Override |
| public void run() { |
| log("endtimes: %f", photo.getX()); |
| } |
| }); |
| } |
| |
| private Bitmap getBitmap(View photo) { |
| if (photo == null) { |
| return null; |
| } |
| ImageView image = (ImageView) photo; |
| LayerDrawable layers = (LayerDrawable) image.getDrawable(); |
| if (layers == null) { |
| return null; |
| } |
| BitmapDrawable bitmap = (BitmapDrawable) layers.getDrawable(0); |
| if (bitmap == null) { |
| return null; |
| } |
| return bitmap.getBitmap(); |
| } |
| |
| private void recycle(View photo) { |
| if (photo != null) { |
| removeView(photo); |
| mPhotoSource.recycle(getBitmap(photo)); |
| } |
| } |
| |
| public void setHighlight(View photo, boolean highlighted) { |
| ImageView image = (ImageView) photo; |
| LayerDrawable layers = (LayerDrawable) image.getDrawable(); |
| if (highlighted) { |
| layers.getDrawable(1).setColorFilter(mHighlightColor, PorterDuff.Mode.SRC_IN); |
| } else { |
| layers.getDrawable(1).clearColorFilter(); |
| } |
| } |
| |
| /** Schedule the first launch. Idempotent. */ |
| public void start() { |
| if (!mStarted) { |
| log("kick it"); |
| mStarted = true; |
| scheduleNext(0); |
| } |
| } |
| |
| public void refreshSelection() { |
| scheduleSelectionReaper(mMaxFocusTime); |
| } |
| |
| public void scheduleSelectionReaper(int delay) { |
| removeCallbacks(mSelectionReaper); |
| postDelayed(mSelectionReaper, delay); |
| } |
| |
| public void refreshFocus() { |
| scheduleFocusReaper(mMaxFocusTime); |
| } |
| |
| public void scheduleFocusReaper(int delay) { |
| removeCallbacks(mFocusReaper); |
| postDelayed(mFocusReaper, delay); |
| } |
| |
| public void scheduleNext(int delay) { |
| removeCallbacks(mLauncher); |
| postDelayed(mLauncher, delay); |
| } |
| |
| private static void log(String message, Object... args) { |
| if (DEBUG) { |
| Formatter formatter = new Formatter(); |
| formatter.format(message, args); |
| Log.i(TAG, formatter.toString()); |
| } |
| } |
| } |
