1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.gallery3d.ui; 18 19 import android.graphics.Rect; 20 import android.opengl.Matrix; 21 import android.view.animation.DecelerateInterpolator; 22 import android.view.animation.Interpolator; 23 24 import com.android.gallery3d.common.Utils; 25 26 // This class does the overscroll effect. 27 class Paper { 28 @SuppressWarnings("unused") 29 private static final String TAG = "Paper"; 30 private static final int ROTATE_FACTOR = 4; 31 private EdgeAnimation mAnimationLeft = new EdgeAnimation(); 32 private EdgeAnimation mAnimationRight = new EdgeAnimation(); 33 private int mWidth; 34 private float[] mMatrix = new float[16]; 35 overScroll(float distance)36 public void overScroll(float distance) { 37 distance /= mWidth; // make it relative to width 38 if (distance < 0) { 39 mAnimationLeft.onPull(-distance); 40 } else { 41 mAnimationRight.onPull(distance); 42 } 43 } 44 edgeReached(float velocity)45 public void edgeReached(float velocity) { 46 velocity /= mWidth; // make it relative to width 47 if (velocity < 0) { 48 mAnimationRight.onAbsorb(-velocity); 49 } else { 50 mAnimationLeft.onAbsorb(velocity); 51 } 52 } 53 onRelease()54 public void onRelease() { 55 mAnimationLeft.onRelease(); 56 mAnimationRight.onRelease(); 57 } 58 advanceAnimation()59 public boolean advanceAnimation() { 60 // Note that we use "|" because we want both animations get updated. 61 return mAnimationLeft.update() | mAnimationRight.update(); 62 } 63 setSize(int width, int height)64 public void setSize(int width, int height) { 65 mWidth = width; 66 } 67 getTransform(Rect rect, float scrollX)68 public float[] getTransform(Rect rect, float scrollX) { 69 float left = mAnimationLeft.getValue(); 70 float right = mAnimationRight.getValue(); 71 float screenX = rect.centerX() - scrollX; 72 // We linearly interpolate the value [left, right] for the screenX 73 // range int [-1/4, 5/4]*mWidth. So if part of the thumbnail is outside 74 // the screen, we still get some transform. 75 float x = screenX + mWidth / 4; 76 int range = 3 * mWidth / 2; 77 float t = ((range - x) * left - x * right) / range; 78 // compress t to the range (-1, 1) by the function 79 // f(t) = (1 / (1 + e^-t) - 0.5) * 2 80 // then multiply by 90 to make the range (-45, 45) 81 float degrees = 82 (1 / (1 + (float) Math.exp(-t * ROTATE_FACTOR)) - 0.5f) * 2 * -45; 83 Matrix.setIdentityM(mMatrix, 0); 84 Matrix.translateM(mMatrix, 0, mMatrix, 0, rect.centerX(), rect.centerY(), 0); 85 Matrix.rotateM(mMatrix, 0, degrees, 0, 1, 0); 86 Matrix.translateM(mMatrix, 0, mMatrix, 0, -rect.width() / 2, -rect.height() / 2, 0); 87 return mMatrix; 88 } 89 } 90 91 // This class follows the structure of frameworks's EdgeEffect class. 92 class EdgeAnimation { 93 @SuppressWarnings("unused") 94 private static final String TAG = "EdgeAnimation"; 95 96 private static final int STATE_IDLE = 0; 97 private static final int STATE_PULL = 1; 98 private static final int STATE_ABSORB = 2; 99 private static final int STATE_RELEASE = 3; 100 101 // Time it will take the effect to fully done in ms 102 private static final int ABSORB_TIME = 200; 103 private static final int RELEASE_TIME = 500; 104 105 private static final float VELOCITY_FACTOR = 0.1f; 106 107 private final Interpolator mInterpolator; 108 109 private int mState; 110 private float mValue; 111 112 private float mValueStart; 113 private float mValueFinish; 114 private long mStartTime; 115 private long mDuration; 116 EdgeAnimation()117 public EdgeAnimation() { 118 mInterpolator = new DecelerateInterpolator(); 119 mState = STATE_IDLE; 120 } 121 startAnimation(float start, float finish, long duration, int newState)122 private void startAnimation(float start, float finish, long duration, 123 int newState) { 124 mValueStart = start; 125 mValueFinish = finish; 126 mDuration = duration; 127 mStartTime = now(); 128 mState = newState; 129 } 130 131 // The deltaDistance's magnitude is in the range of -1 (no change) to 1. 132 // The value 1 is the full length of the view. Negative values means the 133 // movement is in the opposite direction. onPull(float deltaDistance)134 public void onPull(float deltaDistance) { 135 if (mState == STATE_ABSORB) return; 136 mValue = Utils.clamp(mValue + deltaDistance, -1.0f, 1.0f); 137 mState = STATE_PULL; 138 } 139 onRelease()140 public void onRelease() { 141 if (mState == STATE_IDLE || mState == STATE_ABSORB) return; 142 startAnimation(mValue, 0, RELEASE_TIME, STATE_RELEASE); 143 } 144 onAbsorb(float velocity)145 public void onAbsorb(float velocity) { 146 float finish = Utils.clamp(mValue + velocity * VELOCITY_FACTOR, 147 -1.0f, 1.0f); 148 startAnimation(mValue, finish, ABSORB_TIME, STATE_ABSORB); 149 } 150 update()151 public boolean update() { 152 if (mState == STATE_IDLE) return false; 153 if (mState == STATE_PULL) return true; 154 155 float t = Utils.clamp((float)(now() - mStartTime) / mDuration, 0.0f, 1.0f); 156 /* Use linear interpolation for absorb, quadratic for others */ 157 float interp = (mState == STATE_ABSORB) 158 ? t : mInterpolator.getInterpolation(t); 159 160 mValue = mValueStart + (mValueFinish - mValueStart) * interp; 161 162 if (t >= 1.0f) { 163 switch (mState) { 164 case STATE_ABSORB: 165 startAnimation(mValue, 0, RELEASE_TIME, STATE_RELEASE); 166 break; 167 case STATE_RELEASE: 168 mState = STATE_IDLE; 169 break; 170 } 171 } 172 173 return true; 174 } 175 getValue()176 public float getValue() { 177 return mValue; 178 } 179 now()180 private long now() { 181 return AnimationTime.get(); 182 } 183 } 184