();
76 | for (int i = 0; i < eggs.length; ++i) {
77 | eggList.add(new ContentsWrapper(eggs[i]));
78 | }
79 | // mAdapter = new StableArrayAdapter(this, R.layout.eggsample_item, R.id.title, eggList);
80 | mAdapter = new StableWrapperArrayAdapter(this, R.layout.eggsample_item, R.id.title, eggList);
81 | mListView.setAdapter(mAdapter);
82 |
83 | mTouchListener = new SwipeDismissListViewTouchListener(
84 | mListView,
85 | new SwipeDismissListViewTouchListener.DismissCallbacks() {
86 | @Override
87 | public void onDismiss(ListView listView, View viewToRemove, int position) {
88 | // listView.setEnabled(false);
89 | mListViewAnimator.animateRemoval(listView, viewToRemove, position);
90 | }
91 | @Override
92 | public boolean canDismiss(int position) {
93 | mUndoPopup.dismiss(); // dismiss it if user touches away from popup
94 | // return mListView.isEnabled(); // prevent bugs from multiple swiping
95 | // return !listViewAnimator.listViewIsAnimating();
96 | return true;
97 | }
98 | @Override
99 | public boolean listViewIsAnimating() {
100 | return mListViewAnimator.listViewIsAnimating();
101 | }
102 | @Override
103 | public void currentlyAnimatingSwipe(boolean isAnimating) {
104 | // currentlyAnimatingSwipe = isAnimating;
105 | Log.d("onScrollStateChanged", "Setting addButton enabled(" + !isAnimating + ")");
106 | addButton.setEnabled(!isAnimating);
107 | }
108 | /*@Override
109 | public void currentlyAnimatingScroll(boolean isAnimating) {
110 | addButton.setEnabled(!isAnimating);
111 | }*/
112 | }, 0);
113 | mListView.setOnTouchListener(mTouchListener);
114 | mListView.setOnScrollListener(mTouchListener.makeScrollListener());
115 | mDensity = mListView.getResources().getDisplayMetrics().density;
116 |
117 | LayoutInflater inflater = (LayoutInflater) getApplicationContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
118 |
119 | View undoPopupView = inflater.inflate(R.layout.undo_popup, null);
120 | mUndoButton = (Button)undoPopupView.findViewById(R.id.undo);
121 |
122 | mUndoText = (TextView)undoPopupView.findViewById(R.id.text);
123 | mUndoText.setText("");
124 |
125 | mUndoPopup = new PopupWindow(undoPopupView);
126 | mUndoPopup.setAnimationStyle(R.style.fade_animation);
127 |
128 | // Get screen width in dp and set width of popups respectively
129 | int xdensity = (int)(mListView.getContext().getResources().getDisplayMetrics().widthPixels / mDensity);
130 | if(xdensity < 300) {
131 | mUndoPopup.setWidth((int)(mDensity * 280));
132 | } else if(xdensity < 350) {
133 | mUndoPopup.setWidth((int)(mDensity * 300));
134 | } else if(xdensity < 500) {
135 | mUndoPopup.setWidth((int)(mDensity * 330));
136 | } else {
137 | mUndoPopup.setWidth((int)(mDensity * 450));
138 | }
139 | mUndoPopup.setHeight((int)(mDensity * 56));
140 | mUndoPopup.setOnDismissListener(new OnDismissListener() {
141 | @Override
142 | public void onDismiss() {
143 | // toUndoOrRemove = null;
144 | }
145 | });
146 | index = eggs.length - 1;
147 | }
148 |
149 | @Override
150 | protected void onResume() {
151 | super.onResume();
152 | isRunning = true;
153 | }
154 |
155 | @Override
156 | protected void onPause() {
157 | super.onPause();
158 | isRunning = false;
159 | try {
160 | mUndoPopup.dismiss();
161 | } catch (Exception e) {
162 | e.printStackTrace();
163 | }
164 | }
165 |
166 | public ListViewAnimator getListViewAnimator() {
167 | return mListViewAnimator;
168 | }
169 |
170 | @Override
171 | protected void onStart() {
172 | super.onStart();
173 |
174 | mUndoButton.setOnClickListener(new View.OnClickListener() {
175 | @Override
176 | public void onClick(View v) {
177 | mListViewAnimator.animateAddition(toUndoOrRemove, adapterRemoveId);
178 | mUndoPopup.dismiss();
179 | addButton.setEnabled(false);
180 | }
181 | });
182 |
183 | mListViewAnimator = new ListViewAnimator(new ListViewAnimator.Callbacks() {
184 | @Override
185 | public void undoCallback() {
186 | // String title = toUndoOrRemove;
187 | String title = toUndoOrRemove.getContents();
188 | mUndoText.setText("Removed '" + title + "'");
189 | if (isRunning) { // Check if isRunning in order to prevent rare crash if user swipes and exits app
190 | try {
191 | mUndoPopup.showAtLocation(mListView,
192 | Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM,
193 | 0, (int)(mDensity * 15));
194 | timeDismissUndoMessage();
195 | } catch (Exception e) {
196 | e.printStackTrace();
197 | }
198 | }
199 | }
200 | /*@Override
201 | public void deleteAdapterItemCallback(View viewToRemove) {
202 | int position = mListView.getPositionForView(viewToRemove);
203 | adapterRemoveId = position;
204 | toUndoOrRemove = mAdapter.getItem(position);
205 | mAdapter.remove(mAdapter.getItem(position));
206 | mAdapter.notifyDataSetChanged();
207 | }*/
208 | @Override
209 | public void deleteAdapterItemCallback(int position) {
210 | // int position = mListView.getPositionForView(viewToRemove);
211 | adapterRemoveId = position;
212 | toUndoOrRemove = mAdapter.getItem(position);
213 | mAdapter.remove(mAdapter.getItem(position));
214 | mAdapter.notifyDataSetChanged();
215 | }
216 | @Override
217 | public void addButtonSetEnabledCallback(boolean isEnabled) {
218 | addButton.setEnabled(isEnabled);
219 | }
220 | @Override
221 | public long getItemIdForAnimation(int position) {
222 | return mAdapter.getItemIdForAnimation(position);
223 | }
224 | @Override
225 | public void addAdapterItemCallback(int pos, Object itemToAdd) {
226 | // String toAdd = (String) itemToAdd;
227 | ContentsWrapper toAdd = (ContentsWrapper) itemToAdd;
228 | mAdapter.insert(toAdd, pos);
229 | // mAdapter.add(toAdd);
230 | // mAdapter.addItem(toAdd, pos);
231 | mAdapter.reIdMapObjects();
232 | mAdapter.notifyDataSetChanged();
233 | }
234 | }, mListView, mAdapter);
235 |
236 | }
237 |
238 | private Handler handler = new Handler();
239 | Runnable runnable = new Runnable() {
240 | @Override
241 | public void run() {
242 | try {
243 | mUndoPopup.dismiss();
244 | } catch (Exception e) {
245 | e.printStackTrace();
246 | }
247 | }
248 | };
249 |
250 | private void timeDismissUndoMessage() {
251 | handler.removeCallbacks(runnable);
252 | handler.postDelayed(runnable, 5000); // 5 second delay
253 | }
254 |
255 | @Override
256 | public boolean onCreateOptionsMenu(Menu menu) {
257 | // Inflate the menu; this adds items to the action bar if it is present.
258 | getMenuInflater().inflate(R.menu.main, menu);
259 | addButton = menu.findItem(R.id.add);
260 | addButton.setEnabled(true);
261 | return true;
262 | }
263 |
264 | @Override
265 | public boolean onOptionsItemSelected(MenuItem item) {
266 | // Handle action bar item clicks here. The action bar will
267 | // automatically handle clicks on the Home/Up button, so long
268 | // as you specify a parent activity in AndroidManifest.xml.
269 | switch (item.getItemId()) {
270 | case R.id.add:
271 | item.setEnabled(false);
272 | mListView.scrollBy(0, 0);
273 | mUndoPopup.dismiss();
274 | // listViewAnimator.animateAddition(eggs[index]);
275 | mListViewAnimator.animateAddition(new ContentsWrapper(eggs[index]));
276 | // index = index > eggs.length - 2 ? 0 : ++index;
277 | index = index == 0 ? eggs.length - 1 : --index;
278 | return true;
279 | /*case R.id.switch_activity:
280 | // Intent intent = new Intent(this, ImageActivity.class);
281 | // intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
282 | // intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
283 | // intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
284 | // intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
285 | // startActivity(intent);
286 |
287 | OldSwipeDismissListViewTouchListener mOldTouchListener =
288 | new OldSwipeDismissListViewTouchListener(
289 | mListView,
290 | new OldSwipeDismissListViewTouchListener.DismissCallbacks() {
291 | @Override
292 | public boolean canDismiss(int position) {
293 | return true;
294 | }
295 |
296 | @Override
297 | public void onDismiss(ListView listView, int[] reverseSortedPositions) {
298 | for (int position : reverseSortedPositions) {
299 | mAdapter.remove(mAdapter.getItem(position));
300 | }
301 | mAdapter.notifyDataSetChanged();
302 | }
303 | });
304 | mListView.setOnTouchListener(mOldTouchListener);
305 | mListView.setOnScrollListener(mOldTouchListener.makeScrollListener());
306 |
307 | break;*/
308 | default:
309 | break;
310 | }
311 | return super.onOptionsItemSelected(item);
312 | }
313 |
314 | /**
315 | * A placeholder fragment containing a simple view.
316 | */
317 | public static class PlaceholderFragment extends Fragment {
318 |
319 | public PlaceholderFragment() {
320 | }
321 |
322 | @Override
323 | public View onCreateView(LayoutInflater inflater, ViewGroup container,
324 | Bundle savedInstanceState) {
325 | View rootView = inflater.inflate(R.layout.fragment_main, container,
326 | false);
327 | return rootView;
328 | }
329 | }
330 |
331 | }
332 |
--------------------------------------------------------------------------------
/src/com/witheyjr/listviewanimator/OldSwipeDismissListViewTouchListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2013 Google Inc.
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.witheyjr.listviewanimator;
18 |
19 | import android.animation.Animator;
20 | import android.animation.AnimatorListenerAdapter;
21 | import android.animation.ValueAnimator;
22 | import android.annotation.SuppressLint;
23 | import android.graphics.Rect;
24 | import android.os.SystemClock;
25 | import android.view.MotionEvent;
26 | import android.view.VelocityTracker;
27 | import android.view.View;
28 | import android.view.ViewConfiguration;
29 | import android.view.ViewGroup;
30 | import android.view.ViewPropertyAnimator;
31 | import android.widget.AbsListView;
32 | import android.widget.ListView;
33 |
34 | import java.util.ArrayList;
35 | import java.util.Collections;
36 | import java.util.List;
37 |
38 | /**
39 | * A {@link View.OnTouchListener} that makes the list items in a {@link ListView}
40 | * dismissable. {@link ListView} is given special treatment because by default it handles touches
41 | * for its list items... i.e. it's in charge of drawing the pressed state (the list selector),
42 | * handling list item clicks, etc.
43 | *
44 | * After creating the listener, the caller should also call
45 | * {@link ListView#setOnScrollListener(AbsListView.OnScrollListener)}, passing
46 | * in the scroll listener returned by {@link #makeScrollListener()}. If a scroll listener is
47 | * already assigned, the caller should still pass scroll changes through to this listener. This will
48 | * ensure that this {@link SwipeDismissListViewTouchListener} is paused during list view
49 | * scrolling.
50 | *
51 | * Example usage:
52 | *
53 | *
54 | * SwipeDismissListViewTouchListener touchListener =
55 | * new SwipeDismissListViewTouchListener(
56 | * listView,
57 | * new SwipeDismissListViewTouchListener.OnDismissCallback() {
58 | * public void onDismiss(ListView listView, int[] reverseSortedPositions) {
59 | * for (int position : reverseSortedPositions) {
60 | * adapter.remove(adapter.getItem(position));
61 | * }
62 | * adapter.notifyDataSetChanged();
63 | * }
64 | * });
65 | * listView.setOnTouchListener(touchListener);
66 | * listView.setOnScrollListener(touchListener.makeScrollListener());
67 | *
68 | *
69 | * This class Requires API level 12 or later due to use of {@link
70 | * ViewPropertyAnimator}.
71 | *
72 | * For a generalized {@link View.OnTouchListener} that makes any view dismissable,
73 | * see {@link SwipeDismissTouchListener}.
74 | *
75 | * @see SwipeDismissTouchListener
76 | */
77 | @SuppressLint("NewApi")
78 | public class OldSwipeDismissListViewTouchListener implements View.OnTouchListener {
79 | // Cached ViewConfiguration and system-wide constant values
80 | private int mSlop;
81 | private int mMinFlingVelocity;
82 | private int mMaxFlingVelocity;
83 | private long mAnimationTime;
84 |
85 | // Fixed properties
86 | private ListView mListView;
87 | private DismissCallbacks mCallbacks;
88 | private int mViewWidth = 1; // 1 and not 0 to prevent dividing by zero
89 |
90 | // Transient properties
91 | private List mPendingDismisses = new ArrayList();
92 | private int mDismissAnimationRefCount = 0;
93 | private float mDownX;
94 | private float mDownY;
95 | private boolean mSwiping;
96 | private int mSwipingSlop;
97 | private VelocityTracker mVelocityTracker;
98 | private int mDownPosition;
99 | private View mDownView;
100 | private boolean mPaused;
101 |
102 | /**
103 | * The callback interface used by {@link SwipeDismissListViewTouchListener} to inform its client
104 | * about a successful dismissal of one or more list item positions.
105 | */
106 | public interface DismissCallbacks {
107 | /**
108 | * Called to determine whether the given position can be dismissed.
109 | */
110 | boolean canDismiss(int position);
111 |
112 | /**
113 | * Called when the user has indicated they she would like to dismiss one or more list item
114 | * positions.
115 | *
116 | * @param listView The originating {@link ListView}.
117 | * @param reverseSortedPositions An array of positions to dismiss, sorted in descending
118 | * order for convenience.
119 | */
120 | void onDismiss(ListView listView, int[] reverseSortedPositions);
121 | }
122 |
123 | /**
124 | * Constructs a new swipe-to-dismiss touch listener for the given list view.
125 | *
126 | * @param listView The list view whose items should be dismissable.
127 | * @param callbacks The callback to trigger when the user has indicated that she would like to
128 | * dismiss one or more list items.
129 | */
130 | public OldSwipeDismissListViewTouchListener(ListView listView, DismissCallbacks callbacks) {
131 | ViewConfiguration vc = ViewConfiguration.get(listView.getContext());
132 | mSlop = vc.getScaledTouchSlop();
133 | mMinFlingVelocity = vc.getScaledMinimumFlingVelocity() * 16;
134 | mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity();
135 | mAnimationTime = listView.getContext().getResources().getInteger(
136 | android.R.integer.config_mediumAnimTime);
137 | mListView = listView;
138 | mCallbacks = callbacks;
139 | }
140 |
141 | /**
142 | * Enables or disables (pauses or resumes) watching for swipe-to-dismiss gestures.
143 | *
144 | * @param enabled Whether or not to watch for gestures.
145 | */
146 | public void setEnabled(boolean enabled) {
147 | mPaused = !enabled;
148 | }
149 |
150 | /**
151 | * Returns an {@link AbsListView.OnScrollListener} to be added to the {@link
152 | * ListView} using {@link ListView#setOnScrollListener(AbsListView.OnScrollListener)}.
153 | * If a scroll listener is already assigned, the caller should still pass scroll changes through
154 | * to this listener. This will ensure that this {@link SwipeDismissListViewTouchListener} is
155 | * paused during list view scrolling.
156 | *
157 | * @see SwipeDismissListViewTouchListener
158 | */
159 | public AbsListView.OnScrollListener makeScrollListener() {
160 | return new AbsListView.OnScrollListener() {
161 | @Override
162 | public void onScrollStateChanged(AbsListView absListView, int scrollState) {
163 | setEnabled(scrollState != AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
164 | }
165 |
166 | @Override
167 | public void onScroll(AbsListView absListView, int i, int i1, int i2) {
168 | }
169 | };
170 | }
171 |
172 | @Override
173 | public boolean onTouch(View view, MotionEvent motionEvent) {
174 | if (mViewWidth < 2) {
175 | mViewWidth = mListView.getWidth();
176 | }
177 |
178 | switch (motionEvent.getActionMasked()) {
179 | case MotionEvent.ACTION_DOWN: {
180 | if (mPaused) {
181 | return false;
182 | }
183 |
184 | // TODO: ensure this is a finger, and set a flag
185 |
186 | // Find the child view that was touched (perform a hit test)
187 | Rect rect = new Rect();
188 | int childCount = mListView.getChildCount();
189 | int[] listViewCoords = new int[2];
190 | mListView.getLocationOnScreen(listViewCoords);
191 | int x = (int) motionEvent.getRawX() - listViewCoords[0];
192 | int y = (int) motionEvent.getRawY() - listViewCoords[1];
193 | View child;
194 | for (int i = 0; i < childCount; i++) {
195 | child = mListView.getChildAt(i);
196 | child.getHitRect(rect);
197 | if (rect.contains(x, y)) {
198 | mDownView = child;
199 | break;
200 | }
201 | }
202 |
203 | if (mDownView != null) {
204 | mDownX = motionEvent.getRawX();
205 | mDownY = motionEvent.getRawY();
206 | mDownPosition = mListView.getPositionForView(mDownView);
207 | if (mCallbacks.canDismiss(mDownPosition)) {
208 | mVelocityTracker = VelocityTracker.obtain();
209 | mVelocityTracker.addMovement(motionEvent);
210 | } else {
211 | mDownView = null;
212 | }
213 | }
214 | return false;
215 | }
216 |
217 | case MotionEvent.ACTION_CANCEL: {
218 | if (mVelocityTracker == null) {
219 | break;
220 | }
221 |
222 | if (mDownView != null && mSwiping) {
223 | // cancel
224 | mDownView.animate()
225 | .translationX(0)
226 | .alpha(1)
227 | .setDuration(mAnimationTime)
228 | .setListener(null);
229 | }
230 | mVelocityTracker.recycle();
231 | mVelocityTracker = null;
232 | mDownX = 0;
233 | mDownY = 0;
234 | mDownView = null;
235 | mDownPosition = ListView.INVALID_POSITION;
236 | mSwiping = false;
237 | break;
238 | }
239 |
240 | case MotionEvent.ACTION_UP: {
241 | if (mVelocityTracker == null) {
242 | break;
243 | }
244 |
245 | float deltaX = motionEvent.getRawX() - mDownX;
246 | mVelocityTracker.addMovement(motionEvent);
247 | mVelocityTracker.computeCurrentVelocity(1000);
248 | float velocityX = mVelocityTracker.getXVelocity();
249 | float absVelocityX = Math.abs(velocityX);
250 | float absVelocityY = Math.abs(mVelocityTracker.getYVelocity());
251 | boolean dismiss = false;
252 | boolean dismissRight = false;
253 | if (Math.abs(deltaX) > mViewWidth / 2 && mSwiping) {
254 | dismiss = true;
255 | dismissRight = deltaX > 0;
256 | } else if (mMinFlingVelocity <= absVelocityX && absVelocityX <= mMaxFlingVelocity
257 | && absVelocityY < absVelocityX && mSwiping) {
258 | // dismiss only if flinging in the same direction as dragging
259 | dismiss = (velocityX < 0) == (deltaX < 0);
260 | dismissRight = mVelocityTracker.getXVelocity() > 0;
261 | }
262 | if (dismiss && mDownPosition != ListView.INVALID_POSITION) {
263 | // dismiss
264 | final View downView = mDownView; // mDownView gets null'd before animation ends
265 | final int downPosition = mDownPosition;
266 | ++mDismissAnimationRefCount;
267 | mDownView.animate()
268 | .translationX(dismissRight ? mViewWidth : -mViewWidth)
269 | .alpha(0)
270 | .setDuration(mAnimationTime)
271 | .setListener(new AnimatorListenerAdapter() {
272 | @Override
273 | public void onAnimationEnd(Animator animation) {
274 | performDismiss(downView, downPosition);
275 | }
276 | });
277 | } else {
278 | // cancel
279 | mDownView.animate()
280 | .translationX(0)
281 | .alpha(1)
282 | .setDuration(mAnimationTime)
283 | .setListener(null);
284 | }
285 | mVelocityTracker.recycle();
286 | mVelocityTracker = null;
287 | mDownX = 0;
288 | mDownY = 0;
289 | mDownView = null;
290 | mDownPosition = ListView.INVALID_POSITION;
291 | mSwiping = false;
292 | break;
293 | }
294 |
295 | case MotionEvent.ACTION_MOVE: {
296 | if (mVelocityTracker == null || mPaused) {
297 | break;
298 | }
299 |
300 | mVelocityTracker.addMovement(motionEvent);
301 | float deltaX = motionEvent.getRawX() - mDownX;
302 | float deltaY = motionEvent.getRawY() - mDownY;
303 | if (Math.abs(deltaX) > mSlop && Math.abs(deltaY) < Math.abs(deltaX) / 2) {
304 | mSwiping = true;
305 | mSwipingSlop = (deltaX > 0 ? mSlop : -mSlop);
306 | mListView.requestDisallowInterceptTouchEvent(true);
307 |
308 | // Cancel ListView's touch (un-highlighting the item)
309 | MotionEvent cancelEvent = MotionEvent.obtain(motionEvent);
310 | cancelEvent.setAction(MotionEvent.ACTION_CANCEL |
311 | (motionEvent.getActionIndex()
312 | << MotionEvent.ACTION_POINTER_INDEX_SHIFT));
313 | mListView.onTouchEvent(cancelEvent);
314 | cancelEvent.recycle();
315 | }
316 |
317 | if (mSwiping) {
318 | mDownView.setTranslationX(deltaX - mSwipingSlop);
319 | mDownView.setAlpha(Math.max(0f, Math.min(1f,
320 | 1f - 2f * Math.abs(deltaX) / mViewWidth)));
321 | return true;
322 | }
323 | break;
324 | }
325 | }
326 | return false;
327 | }
328 |
329 | class PendingDismissData implements Comparable {
330 | public int position;
331 | public View view;
332 |
333 | public PendingDismissData(int position, View view) {
334 | this.position = position;
335 | this.view = view;
336 | }
337 |
338 | @Override
339 | public int compareTo(PendingDismissData other) {
340 | // Sort by descending position
341 | return other.position - position;
342 | }
343 | }
344 |
345 | private void performDismiss(final View dismissView, final int dismissPosition) {
346 | // Animate the dismissed list item to zero-height and fire the dismiss callback when
347 | // all dismissed list item animations have completed. This triggers layout on each animation
348 | // frame; in the future we may want to do something smarter and more performant.
349 |
350 | final ViewGroup.LayoutParams lp = dismissView.getLayoutParams();
351 | final int originalHeight = dismissView.getHeight();
352 |
353 | ValueAnimator animator = ValueAnimator.ofInt(originalHeight, 1).setDuration(mAnimationTime);
354 |
355 | animator.addListener(new AnimatorListenerAdapter() {
356 | @Override
357 | public void onAnimationEnd(Animator animation) {
358 | --mDismissAnimationRefCount;
359 | if (mDismissAnimationRefCount == 0) {
360 | // No active animations, process all pending dismisses.
361 | // Sort by descending position
362 | Collections.sort(mPendingDismisses);
363 |
364 | int[] dismissPositions = new int[mPendingDismisses.size()];
365 | for (int i = mPendingDismisses.size() - 1; i >= 0; i--) {
366 | dismissPositions[i] = mPendingDismisses.get(i).position;
367 | }
368 | mCallbacks.onDismiss(mListView, dismissPositions);
369 |
370 | // Reset mDownPosition to avoid MotionEvent.ACTION_UP trying to start a dismiss
371 | // animation with a stale position
372 | mDownPosition = ListView.INVALID_POSITION;
373 |
374 | ViewGroup.LayoutParams lp;
375 | for (PendingDismissData pendingDismiss : mPendingDismisses) {
376 | // Reset view presentation
377 | pendingDismiss.view.setAlpha(1f);
378 | pendingDismiss.view.setTranslationX(0);
379 | lp = pendingDismiss.view.getLayoutParams();
380 | lp.height = originalHeight;
381 | pendingDismiss.view.setLayoutParams(lp);
382 | }
383 |
384 | // Send a cancel event
385 | long time = SystemClock.uptimeMillis();
386 | MotionEvent cancelEvent = MotionEvent.obtain(time, time,
387 | MotionEvent.ACTION_CANCEL, 0, 0, 0);
388 | mListView.dispatchTouchEvent(cancelEvent);
389 |
390 | mPendingDismisses.clear();
391 | }
392 | }
393 | });
394 |
395 | animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
396 | @Override
397 | public void onAnimationUpdate(ValueAnimator valueAnimator) {
398 | lp.height = (Integer) valueAnimator.getAnimatedValue();
399 | dismissView.setLayoutParams(lp);
400 | }
401 | });
402 |
403 | mPendingDismisses.add(new PendingDismissData(dismissPosition, dismissView));
404 | animator.start();
405 | }
406 | }
407 |
--------------------------------------------------------------------------------
/src/com/witheyjr/listviewanimator/StableArrayAdapter.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 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.witheyjr.listviewanimator;
18 |
19 | import java.util.ArrayList;
20 | import java.util.HashMap;
21 | import java.util.List;
22 | import android.content.Context;
23 | import android.view.LayoutInflater;
24 | import android.view.View;
25 | import android.view.ViewGroup;
26 | import android.widget.ArrayAdapter;
27 | import android.widget.TextView;
28 |
29 | public class StableArrayAdapter extends ArrayAdapter {
30 |
31 | HashMap mIdMap = new HashMap();
32 |
33 | List objects = new ArrayList();
34 | MainActivity mainActivity;
35 | Context context;
36 | int layoutResourceId;
37 |
38 | public StableArrayAdapter(Context context, int layoutResourceId, int textViewResourceId,
39 | List origObjects) {
40 | // super(context, textViewResourceId, objects);
41 | super(context, layoutResourceId, textViewResourceId, origObjects);
42 | this.objects = origObjects;
43 | for (int i = 0; i < objects.size(); ++i) {
44 | // objects.add(origObjects.get(i));
45 | mIdMap.put(objects.get(i), i);
46 | }
47 | this.context = context;
48 | this.layoutResourceId = layoutResourceId;
49 | }
50 |
51 | /*public void addItem(String toAdd, int pos) {
52 | objects.add(pos, toAdd);
53 | }*/
54 |
55 | public long getItemIdForAnimation(int position) {
56 | // String item = getItem(position);
57 | return mIdMap.get(objects.get(position));
58 | }
59 |
60 | @Override
61 | public boolean hasStableIds() {
62 | return true;
63 | }
64 |
65 | /* this is necessary for correct animations after new views/items have been added
66 | * to the ListView.
67 | */
68 | public void reIdMapObjects() {
69 | mIdMap.clear();
70 | for (int i = 0; i < objects.size(); i++) {
71 | mIdMap.put(objects.get(i), i);
72 | }
73 | }
74 |
75 | /*@Override
76 | public int getCount() {
77 | return objects.size();
78 | }
79 |
80 | @Override
81 | public String getItem(int position) {
82 | return objects.get(position);
83 | }*/
84 |
85 | @Override
86 | public long getItemId(int position) {
87 | // return position;
88 | return mIdMap.get(position);
89 | }
90 |
91 | /*@Override
92 | public int getPosition(String item) {
93 | return super.getPosition(item);
94 | }*/
95 |
96 | @Override
97 | public View getView(int position, View convertView, ViewGroup parent) {
98 |
99 | if (null == convertView)
100 | convertView = LayoutInflater.from(context).inflate(layoutResourceId, null);
101 | TextView title = (TextView) convertView.findViewById(R.id.title);
102 | title.setText(objects.get(position));
103 | // View view = super.getView(position, convertView, parent);
104 | /*if (view != convertView) {
105 | // Add touch listener to every new view to track swipe motion
106 | }*/
107 | return convertView;
108 | }
109 |
110 | }
111 |
--------------------------------------------------------------------------------
/src/com/witheyjr/listviewanimator/StableWrapperArrayAdapter.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2014 J Withey
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.witheyjr.listviewanimator;
18 |
19 | import java.lang.ref.WeakReference;
20 | import java.util.ArrayList;
21 | import java.util.HashMap;
22 | import java.util.List;
23 |
24 | import static com.nineoldandroids.view.ViewPropertyAnimator.animate;
25 | import static com.nineoldandroids.view.ViewHelper.setAlpha;
26 |
27 | import android.annotation.SuppressLint;
28 | import android.content.Context;
29 | import android.graphics.Bitmap;
30 | import android.graphics.BitmapFactory;
31 | import android.graphics.Color;
32 | import android.graphics.drawable.ColorDrawable;
33 | import android.graphics.drawable.Drawable;
34 | import android.os.AsyncTask;
35 | import android.os.Build;
36 | import android.support.v4.util.LruCache;
37 | import android.view.LayoutInflater;
38 | import android.view.View;
39 | import android.view.ViewGroup;
40 | import android.widget.ArrayAdapter;
41 | import android.widget.ImageView;
42 | import android.widget.TextView;
43 |
44 | /**
45 | * @author J Withey
46 | * StableWrapperArrayAdapter makes some tweaks to a bog-standard adapter to make it compatible with
47 | * the {@link ListViewAnimator}. Specifically, the {@link getItemIdForAnimation()} and related {@link mIdMap} are necessary
48 | * to keep track of the correct items for animating, and just prior to notifyDataSetChanged(), the
49 | * mIdMap should be updated with the method {@link reIdMapObjects}.
50 | *
51 | * Based on open source code by the DevBytes team:
52 | * http://graphics-geek.blogspot.co.uk/2013/06/devbytes-animating-listview-deletion.html
53 | */
54 | public class StableWrapperArrayAdapter extends ArrayAdapter {
55 |
56 | private HashMap mIdMap = new HashMap();
57 | private List mObjects = new ArrayList();
58 | private Context mContext;
59 | private int mLayoutResourceId;
60 | private boolean withImage = false;
61 | private final int mDuration = 100;
62 | private LruCache mMemoryCache;
63 |
64 | public StableWrapperArrayAdapter(Context context, int layoutResourceId,
65 | List origObjects) {
66 | super(context, layoutResourceId, origObjects);
67 | this.mObjects = origObjects;
68 | for (int i = 0; i < mObjects.size(); ++i) {
69 | mIdMap.put(mObjects.get(i), i);
70 | }
71 | this.mContext = context;
72 | this.mLayoutResourceId = layoutResourceId;
73 | withImage = true;
74 | /* Get max available VM memory, exceeding this amount will throw an OutOfMemory exception.
75 | * Stored in kilobytes as LruCache takes an int in its constructor.*/
76 | final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
77 | // Use 1/4 of the available memory for this memory cache.
78 | final int cacheSize = maxMemory / 4;
79 | mMemoryCache = new LruCache(cacheSize) {
80 | @SuppressLint("NewApi")
81 | @Override
82 | protected int sizeOf(String key, Bitmap bitmap) {
83 | // The cache size will be measured in kilobytes rather than number of items. Also, I love fragmentation.
84 | if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
85 | return (bitmap.getRowBytes() * bitmap.getHeight()) / 1024;
86 | } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
87 | return bitmap.getByteCount() / 1024;
88 | } else {
89 | return bitmap.getAllocationByteCount() / 1024;
90 | }
91 | }
92 | };
93 | }
94 |
95 | /** This is necessary for the correct items to be animated by the ListViewAnimator.
96 | * Cannot simply override getItemId() as this is used elsewhere.
97 | */
98 | public long getItemIdForAnimation(int position) {
99 | return mIdMap.get(mObjects.get(position));
100 | }
101 |
102 | @Override
103 | public boolean hasStableIds() {
104 | return true;
105 | }
106 |
107 | /** This is necessary for correct animations after new views/items have been added
108 | * to the ListView. To be called just prior to notifyDataSetChanged().
109 | */
110 | public void reIdMapObjects() {
111 | mIdMap.clear();
112 | for (int i = 0; i < mObjects.size(); i++) {
113 | mIdMap.put(mObjects.get(i), i);
114 | }
115 | }
116 |
117 | @Override
118 | public long getItemId(int position) {
119 | return position;
120 | }
121 |
122 | @Override
123 | public View getView(int position, View convertView, ViewGroup parent) {
124 | if (null == convertView)
125 | convertView = LayoutInflater.from(mContext).inflate(mLayoutResourceId, null);
126 | TextView title = (TextView) convertView.findViewById(R.id.title);
127 | title.setText(mObjects.get(position).getContents());
128 | if (withImage) {
129 | ImageView mImageView = (ImageView) convertView.findViewById(R.id.image);
130 | int resId = mObjects.get(position).getImageResource();
131 | final String imageKey = String.valueOf(resId);
132 | final Bitmap bitmap = getBitmapFromMemCache(imageKey);
133 | if (bitmap != null) {
134 | mImageView.setImageBitmap(bitmap);
135 | } else if (cancelPotentialLoad(mObjects.get(position).getImageResource(), mImageView)) {
136 | ImageLoaderTask task = new ImageLoaderTask(mImageView);
137 | LoadedDrawable loadedDrawable = new LoadedDrawable(task);
138 | mImageView.setImageDrawable(loadedDrawable);
139 | task.execute(mObjects.get(position).getImageResource());
140 | }
141 | }
142 | return convertView;
143 | }
144 |
145 | /* ########################################################################################
146 | * # The following are all methods to efficiently load and cache images, and not relevant #
147 | * # to the workings of the ListViewAnimator. #
148 | * ########################################################################################
149 | */
150 |
151 | private void addBitmapToMemoryCache(String key, Bitmap bitmap) {
152 | if (getBitmapFromMemCache(key) == null) {
153 | mMemoryCache.put(key, bitmap);
154 | }
155 | }
156 |
157 | private Bitmap getBitmapFromMemCache(String key) {
158 | return mMemoryCache.get(key);
159 | }
160 |
161 | private static boolean cancelPotentialLoad(int id, ImageView imageView) {
162 | ImageLoaderTask imageLoaderTask = getImageLoaderTask(imageView);
163 | if (imageLoaderTask != null) {
164 | int bitmapId = imageLoaderTask.id;
165 | if ((bitmapId == 0) || (bitmapId != id)) {
166 | imageLoaderTask.cancel(true);
167 | } else {
168 | // The same id is already being loaded.
169 | return false;
170 | }
171 | }
172 | return true;
173 | }
174 |
175 | private static ImageLoaderTask getImageLoaderTask(ImageView imageView) {
176 | if (imageView != null) {
177 | Drawable drawable = imageView.getDrawable();
178 | if (drawable instanceof LoadedDrawable) {
179 | LoadedDrawable downloadedDrawable = (LoadedDrawable)drawable;
180 | return downloadedDrawable.getImageLoaderTask();
181 | }
182 | }
183 | return null;
184 | }
185 |
186 | private class ImageLoaderTask extends AsyncTask {
187 | private int id;
188 | private final WeakReference imageViewReference;
189 | private ImageLoaderTask(ImageView image) {
190 | this.imageViewReference = new WeakReference(image);
191 | }
192 |
193 | @Override
194 | protected Bitmap doInBackground(Integer... params) {
195 | Bitmap bitmap = null;
196 | bitmap = BitmapFactory.decodeResource(mContext.getResources(), params[0]);
197 | addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);
198 | return bitmap;
199 | }
200 |
201 | @SuppressLint("NewApi")
202 | @SuppressWarnings("deprecation")
203 | @Override
204 | protected void onPostExecute(Bitmap result) {
205 | if (isCancelled()) {
206 | result = null;
207 | }
208 | if (imageViewReference != null) {
209 | ImageView imageView = imageViewReference.get();
210 | ImageLoaderTask imageLoaderTask = getImageLoaderTask(imageView);
211 | if (this == imageLoaderTask) {
212 | imageView.setImageBitmap(result);
213 | if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
214 | setAlpha(imageView, 0);
215 | animate(imageView)
216 | .alpha(1)
217 | .setDuration(mDuration);
218 | } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
219 | imageView.setAlpha(0);
220 | imageView.animate()
221 | .alpha(1)
222 | .setDuration(mDuration);
223 | } else {
224 | // Have to cast ImageView to View for animating for some reason
225 | View dummy = (View) imageView;
226 | dummy.setAlpha(0);
227 | dummy.animate()
228 | .alpha(1)
229 | .setDuration(mDuration);
230 | }
231 | }
232 | }
233 | }
234 | }
235 |
236 | private static class LoadedDrawable extends ColorDrawable {
237 | private final WeakReference imageLoaderTaskReference;
238 | public LoadedDrawable(ImageLoaderTask imageLoaderTask) {
239 | super(Color.WHITE);
240 | imageLoaderTaskReference = new WeakReference(imageLoaderTask);
241 | }
242 | public ImageLoaderTask getImageLoaderTask() {
243 | return imageLoaderTaskReference.get();
244 | }
245 | }
246 | }
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
--------------------------------------------------------------------------------
/src/com/witheyjr/listviewanimator/SwipeDismissListViewTouchListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * ******************************************************************************
3 | * Copyright (c) 2014 J Withey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | * *****************************************************************************
17 | */
18 |
19 | package com.witheyjr.listviewanimator;
20 |
21 | import static com.nineoldandroids.view.ViewHelper.setAlpha;
22 | import static com.nineoldandroids.view.ViewHelper.setRotation;
23 | import static com.nineoldandroids.view.ViewHelper.setScaleX;
24 | import static com.nineoldandroids.view.ViewHelper.setScaleY;
25 | import static com.nineoldandroids.view.ViewHelper.setTranslationX;
26 | import static com.nineoldandroids.view.ViewPropertyAnimator.animate;
27 |
28 | import android.animation.Animator;
29 | import android.animation.Animator.AnimatorListener;
30 | import android.annotation.SuppressLint;
31 | import android.graphics.Rect;
32 | import android.os.Build;
33 | import android.view.MotionEvent;
34 | import android.view.VelocityTracker;
35 | import android.view.View;
36 | import android.view.ViewConfiguration;
37 | import android.view.animation.LinearInterpolator;
38 | import android.view.animation.OvershootInterpolator;
39 | import android.widget.AbsListView;
40 | import android.widget.ListView;
41 | import com.nineoldandroids.animation.AnimatorListenerAdapter;
42 |
43 | /**
44 | * This is based on code by Roman Nurik.
45 | * See this link for original code https://github.com/romannurik/Android-SwipeToDismiss
46 | *
47 | *
48 | * A {@link View.OnTouchListener} that makes the list items in a {@link ListView}
49 | * dismissable. {@link ListView} is given special treatment because by default it handles touches
50 | * for its list items... i.e. it's in charge of drawing the pressed state (the list selector),
51 | * handling list item clicks, etc.
52 | *
53 | * After creating the listener, the caller should also call
54 | * {@link ListView#setOnScrollListener(AbsListView.OnScrollListener)}, passing
55 | * in the scroll listener returned by {@link #makeScrollListener()}. If a scroll listener is
56 | * already assigned, the caller should still pass scroll changes through to this listener. This will
57 | * ensure that this {@link SwipeDismissListViewTouchListener} is paused during list view
58 | * scrolling.
59 | *
60 | * This class Requires API level 8 or later
61 | *
62 | */
63 | public class SwipeDismissListViewTouchListener implements View.OnTouchListener {
64 | // Cached ViewConfiguration and system-wide constant values
65 | private int mSlop;
66 | private int mMinFlingVelocity;
67 | private int mMaxFlingVelocity;
68 | private long mAnimationTime;
69 |
70 | // Fixed properties
71 | private ListView mListView;
72 | private DismissCallbacks mCallbacks;
73 | private int mViewWidth = 1; // 1 and not 0 to prevent dividing by zero
74 | private boolean belowApi12 = false;
75 | private boolean belowApi16 = false;
76 |
77 | // Transient properties
78 | private float mDownX;
79 | private float mDownY;
80 | private boolean mSwiping;
81 | private int mSwipingSlop;
82 | private VelocityTracker mVelocityTracker;
83 | private int mDownPosition;
84 | private View mDownView;
85 | private boolean mPaused;
86 | private int firstSlop;
87 | private boolean firstSlopAlreadySet = false;
88 | private int animationCount = 0;
89 | private boolean currentlyScrolling = false;
90 |
91 | /**
92 | * The callback interface used by {@link SwipeDismissListViewTouchListener} to inform its client
93 | * about a successful dismissal of one or more list item positions.
94 | */
95 | public interface DismissCallbacks {
96 | /**
97 | * Called to determine whether the given position can be dismissed.
98 | */
99 | boolean canDismiss(int position);
100 |
101 | /**
102 | * Called when the user has indicated they she would like to dismiss an item
103 | *
104 | * @param listView The originating {@link ListView}
105 | * @param viewToDismiss The view to dismiss
106 | * @param adapterPos The position within the adapter to dismiss
107 | */
108 | void onDismiss(View viewToDismiss, int adapterPos);
109 |
110 | /**
111 | * For disabling the adding of new items while the swiping/scroll animations are running, as
112 | * this can cause visual glitches if you were to quickly swipe and add new view without this
113 | * functionality. Disable/enable your 'New item' button/functionality in your activity here.
114 | */
115 | void currentlyAnimatingSwipeOrScroll(boolean isAnimating);
116 | }
117 |
118 | /**
119 | * Constructs a new swipe-to-dismiss touch listener for the given list view.
120 | *
121 | * @param listView The list view whose items should be dismissable.
122 | * @param callbacks The callbacks to trigger at various points during the add/remove animation process
123 | */
124 | public SwipeDismissListViewTouchListener(ListView listView, DismissCallbacks callbacks) {
125 | ViewConfiguration vc = ViewConfiguration.get(listView.getContext());
126 | mSlop = vc.getScaledTouchSlop();
127 | mMinFlingVelocity = vc.getScaledMinimumFlingVelocity() * 16;
128 | mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity();
129 | mAnimationTime = listView.getContext().getResources().getInteger(
130 | android.R.integer.config_mediumAnimTime);
131 | mListView = listView;
132 | mCallbacks = callbacks;
133 | if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
134 | belowApi12 = true;
135 | } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
136 | belowApi16 = true;
137 | }
138 | }
139 |
140 | /**
141 | * Enables or disables (pauses or resumes) watching for swipe-to-dismiss gestures.
142 | *
143 | * @param enabled Whether or not to watch for gestures.
144 | */
145 | public void setEnabled(boolean enabled) {
146 | mPaused = !enabled;
147 | }
148 |
149 | /**
150 | * Returns an {@link AbsListView.OnScrollListener} to be added to the {@link
151 | * ListView} using {@link ListView#setOnScrollListener(AbsListView.OnScrollListener)}.
152 | * If a scroll listener is already assigned, the caller should still pass scroll changes through
153 | * to this listener. This will ensure that this {@link SwipeDismissListViewTouchListener} is
154 | * paused during list view scrolling.
155 | *
156 | * @see SwipeDismissListViewTouchListener
157 | */
158 | public AbsListView.OnScrollListener makeScrollListener() {
159 | return new AbsListView.OnScrollListener() {
160 | @Override
161 | public void onScrollStateChanged(AbsListView absListView, int scrollState) {
162 | setEnabled(scrollState != AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
163 | if (scrollState == AbsListView.OnScrollListener.SCROLL_STATE_FLING) {
164 | mCallbacks.currentlyAnimatingSwipeOrScroll(true);
165 | currentlyScrolling = true;
166 | } else {
167 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
168 | currentlyScrolling = false;
169 | }
170 | }
171 | @Override
172 | public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totalItemCount) { }
173 | };
174 | }
175 |
176 | @SuppressLint("NewApi")
177 | @Override
178 | public boolean onTouch(View view, MotionEvent motionEvent) {
179 | if (mViewWidth < 2) {
180 | mViewWidth = mListView.getWidth();
181 | }
182 | switch (motionEvent.getActionMasked()) {
183 | case MotionEvent.ACTION_DOWN: {
184 | if (mPaused || animationCount > 0) {
185 | return false;
186 | }
187 | // Find the child view that was touched (perform a hit test)
188 | Rect rect = new Rect();
189 | int childCount = mListView.getChildCount();
190 | int[] listViewCoords = new int[2];
191 | mListView.getLocationOnScreen(listViewCoords);
192 | int x = (int) motionEvent.getRawX() - listViewCoords[0];
193 | int y = (int) motionEvent.getRawY() - listViewCoords[1];
194 | View child = null;
195 | for (int i = 0; i < childCount; i++) {
196 | child = mListView.getChildAt(i);
197 | child.getHitRect(rect);
198 | if (rect.contains(x, y)) {
199 | mDownView = child;
200 | break;
201 | }
202 | }
203 | if (mDownView != null) {
204 | mDownX = motionEvent.getRawX();
205 | mDownY = motionEvent.getRawY();
206 | mDownPosition = mListView.getPositionForView(mDownView);
207 | if (mCallbacks.canDismiss(mDownPosition)) {
208 | mVelocityTracker = VelocityTracker.obtain();
209 | mVelocityTracker.addMovement(motionEvent);
210 | } else {
211 | mDownView = null;
212 | }
213 | }
214 | return false;
215 | }
216 |
217 | case MotionEvent.ACTION_UP: {
218 | if (mVelocityTracker == null) {
219 | break;
220 | }
221 | float deltaX = motionEvent.getRawX() - mDownX;
222 | mVelocityTracker.addMovement(motionEvent);
223 | mVelocityTracker.computeCurrentVelocity(1000);
224 | float velocityX = mVelocityTracker.getXVelocity();
225 | float absVelocityX = Math.abs(velocityX);
226 | float absVelocityY = Math.abs(mVelocityTracker.getYVelocity());
227 | boolean dismiss = false;
228 | boolean dismissRight = false;
229 | firstSlopAlreadySet = false;
230 | if (Math.abs(deltaX) > mViewWidth / 2 && mSwiping) {
231 | dismiss = true;
232 | dismissRight = deltaX > 0;
233 | } else if (mMinFlingVelocity <= absVelocityX && absVelocityX <= mMaxFlingVelocity
234 | && absVelocityY < absVelocityX && mSwiping) {
235 | dismiss = (velocityX < 0) == (deltaX < 0);
236 | dismissRight = mVelocityTracker.getXVelocity() > 0;
237 | }
238 | mCallbacks.currentlyAnimatingSwipeOrScroll(true);
239 | if (dismiss && mDownPosition != ListView.INVALID_POSITION) {
240 | ++animationCount;
241 | dismiss(mDownView, mDownPosition, dismissRight, absVelocityX, deltaX);
242 | } else {
243 | ++animationCount;
244 | if (belowApi12) {
245 | animate(mDownView)
246 | .translationX(0)
247 | .alpha(1)
248 | .scaleX(1)
249 | .scaleY(1)
250 | .setInterpolator(new OvershootInterpolator(Math.min(deltaX >= 0? deltaX / 80f : -deltaX / 80f, 3.5f)))
251 | .rotation(0)
252 | .setDuration((long) ((mAnimationTime / 1.4f) + ((Math.abs(deltaX) / mViewWidth))))
253 | .setListener(new AnimatorListenerAdapter() {
254 | @Override
255 | public void onAnimationEnd(com.nineoldandroids.animation.Animator animation) {
256 | --animationCount;
257 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
258 | }
259 | });
260 | } else if (belowApi16) {
261 | mDownView.animate()
262 | .translationX(0)
263 | .alpha(1)
264 | .scaleX(1)
265 | .scaleY(1)
266 | .setInterpolator(new OvershootInterpolator(Math.min(deltaX >= 0? deltaX / 80f : -deltaX / 80f, 3.5f)))
267 | .rotation(0)
268 | .setDuration( (long) ((mAnimationTime / 1.4f) + ((Math.abs(deltaX) / mViewWidth))))
269 | .setListener(new AnimatorListener() {
270 | @Override public void onAnimationStart(Animator animation) { }
271 | @Override public void onAnimationRepeat(Animator animation) { }
272 | @Override
273 | public void onAnimationEnd(Animator animation) {
274 | --animationCount;
275 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
276 | }
277 | @Override public void onAnimationCancel(Animator animation) { }
278 | });
279 | } else {
280 | mDownView.animate()
281 | .translationX(0)
282 | .alpha(1)
283 | .scaleX(1)
284 | .scaleY(1)
285 | .setInterpolator(new OvershootInterpolator(Math.min(deltaX >= 0? deltaX / 80f : -deltaX / 80f, 3.5f)))
286 | .rotation(0)
287 | .setDuration( (long) ((mAnimationTime / 1.4f) + ((Math.abs(deltaX) / mViewWidth))))
288 | .withEndAction(new Runnable() {
289 | @Override
290 | public void run() {
291 | --animationCount;
292 | if (!currentlyScrolling)
293 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
294 | }
295 | });
296 | }
297 | }
298 | mVelocityTracker.recycle();
299 | mVelocityTracker = null;
300 | mDownX = 0;
301 | mDownY = 0;
302 | mDownView = null;
303 | mDownPosition = ListView.INVALID_POSITION;
304 | mSwiping = false;
305 | break;
306 | }
307 |
308 | case MotionEvent.ACTION_CANCEL: {
309 | if (mVelocityTracker == null) {
310 | break;
311 | }
312 | if (mSwiping) {
313 | if (mDownView != null) {
314 | // cancel
315 | if (belowApi12) {
316 | animate(mDownView)
317 | .translationX(0)
318 | .alpha(1)
319 | .scaleX(1)
320 | .scaleY(1)
321 | .rotation(0)
322 | .setDuration(mAnimationTime)
323 | .setListener(null);
324 | } else {
325 | mDownView.animate()
326 | .translationX(0)
327 | .alpha(1)
328 | .scaleX(1)
329 | .scaleY(1)
330 | .rotation(0)
331 | .setDuration(mAnimationTime)
332 | .setListener(null);
333 | }
334 | }
335 | }
336 | mVelocityTracker.recycle();
337 | mVelocityTracker = null;
338 | mDownX = 0;
339 | mDownY = 0;
340 | mDownView = null;
341 | mDownPosition = ListView.INVALID_POSITION;
342 | mSwiping = false;
343 | firstSlopAlreadySet = false;
344 | break;
345 | }
346 |
347 | case MotionEvent.ACTION_MOVE: {
348 | if (mVelocityTracker == null) {
349 | break;
350 | } else if (mPaused) {
351 | break;
352 | }
353 | mVelocityTracker.addMovement(motionEvent);
354 | float deltaX = motionEvent.getRawX() - mDownX;
355 | float deltaY = motionEvent.getRawY() - mDownY;
356 | if (Math.abs(deltaX) > mSlop && Math.abs(deltaY) < Math.abs(deltaX) / 2) {
357 | mSwiping = true;
358 | mSwipingSlop = (deltaX > 0 ? mSlop : -mSlop);
359 | if (!firstSlopAlreadySet) {
360 | firstSlop = mSwipingSlop;
361 | firstSlopAlreadySet = true;
362 | }
363 | mListView.requestDisallowInterceptTouchEvent(true);
364 | // Cancel ListView's touch (un-highlighting the item)
365 | MotionEvent cancelEvent = MotionEvent.obtain(motionEvent);
366 | cancelEvent.setAction(MotionEvent.ACTION_CANCEL |
367 | (motionEvent.getActionIndex()
368 | << MotionEvent.ACTION_POINTER_INDEX_SHIFT));
369 | mListView.onTouchEvent(cancelEvent);
370 | cancelEvent.recycle();
371 | }
372 | if (mSwiping) {
373 | if (belowApi12) {
374 | setTranslationX(mDownView, deltaX - firstSlop);
375 | setAlpha(mDownView, Math.max(0f, Math.min(1f,
376 | 1f - 1.2f * Math.abs(deltaX - firstSlop) / mViewWidth)));
377 | setScaleX(mDownView, 1 - 1.05f * (Math.abs(deltaX - firstSlop) / mViewWidth / 1.5f));
378 | setScaleY(mDownView, 1 - 1.05f * (Math.abs(deltaX - firstSlop) / mViewWidth / 1.5f));
379 | setRotation(mDownView, (float) Math.pow((deltaX - firstSlop) / (mViewWidth / 4), 3));
380 | } else {
381 | mDownView.setTranslationX(deltaX - firstSlop);
382 | mDownView.setAlpha(Math.max(0f, Math.min(1f,
383 | 1f - 1.2f * Math.abs(deltaX - firstSlop) / mViewWidth)));
384 | mDownView.setScaleX(1 - 1.05f * (Math.abs(deltaX - firstSlop) / mViewWidth / 1.5f));
385 | mDownView.setScaleY(1 - 1.05f * (Math.abs(deltaX - firstSlop) / mViewWidth / 1.5f));
386 | mDownView.setRotation((float) Math.pow((deltaX - firstSlop) / (mViewWidth / 4), 3));
387 | }
388 | return true;
389 | }
390 | break;
391 | }
392 | }
393 | return false;
394 | }
395 |
396 | @SuppressLint("NewApi")
397 | private void dismiss(final View view, final int position, boolean dismissRight, float absVelocityX, float deltaX) {
398 | if (view == null) {
399 | --animationCount;
400 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
401 | mCallbacks.onDismiss(view, position);
402 | return;
403 | }
404 | if (belowApi12) {
405 | animate(view)
406 | .translationX(dismissRight ? mViewWidth : -mViewWidth)
407 | .alpha(0)
408 | .scaleX(0.25f)
409 | .scaleY(0.25f)
410 | .rotation(dismissRight ? 20 : -20)
411 | .setInterpolator(new LinearInterpolator())
412 | .setDuration((long) (mAnimationTime / 1.5))
413 | .setListener(new AnimatorListenerAdapter() {
414 | @Override
415 | public void onAnimationEnd(com.nineoldandroids.animation.Animator animator) {
416 | // Restore animated values
417 | setAlpha(view, 1);
418 | setTranslationX(view, 0);
419 | setRotation(view, 0);
420 | setScaleX(view, 1);
421 | setScaleY(view, 1);
422 | --animationCount;
423 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
424 | mCallbacks.onDismiss(view, position);
425 | }
426 | });
427 | } else if (belowApi16) {
428 | view.animate()
429 | .translationX(dismissRight ? mViewWidth : -mViewWidth)
430 | .alpha(0)
431 | .scaleX(0.25f)
432 | .scaleY(0.25f)
433 | .rotation(dismissRight ? 20 : -20)
434 | .setInterpolator(new LinearInterpolator())
435 | .setDuration((long) (mAnimationTime / 1.5))
436 | .setListener(new AnimatorListener() {
437 | @Override public void onAnimationStart(android.animation.Animator animation) { }
438 | @Override
439 | public void onAnimationEnd(android.animation.Animator animation) {
440 | view.setAlpha(1);
441 | view.setTranslationX(0);
442 | view.setRotation(0);
443 | view.setScaleX(1);
444 | view.setScaleY(1);
445 | --animationCount;
446 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
447 | mCallbacks.onDismiss(view, position);
448 | }
449 | @Override public void onAnimationCancel(android.animation.Animator animation) { }
450 | @Override public void onAnimationRepeat(android.animation.Animator animation) { }
451 | });
452 | } else {
453 | view.animate()
454 | .translationX(dismissRight ? mViewWidth : -mViewWidth)
455 | .alpha(0)
456 | .scaleX(0.25f)
457 | .scaleY(0.25f)
458 | .rotation(dismissRight ? 20 : -20)
459 | .setInterpolator(new LinearInterpolator())
460 | .setDuration((long) (mAnimationTime / 1.5))
461 | .withEndAction(new Runnable() {
462 | @Override
463 | public void run() {
464 | view.setAlpha(1);
465 | view.setTranslationX(0);
466 | view.setRotation(0);
467 | view.setScaleX(1);
468 | view.setScaleY(1);
469 | --animationCount;
470 | mCallbacks.currentlyAnimatingSwipeOrScroll(false);
471 | mCallbacks.onDismiss(view, position);
472 | }
473 | });
474 | }
475 | }
476 | }
477 |
478 |
479 |
480 |
481 |
482 |
483 |
484 |
485 |
486 |
487 |
488 |
489 |
490 |
491 |
492 |
493 |
494 |
495 |
--------------------------------------------------------------------------------
19 |