http://www.oschina.net/code/snippet_16_2541
（另）http://www.eoeandroid.com/thread-48286-1-1.html（带附件）
[代码] FlingGalleryActivity
001 |
import android.app.Activity;
|
002 |
import android.os.Bundle;
|
003 |
004 |
import android.content.Context;
|
005 |
import android.graphics.Color;
|
006 |
import android.util.Log;
|
007 |
import android.view.Gravity;
|
008 |
import android.view.MotionEvent;
|
009 |
import android.view.View;
|
010 |
import android.view.ViewGroup;
|
011 |
import android.view.View.OnClickListener;
|
012 |
import android.widget.ArrayAdapter;
|
013 |
import android.widget.Button;
|
014 |
import android.widget.CheckBox;
|
015 |
import android.widget.EditText;
|
016 |
import android.widget.LinearLayout;
|
017 |
import android.widget.TableLayout;
|
018 |
import android.widget.TextView;
|
019 |
020 |
public class FlingGalleryActivity extends Activity
|
021 |
{ |
022 |
private final int color_red = Color.argb(100, 200, 0, 0);
|
023 |
private final int color_green = Color.argb(100, 0, 200, 0);
|
024 |
private final int color_blue = Color.argb(100, 0, 0, 200);
|
025 |
private final int color_yellow = Color.argb(100, 200, 200, 0);
|
026 |
private final int color_purple = Color.argb(100, 200, 0, 200);
|
027 |
028 |
private final String[] mLabelArray = {"View1", "View2", "View3", "View4", "View5"};
|
029 |
private final int[] mColorArray = {color_red, color_green, color_blue, color_yellow, color_purple};
|
030 |
031 |
private FlingGallery mGallery;
|
032 |
private CheckBox mCheckBox;
|
033 |
034 |
// Note: The following handler is critical to correct function of
|
035 |
// the FlingGallery class. This enables the FlingGallery class to
|
036 |
// detect when the motion event has ended by finger being lifted
|
037 |
038 |
@Override
|
039 |
public boolean onTouchEvent(MotionEvent event)
|
040 |
{
|
041 |
return mGallery.onGalleryTouchEvent(event);
|
042 |
}
|
043 |
044 |
public void onCreate(Bundle savedInstanceState)
|
045 |
{
|
046 |
super.onCreate(savedInstanceState);
|
047 |
048 |
mGallery = new FlingGallery(this);
|
049 |
mGallery.setPaddingWidth(5);
|
050 |
mGallery.setAdapter(new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, mLabelArray)
|
051 |
{
|
052 |
@Override
|
053 |
public View getView(int position, View convertView, ViewGroup parent)
|
054 |
{
|
055 |
Log.d("111", "count="+position);
|
056 |
// if (convertView != null && convertView instanceof GalleryViewItem) |
057 |
// { |
058 |
// GalleryViewItem galleryView = (GalleryViewItem) convertView; |
059 |
// |
060 |
// galleryView.mEdit1.setText(""); |
061 |
// galleryView.mText1.setText(mLabelArray[position]); |
062 |
// galleryView.mText1.setBackgroundColor(mColorArray[position]); |
063 |
// galleryView.mText2.setText(mLabelArray[position]); |
064 |
// galleryView.mText2.setBackgroundColor(mColorArray[position]); |
065 |
// |
066 |
// Log.d("111", "count="+position); |
067 |
// |
068 |
// return galleryView; |
069 |
// |
070 |
// } |
071 |
|
072 |
return new GalleryViewItem(getApplicationContext(), position);
|
073 |
}
|
074 |
});
|
075 |
076 |
LinearLayout layout = new LinearLayout(getApplicationContext());
|
077 |
layout.setOrientation(LinearLayout.VERTICAL);
|
078 |
079 |
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
|
080 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
081 |
LinearLayout.LayoutParams.MATCH_PARENT);
|
082 |
083 |
layoutParams.setMargins(10, 10, 10, 10);
|
084 |
layoutParams.weight = 1.0f;
|
085 |
|
086 |
layout.addView(mGallery, layoutParams);
|
087 |
|
088 |
mCheckBox = new CheckBox(getApplicationContext());
|
089 |
mCheckBox.setText("Gallery is Circular");
|
090 |
mCheckBox.setText("Gallery is Circular");
|
091 |
mCheckBox.setPadding(50, 10, 0, 10);
|
092 |
mCheckBox.setTextSize(30);
|
093 |
mCheckBox.setChecked(true);
|
094 |
mCheckBox.setOnClickListener(new OnClickListener()
|
095 |
{
|
096 |
@Override
|
097 |
public void onClick(View view)
|
098 |
{
|
099 |
mGallery.setIsGalleryCircular(mCheckBox.isChecked());
|
100 |
}
|
101 |
});
|
102 |
103 |
layout.addView(mCheckBox, new LinearLayout.LayoutParams(
|
104 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
105 |
LinearLayout.LayoutParams.WRAP_CONTENT));
|
106 |
|
107 |
setContentView(layout);
|
108 |
}
|
109 |
110 |
private class GalleryViewItem extends TableLayout
|
111 |
{
|
112 |
private EditText mEdit1;
|
113 |
private TextView mText1;
|
114 |
private TextView mText2;
|
115 |
private Button mButton1;
|
116 |
private Button mButton2;
|
117 |
118 |
public GalleryViewItem(Context context, int position)
|
119 |
{
|
120 |
super(context);
|
121 |
122 |
this.setOrientation(LinearLayout.VERTICAL);
|
123 |
124 |
this.setLayoutParams(new LinearLayout.LayoutParams(
|
125 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
126 |
LinearLayout.LayoutParams.MATCH_PARENT));
|
127 |
|
128 |
mEdit1 = new EditText(context);
|
129 |
130 |
this.addView(mEdit1, new LinearLayout.LayoutParams(
|
131 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
132 |
LinearLayout.LayoutParams.WRAP_CONTENT));
|
133 |
134 |
mText1 = new TextView(context);
|
135 |
mText1.setText(mLabelArray[position]);
|
136 |
mText1.setTextSize(30);
|
137 |
mText1.setGravity(Gravity.LEFT);
|
138 |
mText1.setBackgroundColor(mColorArray[position]);
|
139 |
140 |
this.addView(mText1, new LinearLayout.LayoutParams(
|
141 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
142 |
LinearLayout.LayoutParams.WRAP_CONTENT));
|
143 |
144 |
mButton1 = new Button(context);
|
145 |
mButton1.setText("<<");
|
146 |
mButton1.setGravity(Gravity.LEFT);
|
147 |
mButton1.setOnClickListener(new OnClickListener()
|
148 |
{
|
149 |
@Override
|
150 |
public void onClick(View view)
|
151 |
{
|
152 |
mGallery.movePrevious();
|
153 |
}
|
154 |
});
|
155 |
|
156 |
this.addView(mButton1, new LinearLayout.LayoutParams(
|
157 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
158 |
LinearLayout.LayoutParams.WRAP_CONTENT));
|
159 |
160 |
mButton2 = new Button(context);
|
161 |
mButton2.setText(">>");
|
162 |
mButton2.setGravity(Gravity.RIGHT);
|
163 |
mButton2.setOnClickListener(new OnClickListener()
|
164 |
{
|
165 |
@Override
|
166 |
public void onClick(View view)
|
167 |
{
|
168 |
mGallery.moveNext();
|
169 |
}
|
170 |
});
|
171 |
|
172 |
this.addView(mButton2, new LinearLayout.LayoutParams(
|
173 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
174 |
LinearLayout.LayoutParams.WRAP_CONTENT));
|
175 |
176 |
mText2 = new TextView(context);
|
177 |
mText2.setText(mLabelArray[position]);
|
178 |
mText2.setTextSize(30);
|
179 |
mText2.setGravity(Gravity.RIGHT);
|
180 |
mText2.setBackgroundColor(mColorArray[position]);
|
181 |
182 |
this.addView(mText2, new LinearLayout.LayoutParams(
|
183 |
LinearLayout.LayoutParams.MATCH_PARENT,
|
184 |
LinearLayout.LayoutParams.MATCH_PARENT, 1));
|
185 |
}
|
186 |
}
|
187 |
} |
[代码] FlingGallery
001 |
import android.content.Context;
|
002 |
import android.view.GestureDetector;
|
003 |
import android.view.KeyEvent;
|
004 |
import android.view.MotionEvent;
|
005 |
import android.view.View;
|
006 |
import android.view.animation.Animation;
|
007 |
import android.view.animation.AnimationUtils;
|
008 |
import android.view.animation.Interpolator;
|
009 |
import android.view.animation.Transformation;
|
010 |
import android.widget.Adapter;
|
011 |
import android.widget.FrameLayout;
|
012 |
import android.widget.LinearLayout;
|
013 |
014 |
// TODO: |
015 |
016 |
// 1. In order to improve performance Cache screen bitmap and use for animation |
017 |
// 2. Establish superfluous memory allocations and delay or replace with reused objects |
018 |
// Probably need to make sure we are not allocating objects (strings, etc.) in loops |
019 |
020 |
public class FlingGallery extends FrameLayout
|
021 |
{ |
022 |
// Constants
|
023 |
|
024 |
private final int swipe_min_distance = 120;
|
025 |
private final int swipe_max_off_path = 250;
|
026 |
private final int swipe_threshold_veloicty = 400;
|
027 |
028 |
// Properties
|
029 |
|
030 |
private int mViewPaddingWidth = 0;
|
031 |
private int mAnimationDuration = 250;
|
032 |
private float mSnapBorderRatio = 0.5f;
|
033 |
private boolean mIsGalleryCircular = true;
|
034 |
035 |
// Members
|
036 |
037 |
private int mGalleryWidth = 0;
|
038 |
private boolean mIsTouched = false;
|
039 |
private boolean mIsDragging = false;
|
040 |
private float mCurrentOffset = 0.0f;
|
041 |
private long mScrollTimestamp = 0;
|
042 |
private int mFlingDirection = 0;
|
043 |
private int mCurrentPosition = 0;
|
044 |
private int mCurrentViewNumber = 0;
|
045 |
046 |
private Context mContext;
|
047 |
private Adapter mAdapter;
|
048 |
private FlingGalleryView[] mViews;
|
049 |
private FlingGalleryAnimation mAnimation;
|
050 |
private GestureDetector mGestureDetector;
|
051 |
private Interpolator mDecelerateInterpolater;
|
052 |
053 |
public FlingGallery(Context context)
|
054 |
{
|
055 |
super(context);
|
056 |
057 |
mContext = context;
|
058 |
mAdapter = null;
|
059 |
|
060 |
mViews = new FlingGalleryView[3];
|
061 |
mViews[0] = new FlingGalleryView(0, this);
|
062 |
mViews[1] = new FlingGalleryView(1, this);
|
063 |
mViews[2] = new FlingGalleryView(2, this);
|
064 |
065 |
mAnimation = new FlingGalleryAnimation();
|
066 |
mGestureDetector = new GestureDetector(new FlingGestureDetector());
|
067 |
mDecelerateInterpolater = AnimationUtils.loadInterpolator(mContext, android.R.anim.decelerate_interpolator);
|
068 |
}
|
069 |
070 |
public void setPaddingWidth(int viewPaddingWidth)
|
071 |
{
|
072 |
mViewPaddingWidth = viewPaddingWidth;
|
073 |
}
|
074 |
075 |
public void setAnimationDuration(int animationDuration)
|
076 |
{
|
077 |
mAnimationDuration = animationDuration;
|
078 |
}
|
079 |
|
080 |
public void setSnapBorderRatio(float snapBorderRatio)
|
081 |
{
|
082 |
mSnapBorderRatio = snapBorderRatio;
|
083 |
}
|
084 |
085 |
public void setIsGalleryCircular(boolean isGalleryCircular)
|
086 |
{
|
087 |
if (mIsGalleryCircular != isGalleryCircular)
|
088 |
{
|
089 |
mIsGalleryCircular = isGalleryCircular;
|
090 |
|
091 |
if (mCurrentPosition == getFirstPosition())
|
092 |
{
|
093 |
// We need to reload the view immediately to the left to change it to circular view or blank
|
094 |
mViews[getPrevViewNumber(mCurrentViewNumber)].recycleView(getPrevPosition(mCurrentPosition));
|
095 |
}
|
096 |
|
097 |
if (mCurrentPosition == getLastPosition())
|
098 |
{
|
099 |
// We need to reload the view immediately to the right to change it to circular view or blank
|
100 |
mViews[getNextViewNumber(mCurrentViewNumber)].recycleView(getNextPosition(mCurrentPosition));
|
101 |
}
|
102 |
}
|
103 |
}
|
104 |
105 |
public int getGalleryCount()
|
106 |
{
|
107 |
return (mAdapter == null) ? 0 : mAdapter.getCount();
|
108 |
}
|
109 |
110 |
public int getFirstPosition()
|
111 |
{
|
112 |
return 0;
|
113 |
}
|
114 |
115 |
public int getLastPosition()
|
116 |
{
|
117 |
return (getGalleryCount() == 0) ? 0 : getGalleryCount() - 1;
|
118 |
}
|
119 |
120 |
private int getPrevPosition(int relativePosition)
|
121 |
{
|
122 |
int prevPosition = relativePosition - 1;
|
123 |
124 |
if (prevPosition < getFirstPosition())
|
125 |
{
|
126 |
prevPosition = getFirstPosition() - 1;
|
127 |
128 |
if (mIsGalleryCircular == true)
|
129 |
{
|
130 |
prevPosition = getLastPosition();
|
131 |
}
|
132 |
}
|
133 |
134 |
return prevPosition;
|
135 |
}
|
136 |
137 |
private int getNextPosition(int relativePosition)
|
138 |
{
|
139 |
int nextPosition = relativePosition + 1;
|
140 |
141 |
if (nextPosition > getLastPosition())
|
142 |
{
|
143 |
nextPosition = getLastPosition() + 1;
|
144 |
145 |
if (mIsGalleryCircular == true)
|
146 |
{
|
147 |
nextPosition = getFirstPosition();
|
148 |
}
|
149 |
}
|
150 |
151 |
return nextPosition;
|
152 |
}
|
153 |
154 |
private int getPrevViewNumber(int relativeViewNumber)
|
155 |
{
|
156 |
return (relativeViewNumber == 0) ? 2 : relativeViewNumber - 1;
|
157 |
}
|
158 |
159 |
private int getNextViewNumber(int relativeViewNumber)
|
160 |
{
|
161 |
return (relativeViewNumber == 2) ? 0 : relativeViewNumber + 1;
|
162 |
}
|
163 |
|
164 |
@Override
|
165 |
protected void onLayout(boolean changed, int left, int top, int right, int bottom)
|
166 |
{
|
167 |
super.onLayout(changed, left, top, right, bottom);
|
168 |
169 |
// Calculate our view width
|
170 |
mGalleryWidth = right - left;
|
171 |
172 |
if (changed == true)
|
173 |
{
|
174 |
// Position views at correct starting offsets
|
175 |
mViews[0].setOffset(0, 0, mCurrentViewNumber);
|
176 |
mViews[1].setOffset(0, 0, mCurrentViewNumber);
|
177 |
mViews[2].setOffset(0, 0, mCurrentViewNumber);
|
178 |
}
|
179 |
}
|
180 |
181 |
public void setAdapter(Adapter adapter)
|
182 |
{
|
183 |
mAdapter = adapter;
|
184 |
mCurrentPosition = 0;
|
185 |
mCurrentViewNumber = 0;
|
186 |
187 |
// Load the initial views from adapter
|
188 |
mViews[0].recycleView(mCurrentPosition);
|
189 |
mViews[1].recycleView(getNextPosition(mCurrentPosition));
|
190 |
mViews[2].recycleView(getPrevPosition(mCurrentPosition));
|
191 |
192 |
// Position views at correct starting offsets
|
193 |
mViews[0].setOffset(0, 0, mCurrentViewNumber);
|
194 |
mViews[1].setOffset(0, 0, mCurrentViewNumber);
|
195 |
mViews[2].setOffset(0, 0, mCurrentViewNumber);
|
196 |
}
|
197 |
198 |
private int getViewOffset(int viewNumber, int relativeViewNumber)
|
199 |
{
|
200 |
// Determine width including configured padding width
|
201 |
int offsetWidth = mGalleryWidth + mViewPaddingWidth;
|
202 |
203 |
// Position the previous view one measured width to left
|
204 |
if (viewNumber == getPrevViewNumber(relativeViewNumber))
|
205 |
{
|
206 |
return offsetWidth;
|
207 |
}
|
208 |
209 |
// Position the next view one measured width to the right
|
210 |
if (viewNumber == getNextViewNumber(relativeViewNumber))
|
211 |
{
|
212 |
return offsetWidth * -1;
|
213 |
}
|
214 |
215 |
return 0;
|
216 |
}
|
217 |
218 |
void movePrevious()
|
219 |
{
|
220 |
// Slide to previous view
|
221 |
mFlingDirection = 1;
|
222 |
processGesture();
|
223 |
}
|
224 |
225 |
void moveNext()
|
226 |
{
|
227 |
// Slide to next view
|
228 |
mFlingDirection = -1;
|
229 |
processGesture();
|
230 |
}
|
231 |
232 |
@Override
|
233 |
public boolean onKeyDown(int keyCode, KeyEvent event)
|
234 |
{
|
235 |
switch (keyCode)
|
236 |
{
|
237 |
case KeyEvent.KEYCODE_DPAD_LEFT:
|
238 |
movePrevious();
|
239 |
return true;
|
240 |
|
241 |
case KeyEvent.KEYCODE_DPAD_RIGHT:
|
242 |
moveNext();
|
243 |
return true;
|
244 |
|
245 |
case KeyEvent.KEYCODE_DPAD_CENTER:
|
246 |
case KeyEvent.KEYCODE_ENTER:
|
247 |
}
|
248 |
249 |
return super.onKeyDown(keyCode, event);
|
250 |
}
|
251 |
252 |
public boolean onGalleryTouchEvent(MotionEvent event)
|
253 |
{
|
254 |
boolean consumed = mGestureDetector.onTouchEvent(event);
|
255 |
|
256 |
if (event.getAction() == MotionEvent.ACTION_UP)
|
257 |
{
|
258 |
if (mIsTouched || mIsDragging)
|
259 |
{
|
260 |
processScrollSnap();
|
261 |
processGesture();
|
262 |
}
|
263 |
}
|
264 |
|
265 |
return consumed;
|
266 |
}
|
267 |
268 |
void processGesture()
|
269 |
{
|
270 |
int newViewNumber = mCurrentViewNumber;
|
271 |
int reloadViewNumber = 0;
|
272 |
int reloadPosition = 0;
|
273 |
274 |
mIsTouched = false;
|
275 |
mIsDragging = false;
|
276 |
277 |
if (mFlingDirection > 0)
|
278 |
{
|
279 |
if (mCurrentPosition > getFirstPosition() || mIsGalleryCircular == true)
|
280 |
{
|
281 |
// Determine previous view and outgoing view to recycle
|
282 |
newViewNumber = getPrevViewNumber(mCurrentViewNumber);
|
283 |
mCurrentPosition = getPrevPosition(mCurrentPosition);
|
284 |
reloadViewNumber = getNextViewNumber(mCurrentViewNumber);
|
285 |
reloadPosition = getPrevPosition(mCurrentPosition);
|
286 |
}
|
287 |
}
|
288 |
289 |
if (mFlingDirection < 0)
|
290 |
{
|
291 |
if (mCurrentPosition < getLastPosition() || mIsGalleryCircular == true)
|
292 |
{
|
293 |
// Determine the next view and outgoing view to recycle
|
294 |
newViewNumber = getNextViewNumber(mCurrentViewNumber);
|
295 |
mCurrentPosition = getNextPosition(mCurrentPosition);
|
296 |
reloadViewNumber = getPrevViewNumber(mCurrentViewNumber);
|
297 |
reloadPosition = getNextPosition(mCurrentPosition);
|
298 |
}
|
299 |
}
|
300 |
301 |
if (newViewNumber != mCurrentViewNumber)
|
302 |
{
|
303 |
mCurrentViewNumber = newViewNumber;
|
304 |
305 |
// Reload outgoing view from adapter in new position
|
306 |
mViews[reloadViewNumber].recycleView(reloadPosition);
|
307 |
}
|
308 |
309 |
// Ensure input focus on the current view
|
310 |
mViews[mCurrentViewNumber].requestFocus();
|
311 |
312 |
// Run the slide animations for view transitions
|
313 |
mAnimation.prepareAnimation(mCurrentViewNumber);
|
314 |
this.startAnimation(mAnimation);
|
315 |
316 |
// Reset fling state
|
317 |
mFlingDirection = 0;
|
318 |
}
|
319 |
320 |
void processScrollSnap()
|
321 |
{
|
322 |
// Snap to next view if scrolled passed snap position
|
323 |
float rollEdgeWidth = mGalleryWidth * mSnapBorderRatio;
|
324 |
int rollOffset = mGalleryWidth - (int) rollEdgeWidth;
|
325 |
int currentOffset = mViews[mCurrentViewNumber].getCurrentOffset();
|
326 |
327 |
if (currentOffset <= rollOffset * -1)
|
328 |
{
|
329 |
// Snap to previous view
|
330 |
mFlingDirection = 1;
|
331 |
}
|
332 |
333 |
if (currentOffset >= rollOffset)
|
334 |
{
|
335 |
// Snap to next view
|
336 |
mFlingDirection = -1;
|
337 |
}
|
338 |
}
|
339 |
340 |
private class FlingGalleryView
|
341 |
{
|
342 |
private int mViewNumber;
|
343 |
private FrameLayout mParentLayout;
|
344 |
|
345 |
private FrameLayout mInvalidLayout = null;
|
346 |
private LinearLayout mInternalLayout = null;
|
347 |
private View mExternalView = null;
|
348 |
349 |
public FlingGalleryView(int viewNumber, FrameLayout parentLayout)
|
350 |
{
|
351 |
mViewNumber = viewNumber;
|
352 |
mParentLayout = parentLayout;
|
353 |
354 |
// Invalid layout is used when outside gallery
|
355 |
mInvalidLayout = new FrameLayout(mContext);
|
356 |
mInvalidLayout.setLayoutParams(new LinearLayout.LayoutParams(
|
357 |
LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
|
358 |
359 |
// Internal layout is permanent for duration
|
360 |
mInternalLayout = new LinearLayout(mContext);
|
361 |
mInternalLayout.setLayoutParams(new LinearLayout.LayoutParams(
|
362 |
LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
|
363 |
364 |
mParentLayout.addView(mInternalLayout);
|
365 |
}
|
366 |
367 |
public void recycleView(int newPosition)
|
368 |
{
|
369 |
if (mExternalView != null)
|
370 |
{
|
371 |
mInternalLayout.removeView(mExternalView);
|
372 |
}
|
373 |
374 |
if (mAdapter != null)
|
375 |
{
|
376 |
if (newPosition >= getFirstPosition() && newPosition <= getLastPosition())
|
377 |
{
|
378 |
mExternalView = mAdapter.getView(newPosition, mExternalView, mInternalLayout);
|
379 |
}
|
380 |
else
|
381 |
{
|
382 |
mExternalView = mInvalidLayout;
|
383 |
}
|
384 |
}
|
385 |
386 |
if (mExternalView != null)
|
387 |
{
|
388 |
mInternalLayout.addView(mExternalView, new LinearLayout.LayoutParams(
|
389 |
LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
|
390 |
}
|
391 |
}
|
392 |
393 |
public void setOffset(int xOffset, int yOffset, int relativeViewNumber)
|
394 |
{
|
395 |
// Scroll the target view relative to its own position relative to currently displayed view
|
396 |
mInternalLayout.scrollTo(getViewOffset(mViewNumber, relativeViewNumber) + xOffset, yOffset);
|
397 |
}
|
398 |
|
399 |
public int getCurrentOffset()
|
400 |
{
|
401 |
// Return the current scroll position
|
402 |
return mInternalLayout.getScrollX();
|
403 |
}
|
404 |
405 |
public void requestFocus()
|
406 |
{
|
407 |
mInternalLayout.requestFocus();
|
408 |
}
|
409 |
}
|
410 |
411 |
private class FlingGalleryAnimation extends Animation
|
412 |
{
|
413 |
private boolean mIsAnimationInProgres;
|
414 |
private int mRelativeViewNumber;
|
415 |
private int mInitialOffset;
|
416 |
private int mTargetOffset;
|
417 |
private int mTargetDistance;
|
418 |
|
419 |
public FlingGalleryAnimation()
|
420 |
{
|
421 |
mIsAnimationInProgres = false;
|
422 |
mRelativeViewNumber = 0;
|
423 |
mInitialOffset = 0;
|
424 |
mTargetOffset = 0;
|
425 |
mTargetDistance = 0;
|
426 |
}
|
427 |
|
428 |
public void prepareAnimation(int relativeViewNumber)
|
429 |
{
|
430 |
// If we are animating relative to a new view
|
431 |
if (mRelativeViewNumber != relativeViewNumber)
|
432 |
{
|
433 |
if (mIsAnimationInProgres == true)
|
434 |
{
|
435 |
// We only have three views so if requested again to animate in same direction we must snap
|
436 |
int newDirection = (relativeViewNumber == getPrevViewNumber(mRelativeViewNumber)) ? 1 : -1;
|
437 |
int animDirection = (mTargetDistance < 0) ? 1 : -1;
|
438 |
439 |
// If animation in same direction
|
440 |
if (animDirection == newDirection)
|
441 |
{
|
442 |
// Ran out of time to animate so snap to the target offset
|
443 |
mViews[0].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
444 |
mViews[1].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
445 |
mViews[2].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
446 |
}
|
447 |
}
|
448 |
|
449 |
// Set relative view number for animation
|
450 |
mRelativeViewNumber = relativeViewNumber;
|
451 |
}
|
452 |
453 |
// Note: In this implementation the targetOffset will always be zero
|
454 |
// as we are centering the view; but we include the calculations of
|
455 |
// targetOffset and targetDistance for use in future implementations
|
456 |
457 |
mInitialOffset = mViews[mRelativeViewNumber].getCurrentOffset();
|
458 |
mTargetOffset = getViewOffset(mRelativeViewNumber, mRelativeViewNumber);
|
459 |
mTargetDistance = mTargetOffset - mInitialOffset;
|
460 |
461 |
// Configure base animation properties
|
462 |
this.setDuration(mAnimationDuration);
|
463 |
this.setInterpolator(mDecelerateInterpolater);
|
464 |
465 |
// Start/continued animation
|
466 |
mIsAnimationInProgres = true;
|
467 |
}
|
468 |
469 |
@Override
|
470 |
protected void applyTransformation(float interpolatedTime, Transformation transformation)
|
471 |
{
|
472 |
// Ensure interpolatedTime does not over-shoot then calculate new offset
|
473 |
interpolatedTime = (interpolatedTime > 1.0f) ? 1.0f : interpolatedTime;
|
474 |
int offset = mInitialOffset + (int) (mTargetDistance * interpolatedTime);
|
475 |
476 |
for (int viewNumber = 0; viewNumber < 3; viewNumber++)
|
477 |
{
|
478 |
// Only need to animate the visible views as the other view will always be off-screen
|
479 |
if ((mTargetDistance > 0 && viewNumber != getNextViewNumber(mRelativeViewNumber)) ||
|
480 |
(mTargetDistance < 0 && viewNumber != getPrevViewNumber(mRelativeViewNumber)))
|
481 |
{
|
482 |
mViews[viewNumber].setOffset(offset, 0, mRelativeViewNumber);
|
483 |
}
|
484 |
}
|
485 |
}
|
486 |
487 |
@Override
|
488 |
public boolean getTransformation(long currentTime, Transformation outTransformation)
|
489 |
{
|
490 |
if (super.getTransformation(currentTime, outTransformation) == false)
|
491 |
{
|
492 |
// Perform final adjustment to offsets to cleanup animation
|
493 |
mViews[0].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
494 |
mViews[1].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
495 |
mViews[2].setOffset(mTargetOffset, 0, mRelativeViewNumber);
|
496 |
497 |
// Reached the animation target
|
498 |
mIsAnimationInProgres = false;
|
499 |
500 |
return false;
|
501 |
}
|
502 |
|
503 |
// Cancel if the screen touched
|
504 |
if (mIsTouched || mIsDragging)
|
505 |
{
|
506 |
// Note that at this point we still consider ourselves to be animating
|
507 |
// because we have not yet reached the target offset; its just that the
|
508 |
// user has temporarily interrupted the animation with a touch gesture
|
509 |
510 |
return false;
|
511 |
}
|
512 |
513 |
return true;
|
514 |
}
|
515 |
}
|
516 |
517 |
private class FlingGestureDetector extends GestureDetector.SimpleOnGestureListener
|
518 |
{
|
519 |
@Override
|
520 |
public boolean onDown(MotionEvent e)
|
521 |
{
|
522 |
// Stop animation
|
523 |
mIsTouched = true;
|
524 |
525 |
// Reset fling state
|
526 |
mFlingDirection = 0;
|
527 |
return true;
|
528 |
}
|
529 |
530 |
@Override
|
531 |
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
|
532 |
{
|
533 |
if (e2.getAction() == MotionEvent.ACTION_MOVE)
|
534 |
{
|
535 |
if (mIsDragging == false)
|
536 |
{
|
537 |
// Stop animation
|
538 |
mIsTouched = true;
|
539 |
|
540 |
// Reconfigure scroll
|
541 |
mIsDragging = true;
|
542 |
mFlingDirection = 0;
|
543 |
mScrollTimestamp = System.currentTimeMillis();
|
544 |
mCurrentOffset = mViews[mCurrentViewNumber].getCurrentOffset();
|
545 |
}
|
546 |
547 |
float maxVelocity = mGalleryWidth / (mAnimationDuration / 1000.0f);
|
548 |
long timestampDelta = System.currentTimeMillis() - mScrollTimestamp;
|
549 |
float maxScrollDelta = maxVelocity * (timestampDelta / 1000.0f);
|
550 |
float currentScrollDelta = e1.getX() - e2.getX();
|
551 |
552 |
if (currentScrollDelta < maxScrollDelta * -1) currentScrollDelta = maxScrollDelta * -1;
|
553 |
if (currentScrollDelta > maxScrollDelta) currentScrollDelta = maxScrollDelta;
|
554 |
int scrollOffset = Math.round(mCurrentOffset + currentScrollDelta);
|
555 |
556 |
// We can't scroll more than the width of our own frame layout
|
557 |
if (scrollOffset >= mGalleryWidth) scrollOffset = mGalleryWidth;
|
558 |
if (scrollOffset <= mGalleryWidth * -1) scrollOffset = mGalleryWidth * -1;
|
559 |
|
560 |
mViews[0].setOffset(scrollOffset, 0, mCurrentViewNumber);
|
561 |
mViews[1].setOffset(scrollOffset, 0, mCurrentViewNumber);
|
562 |
mViews[2].setOffset(scrollOffset, 0, mCurrentViewNumber);
|
563 |
}
|
564 |
565 |
return false;
|
566 |
}
|
567 |
568 |
@Override
|
569 |
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
|
570 |
{
|
571 |
if (Math.abs(e1.getY() - e2.getY()) <= swipe_max_off_path)
|
572 |
{
|
573 |
if (e2.getX() - e1.getX() > swipe_min_distance && Math.abs(velocityX) > swipe_threshold_veloicty)
|
574 |
{
|
575 |
movePrevious();
|
576 |
}
|
577 |
578 |
if(e1.getX() - e2.getX() > swipe_min_distance && Math.abs(velocityX) > swipe_threshold_veloicty)
|
579 |
{
|
580 |
moveNext();
|
581 |
}
|
582 |
}
|
583 |
584 |
return false;
|
585 |
}
|
586 |
587 |
@Override
|
588 |
public void onLongPress(MotionEvent e)
|
589 |
{
|
590 |
// Finalise scrolling
|
591 |
mFlingDirection = 0;
|
592 |
processGesture();
|
593 |
}
|
594 |
595 |
@Override
|
596 |
public void onShowPress(MotionEvent e)
|
597 |
{
|
598 |
}
|
599 |
600 |
@Override
|
601 |
public boolean onSingleTapUp(MotionEvent e)
|
602 |
{
|
603 |
// Reset fling state
|
604 |
mFlingDirection = 0;
|
605 |
return false;
|
606 |
}
|
607 |
}
|
608 |
} |