524 lines
19 KiB
Java
524 lines
19 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2008 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 android.widget;
|
||
|
|
|
||
|
|
import android.content.Context;
|
||
|
|
import android.content.res.ColorStateList;
|
||
|
|
import android.content.res.Resources;
|
||
|
|
import android.content.res.TypedArray;
|
||
|
|
import android.graphics.Canvas;
|
||
|
|
import android.graphics.Paint;
|
||
|
|
import android.graphics.RectF;
|
||
|
|
import android.graphics.drawable.Drawable;
|
||
|
|
import android.os.Handler;
|
||
|
|
import android.os.SystemClock;
|
||
|
|
import android.util.TypedValue;
|
||
|
|
import android.view.MotionEvent;
|
||
|
|
import android.widget.AbsListView.OnScrollListener;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper class for AbsListView to draw and control the Fast Scroll thumb
|
||
|
|
*/
|
||
|
|
class FastScroller {
|
||
|
|
|
||
|
|
// Minimum number of pages to justify showing a fast scroll thumb
|
||
|
|
private static int MIN_PAGES = 4;
|
||
|
|
// Scroll thumb not showing
|
||
|
|
private static final int STATE_NONE = 0;
|
||
|
|
// Not implemented yet - fade-in transition
|
||
|
|
private static final int STATE_ENTER = 1;
|
||
|
|
// Scroll thumb visible and moving along with the scrollbar
|
||
|
|
private static final int STATE_VISIBLE = 2;
|
||
|
|
// Scroll thumb being dragged by user
|
||
|
|
private static final int STATE_DRAGGING = 3;
|
||
|
|
// Scroll thumb fading out due to inactivity timeout
|
||
|
|
private static final int STATE_EXIT = 4;
|
||
|
|
|
||
|
|
private Drawable mThumbDrawable;
|
||
|
|
private Drawable mOverlayDrawable;
|
||
|
|
|
||
|
|
private int mThumbH;
|
||
|
|
private int mThumbW;
|
||
|
|
private int mThumbY;
|
||
|
|
|
||
|
|
private RectF mOverlayPos;
|
||
|
|
private int mOverlaySize;
|
||
|
|
|
||
|
|
private AbsListView mList;
|
||
|
|
private boolean mScrollCompleted;
|
||
|
|
private int mVisibleItem;
|
||
|
|
private Paint mPaint;
|
||
|
|
private int mListOffset;
|
||
|
|
private int mItemCount = -1;
|
||
|
|
private boolean mLongList;
|
||
|
|
|
||
|
|
private Object [] mSections;
|
||
|
|
private String mSectionText;
|
||
|
|
private boolean mDrawOverlay;
|
||
|
|
private ScrollFade mScrollFade;
|
||
|
|
|
||
|
|
private int mState;
|
||
|
|
|
||
|
|
private Handler mHandler = new Handler();
|
||
|
|
|
||
|
|
private BaseAdapter mListAdapter;
|
||
|
|
private SectionIndexer mSectionIndexer;
|
||
|
|
|
||
|
|
private boolean mChangedBounds;
|
||
|
|
|
||
|
|
public FastScroller(Context context, AbsListView listView) {
|
||
|
|
mList = listView;
|
||
|
|
init(context);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void setState(int state) {
|
||
|
|
switch (state) {
|
||
|
|
case STATE_NONE:
|
||
|
|
mHandler.removeCallbacks(mScrollFade);
|
||
|
|
mList.invalidate();
|
||
|
|
break;
|
||
|
|
case STATE_VISIBLE:
|
||
|
|
if (mState != STATE_VISIBLE) { // Optimization
|
||
|
|
resetThumbPos();
|
||
|
|
}
|
||
|
|
// Fall through
|
||
|
|
case STATE_DRAGGING:
|
||
|
|
mHandler.removeCallbacks(mScrollFade);
|
||
|
|
break;
|
||
|
|
case STATE_EXIT:
|
||
|
|
int viewWidth = mList.getWidth();
|
||
|
|
mList.invalidate(viewWidth - mThumbW, mThumbY, viewWidth, mThumbY + mThumbH);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
mState = state;
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getState() {
|
||
|
|
return mState;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void resetThumbPos() {
|
||
|
|
final int viewWidth = mList.getWidth();
|
||
|
|
// Bounds are always top right. Y coordinate get's translated during draw
|
||
|
|
mThumbDrawable.setBounds(viewWidth - mThumbW, 0, viewWidth, mThumbH);
|
||
|
|
mThumbDrawable.setAlpha(ScrollFade.ALPHA_MAX);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void useThumbDrawable(Context context, Drawable drawable) {
|
||
|
|
mThumbDrawable = drawable;
|
||
|
|
mThumbW = context.getResources().getDimensionPixelSize(
|
||
|
|
com.android.internal.R.dimen.fastscroll_thumb_width);
|
||
|
|
mThumbH = context.getResources().getDimensionPixelSize(
|
||
|
|
com.android.internal.R.dimen.fastscroll_thumb_height);
|
||
|
|
mChangedBounds = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void init(Context context) {
|
||
|
|
// Get both the scrollbar states drawables
|
||
|
|
final Resources res = context.getResources();
|
||
|
|
useThumbDrawable(context, res.getDrawable(
|
||
|
|
com.android.internal.R.drawable.scrollbar_handle_accelerated_anim2));
|
||
|
|
|
||
|
|
mOverlayDrawable = res.getDrawable(
|
||
|
|
com.android.internal.R.drawable.menu_submenu_background);
|
||
|
|
|
||
|
|
mScrollCompleted = true;
|
||
|
|
|
||
|
|
getSectionsFromIndexer();
|
||
|
|
|
||
|
|
mOverlaySize = context.getResources().getDimensionPixelSize(
|
||
|
|
com.android.internal.R.dimen.fastscroll_overlay_size);
|
||
|
|
mOverlayPos = new RectF();
|
||
|
|
mScrollFade = new ScrollFade();
|
||
|
|
mPaint = new Paint();
|
||
|
|
mPaint.setAntiAlias(true);
|
||
|
|
mPaint.setTextAlign(Paint.Align.CENTER);
|
||
|
|
mPaint.setTextSize(mOverlaySize / 2);
|
||
|
|
TypedArray ta = context.getTheme().obtainStyledAttributes(new int[] {
|
||
|
|
android.R.attr.textColorPrimary });
|
||
|
|
ColorStateList textColor = ta.getColorStateList(ta.getIndex(0));
|
||
|
|
int textColorNormal = textColor.getDefaultColor();
|
||
|
|
mPaint.setColor(textColorNormal);
|
||
|
|
mPaint.setStyle(Paint.Style.FILL_AND_STROKE);
|
||
|
|
|
||
|
|
mState = STATE_NONE;
|
||
|
|
}
|
||
|
|
|
||
|
|
void stop() {
|
||
|
|
setState(STATE_NONE);
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean isVisible() {
|
||
|
|
return !(mState == STATE_NONE);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void draw(Canvas canvas) {
|
||
|
|
|
||
|
|
if (mState == STATE_NONE) {
|
||
|
|
// No need to draw anything
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
final int y = mThumbY;
|
||
|
|
final int viewWidth = mList.getWidth();
|
||
|
|
final FastScroller.ScrollFade scrollFade = mScrollFade;
|
||
|
|
|
||
|
|
int alpha = -1;
|
||
|
|
if (mState == STATE_EXIT) {
|
||
|
|
alpha = scrollFade.getAlpha();
|
||
|
|
if (alpha < ScrollFade.ALPHA_MAX / 2) {
|
||
|
|
mThumbDrawable.setAlpha(alpha * 2);
|
||
|
|
}
|
||
|
|
int left = viewWidth - (mThumbW * alpha) / ScrollFade.ALPHA_MAX;
|
||
|
|
mThumbDrawable.setBounds(left, 0, viewWidth, mThumbH);
|
||
|
|
mChangedBounds = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
canvas.translate(0, y);
|
||
|
|
mThumbDrawable.draw(canvas);
|
||
|
|
canvas.translate(0, -y);
|
||
|
|
|
||
|
|
// If user is dragging the scroll bar, draw the alphabet overlay
|
||
|
|
if (mState == STATE_DRAGGING && mDrawOverlay) {
|
||
|
|
mOverlayDrawable.draw(canvas);
|
||
|
|
final Paint paint = mPaint;
|
||
|
|
float descent = paint.descent();
|
||
|
|
final RectF rectF = mOverlayPos;
|
||
|
|
canvas.drawText(mSectionText, (int) (rectF.left + rectF.right) / 2,
|
||
|
|
(int) (rectF.bottom + rectF.top) / 2 + mOverlaySize / 4 - descent, paint);
|
||
|
|
} else if (mState == STATE_EXIT) {
|
||
|
|
if (alpha == 0) { // Done with exit
|
||
|
|
setState(STATE_NONE);
|
||
|
|
} else {
|
||
|
|
mList.invalidate(viewWidth - mThumbW, y, viewWidth, y + mThumbH);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void onSizeChanged(int w, int h, int oldw, int oldh) {
|
||
|
|
if (mThumbDrawable != null) {
|
||
|
|
mThumbDrawable.setBounds(w - mThumbW, 0, w, mThumbH);
|
||
|
|
}
|
||
|
|
final RectF pos = mOverlayPos;
|
||
|
|
pos.left = (w - mOverlaySize) / 2;
|
||
|
|
pos.right = pos.left + mOverlaySize;
|
||
|
|
pos.top = h / 10; // 10% from top
|
||
|
|
pos.bottom = pos.top + mOverlaySize;
|
||
|
|
if (mOverlayDrawable != null) {
|
||
|
|
mOverlayDrawable.setBounds((int) pos.left, (int) pos.top,
|
||
|
|
(int) pos.right, (int) pos.bottom);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
|
||
|
|
int totalItemCount) {
|
||
|
|
// Are there enough pages to require fast scroll? Recompute only if total count changes
|
||
|
|
if (mItemCount != totalItemCount && visibleItemCount > 0) {
|
||
|
|
mItemCount = totalItemCount;
|
||
|
|
mLongList = mItemCount / visibleItemCount >= MIN_PAGES;
|
||
|
|
}
|
||
|
|
if (!mLongList) {
|
||
|
|
if (mState != STATE_NONE) {
|
||
|
|
setState(STATE_NONE);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (totalItemCount - visibleItemCount > 0 && mState != STATE_DRAGGING ) {
|
||
|
|
mThumbY = ((mList.getHeight() - mThumbH) * firstVisibleItem)
|
||
|
|
/ (totalItemCount - visibleItemCount);
|
||
|
|
if (mChangedBounds) {
|
||
|
|
resetThumbPos();
|
||
|
|
mChangedBounds = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mScrollCompleted = true;
|
||
|
|
if (firstVisibleItem == mVisibleItem) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
mVisibleItem = firstVisibleItem;
|
||
|
|
if (mState != STATE_DRAGGING) {
|
||
|
|
setState(STATE_VISIBLE);
|
||
|
|
mHandler.postDelayed(mScrollFade, 1500);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SectionIndexer getSectionIndexer() {
|
||
|
|
return mSectionIndexer;
|
||
|
|
}
|
||
|
|
|
||
|
|
Object[] getSections() {
|
||
|
|
if (mListAdapter == null && mList != null) {
|
||
|
|
getSectionsFromIndexer();
|
||
|
|
}
|
||
|
|
return mSections;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void getSectionsFromIndexer() {
|
||
|
|
Adapter adapter = mList.getAdapter();
|
||
|
|
mSectionIndexer = null;
|
||
|
|
if (adapter instanceof HeaderViewListAdapter) {
|
||
|
|
mListOffset = ((HeaderViewListAdapter)adapter).getHeadersCount();
|
||
|
|
adapter = ((HeaderViewListAdapter)adapter).getWrappedAdapter();
|
||
|
|
}
|
||
|
|
if (adapter instanceof ExpandableListConnector) {
|
||
|
|
ExpandableListAdapter expAdapter = ((ExpandableListConnector)adapter).getAdapter();
|
||
|
|
if (expAdapter instanceof SectionIndexer) {
|
||
|
|
mSectionIndexer = (SectionIndexer) expAdapter;
|
||
|
|
mListAdapter = (BaseAdapter) adapter;
|
||
|
|
mSections = mSectionIndexer.getSections();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (adapter instanceof SectionIndexer) {
|
||
|
|
mListAdapter = (BaseAdapter) adapter;
|
||
|
|
mSectionIndexer = (SectionIndexer) adapter;
|
||
|
|
mSections = mSectionIndexer.getSections();
|
||
|
|
|
||
|
|
} else {
|
||
|
|
mListAdapter = (BaseAdapter) adapter;
|
||
|
|
mSections = new String[] { " " };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void scrollTo(float position) {
|
||
|
|
int count = mList.getCount();
|
||
|
|
mScrollCompleted = false;
|
||
|
|
float fThreshold = (1.0f / count) / 8;
|
||
|
|
final Object[] sections = mSections;
|
||
|
|
int sectionIndex;
|
||
|
|
if (sections != null && sections.length > 1) {
|
||
|
|
final int nSections = sections.length;
|
||
|
|
int section = (int) (position * nSections);
|
||
|
|
if (section >= nSections) {
|
||
|
|
section = nSections - 1;
|
||
|
|
}
|
||
|
|
int exactSection = section;
|
||
|
|
sectionIndex = section;
|
||
|
|
int index = mSectionIndexer.getPositionForSection(section);
|
||
|
|
// Given the expected section and index, the following code will
|
||
|
|
// try to account for missing sections (no names starting with..)
|
||
|
|
// It will compute the scroll space of surrounding empty sections
|
||
|
|
// and interpolate the currently visible letter's range across the
|
||
|
|
// available space, so that there is always some list movement while
|
||
|
|
// the user moves the thumb.
|
||
|
|
int nextIndex = count;
|
||
|
|
int prevIndex = index;
|
||
|
|
int prevSection = section;
|
||
|
|
int nextSection = section + 1;
|
||
|
|
// Assume the next section is unique
|
||
|
|
if (section < nSections - 1) {
|
||
|
|
nextIndex = mSectionIndexer.getPositionForSection(section + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find the previous index if we're slicing the previous section
|
||
|
|
if (nextIndex == index) {
|
||
|
|
// Non-existent letter
|
||
|
|
while (section > 0) {
|
||
|
|
section--;
|
||
|
|
prevIndex = mSectionIndexer.getPositionForSection(section);
|
||
|
|
if (prevIndex != index) {
|
||
|
|
prevSection = section;
|
||
|
|
sectionIndex = section;
|
||
|
|
break;
|
||
|
|
} else if (section == 0) {
|
||
|
|
// When section reaches 0 here, sectionIndex must follow it.
|
||
|
|
// Assuming mSectionIndexer.getPositionForSection(0) == 0.
|
||
|
|
sectionIndex = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Find the next index, in case the assumed next index is not
|
||
|
|
// unique. For instance, if there is no P, then request for P's
|
||
|
|
// position actually returns Q's. So we need to look ahead to make
|
||
|
|
// sure that there is really a Q at Q's position. If not, move
|
||
|
|
// further down...
|
||
|
|
int nextNextSection = nextSection + 1;
|
||
|
|
while (nextNextSection < nSections &&
|
||
|
|
mSectionIndexer.getPositionForSection(nextNextSection) == nextIndex) {
|
||
|
|
nextNextSection++;
|
||
|
|
nextSection++;
|
||
|
|
}
|
||
|
|
// Compute the beginning and ending scroll range percentage of the
|
||
|
|
// currently visible letter. This could be equal to or greater than
|
||
|
|
// (1 / nSections).
|
||
|
|
float fPrev = (float) prevSection / nSections;
|
||
|
|
float fNext = (float) nextSection / nSections;
|
||
|
|
if (prevSection == exactSection && position - fPrev < fThreshold) {
|
||
|
|
index = prevIndex;
|
||
|
|
} else {
|
||
|
|
index = prevIndex + (int) ((nextIndex - prevIndex) * (position - fPrev)
|
||
|
|
/ (fNext - fPrev));
|
||
|
|
}
|
||
|
|
// Don't overflow
|
||
|
|
if (index > count - 1) index = count - 1;
|
||
|
|
|
||
|
|
if (mList instanceof ExpandableListView) {
|
||
|
|
ExpandableListView expList = (ExpandableListView) mList;
|
||
|
|
expList.setSelectionFromTop(expList.getFlatListPosition(
|
||
|
|
ExpandableListView.getPackedPositionForGroup(index + mListOffset)), 0);
|
||
|
|
} else if (mList instanceof ListView) {
|
||
|
|
((ListView)mList).setSelectionFromTop(index + mListOffset, 0);
|
||
|
|
} else {
|
||
|
|
mList.setSelection(index + mListOffset);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
int index = (int) (position * count);
|
||
|
|
if (mList instanceof ExpandableListView) {
|
||
|
|
ExpandableListView expList = (ExpandableListView) mList;
|
||
|
|
expList.setSelectionFromTop(expList.getFlatListPosition(
|
||
|
|
ExpandableListView.getPackedPositionForGroup(index + mListOffset)), 0);
|
||
|
|
} else if (mList instanceof ListView) {
|
||
|
|
((ListView)mList).setSelectionFromTop(index + mListOffset, 0);
|
||
|
|
} else {
|
||
|
|
mList.setSelection(index + mListOffset);
|
||
|
|
}
|
||
|
|
sectionIndex = -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sectionIndex >= 0) {
|
||
|
|
String text = mSectionText = sections[sectionIndex].toString();
|
||
|
|
mDrawOverlay = (text.length() != 1 || text.charAt(0) != ' ') &&
|
||
|
|
sectionIndex < sections.length;
|
||
|
|
} else {
|
||
|
|
mDrawOverlay = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void cancelFling() {
|
||
|
|
// Cancel the list fling
|
||
|
|
MotionEvent cancelFling = MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0, 0, 0);
|
||
|
|
mList.onTouchEvent(cancelFling);
|
||
|
|
cancelFling.recycle();
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean onInterceptTouchEvent(MotionEvent ev) {
|
||
|
|
if (mState > STATE_NONE && ev.getAction() == MotionEvent.ACTION_DOWN) {
|
||
|
|
if (isPointInside(ev.getX(), ev.getY())) {
|
||
|
|
setState(STATE_DRAGGING);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean onTouchEvent(MotionEvent me) {
|
||
|
|
if (mState == STATE_NONE) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
final int action = me.getAction();
|
||
|
|
|
||
|
|
if (action == MotionEvent.ACTION_DOWN) {
|
||
|
|
if (isPointInside(me.getX(), me.getY())) {
|
||
|
|
setState(STATE_DRAGGING);
|
||
|
|
if (mListAdapter == null && mList != null) {
|
||
|
|
getSectionsFromIndexer();
|
||
|
|
}
|
||
|
|
if (mList != null) {
|
||
|
|
mList.requestDisallowInterceptTouchEvent(true);
|
||
|
|
mList.reportScrollStateChange(OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
|
||
|
|
}
|
||
|
|
|
||
|
|
cancelFling();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
} else if (action == MotionEvent.ACTION_UP) { // don't add ACTION_CANCEL here
|
||
|
|
if (mState == STATE_DRAGGING) {
|
||
|
|
if (mList != null) {
|
||
|
|
// ViewGroup does the right thing already, but there might
|
||
|
|
// be other classes that don't properly reset on touch-up,
|
||
|
|
// so do this explicitly just in case.
|
||
|
|
mList.requestDisallowInterceptTouchEvent(false);
|
||
|
|
mList.reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
|
||
|
|
}
|
||
|
|
setState(STATE_VISIBLE);
|
||
|
|
final Handler handler = mHandler;
|
||
|
|
handler.removeCallbacks(mScrollFade);
|
||
|
|
handler.postDelayed(mScrollFade, 1000);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
} else if (action == MotionEvent.ACTION_MOVE) {
|
||
|
|
if (mState == STATE_DRAGGING) {
|
||
|
|
final int viewHeight = mList.getHeight();
|
||
|
|
// Jitter
|
||
|
|
int newThumbY = (int) me.getY() - mThumbH + 10;
|
||
|
|
if (newThumbY < 0) {
|
||
|
|
newThumbY = 0;
|
||
|
|
} else if (newThumbY + mThumbH > viewHeight) {
|
||
|
|
newThumbY = viewHeight - mThumbH;
|
||
|
|
}
|
||
|
|
if (Math.abs(mThumbY - newThumbY) < 2) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
mThumbY = newThumbY;
|
||
|
|
// If the previous scrollTo is still pending
|
||
|
|
if (mScrollCompleted) {
|
||
|
|
scrollTo((float) mThumbY / (viewHeight - mThumbH));
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean isPointInside(float x, float y) {
|
||
|
|
return x > mList.getWidth() - mThumbW && y >= mThumbY && y <= mThumbY + mThumbH;
|
||
|
|
}
|
||
|
|
|
||
|
|
public class ScrollFade implements Runnable {
|
||
|
|
|
||
|
|
long mStartTime;
|
||
|
|
long mFadeDuration;
|
||
|
|
static final int ALPHA_MAX = 208;
|
||
|
|
static final long FADE_DURATION = 200;
|
||
|
|
|
||
|
|
void startFade() {
|
||
|
|
mFadeDuration = FADE_DURATION;
|
||
|
|
mStartTime = SystemClock.uptimeMillis();
|
||
|
|
setState(STATE_EXIT);
|
||
|
|
}
|
||
|
|
|
||
|
|
int getAlpha() {
|
||
|
|
if (getState() != STATE_EXIT) {
|
||
|
|
return ALPHA_MAX;
|
||
|
|
}
|
||
|
|
int alpha;
|
||
|
|
long now = SystemClock.uptimeMillis();
|
||
|
|
if (now > mStartTime + mFadeDuration) {
|
||
|
|
alpha = 0;
|
||
|
|
} else {
|
||
|
|
alpha = (int) (ALPHA_MAX - ((now - mStartTime) * ALPHA_MAX) / mFadeDuration);
|
||
|
|
}
|
||
|
|
return alpha;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void run() {
|
||
|
|
if (getState() != STATE_EXIT) {
|
||
|
|
startFade();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (getAlpha() > 0) {
|
||
|
|
mList.invalidate();
|
||
|
|
} else {
|
||
|
|
setState(STATE_NONE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|