/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.fmradio.views; import android.animation.Animator; import android.animation.Animator.AnimatorListener; import android.animation.AnimatorListenerAdapter; import android.animation.ObjectAnimator; import android.content.Context; import android.content.res.Configuration; import android.content.res.Resources; import android.content.res.TypedArray; import android.database.Cursor; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Typeface; import android.hardware.display.DisplayManagerGlobal; import android.os.Handler; import android.os.Looper; import android.util.AttributeSet; import android.util.DisplayMetrics; import android.view.Display; import android.view.DisplayInfo; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuItem; import android.view.MotionEvent; import android.view.VelocityTracker; import android.view.View; import android.view.ViewConfiguration; import android.view.ViewGroup; import android.view.ViewTreeObserver.OnPreDrawListener; import android.view.animation.Interpolator; import android.widget.AdapterView; import android.widget.AdapterView.OnItemClickListener; import android.widget.BaseAdapter; import android.widget.EdgeEffect; import android.widget.FrameLayout; import android.widget.GridView; import android.widget.ImageView; import android.widget.PopupMenu; import android.widget.PopupMenu.OnMenuItemClickListener; import android.widget.ScrollView; import android.widget.Scroller; import android.widget.TextView; import com.android.fmradio.FmStation; import com.android.fmradio.FmUtils; import com.android.fmradio.R; import com.android.fmradio.FmStation.Station; /** * Modified from Contact MultiShrinkScroll Handle the touch event and change * header size and scroll */ public class FmScroller extends FrameLayout { private static final String TAG = "FmScroller"; /** * 1000 pixels per millisecond. Ie, 1 pixel per second. */ private static final int PIXELS_PER_SECOND = 1000; private static final int ON_PLAY_ANIMATION_DELAY = 1000; private static final int PORT_COLUMN_NUM = 3; private static final int LAND_COLUMN_NUM = 5; private static final int STATE_NO_FAVORITE = 0; private static final int STATE_HAS_FAVORITE = 1; private float[] mLastEventPosition = { 0, 0 }; private VelocityTracker mVelocityTracker; private boolean mIsBeingDragged = false; private boolean mReceivedDown = false; private boolean mFirstOnResume = true; private String mSelection = "IS_FAVORITE=?"; private String[] mSelectionArgs = { "1" }; private EventListener mEventListener; private PopupMenu mPopupMenu; private Handler mMainHandler; private ScrollView mScrollView; private View mScrollViewChild; private GridView mGridView; private TextView mFavoriteText; private View mHeader; private int mMaximumHeaderHeight; private int mMinimumHeaderHeight; private Adjuster mAdjuster; private int mCurrentStation; private boolean mIsFmPlaying; private FavoriteAdapter mAdapter; private final Scroller mScroller; private final EdgeEffect mEdgeGlowBottom; private final int mTouchSlop; private final int mMaximumVelocity; private final int mMinimumVelocity; private final int mActionBarSize; private final AnimatorListener mHeaderExpandAnimationListener = new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { refreshStateHeight(); } }; /** * Interpolator from android.support.v4.view.ViewPager. Snappier and more * elastic feeling than the default interpolator. */ private static final Interpolator INTERPOLATOR = new Interpolator() { /** * {@inheritDoc} */ @Override public float getInterpolation(float t) { t -= 1.0f; return t * t * t * t * t + 1.0f; } }; /** * Constructor * * @param context The context */ public FmScroller(Context context) { this(context, null); } /** * Constructor * * @param context The context * @param attrs The attrs */ public FmScroller(Context context, AttributeSet attrs) { this(context, attrs, 0); } /** * Constructor * * @param context The context * @param attrs The attrs * @param defStyleAttr The default attr */ public FmScroller(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); final ViewConfiguration configuration = ViewConfiguration.get(context); setFocusable(false); // Drawing must be enabled in order to support EdgeEffect setWillNotDraw(/* willNotDraw = */false); mEdgeGlowBottom = new EdgeEffect(context); mScroller = new Scroller(context, INTERPOLATOR); mTouchSlop = configuration.getScaledTouchSlop(); mMinimumVelocity = configuration.getScaledMinimumFlingVelocity(); mMaximumVelocity = configuration.getScaledMaximumFlingVelocity(); final TypedArray attributeArray = context.obtainStyledAttributes(new int[] { android.R.attr.actionBarSize }); mActionBarSize = attributeArray.getDimensionPixelSize(0, 0); attributeArray.recycle(); } /** * This method must be called inside the Activity's OnCreate. */ public void initialize() { mScrollView = (ScrollView) findViewById(R.id.content_scroller); mScrollViewChild = findViewById(R.id.favorite_container); mHeader = findViewById(R.id.main_header_parent); mMainHandler = new Handler(Looper.getMainLooper()); mFavoriteText = (TextView) findViewById(R.id.favorite_text); mGridView = (GridView) findViewById(R.id.gridview); mAdapter = new FavoriteAdapter(getContext()); mAdjuster = new Adjuster(getContext()); mGridView.setAdapter(mAdapter); Cursor c = getData(); mAdapter.swipResult(c); mGridView.setFocusable(false); mGridView.setFocusableInTouchMode(false); mGridView.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView parent, View view, int position, long id) { if (mEventListener != null && mAdapter != null) { mEventListener.onPlay(mAdapter.getFrequency(position)); } mMainHandler.removeCallbacks(null); mMainHandler.postDelayed(new Runnable() { @Override public void run() { mMaximumHeaderHeight = getMaxHeight(STATE_HAS_FAVORITE); expandHeader(); } }, ON_PLAY_ANIMATION_DELAY); } }); // Called when first time create activity doOnPreDraw(this, /* drawNextFrame = */false, new Runnable() { @Override public void run() { refreshStateHeight(); setHeaderHeight(getMaximumScrollableHeaderHeight()); updateHeaderTextAndButton(); refreshFavoriteLayout(); } }); } /** * Runs a piece of code just before the next draw, after layout and measurement * * @param view The view depend on * @param drawNextFrame Whether to draw next frame * @param runnable The executed runnable instance */ private void doOnPreDraw(final View view, final boolean drawNextFrame, final Runnable runnable) { final OnPreDrawListener listener = new OnPreDrawListener() { @Override public boolean onPreDraw() { view.getViewTreeObserver().removeOnPreDrawListener(this); runnable.run(); return drawNextFrame; } }; view.getViewTreeObserver().addOnPreDrawListener(listener); } private void refreshFavoriteLayout() { setFavoriteTextHeight(mAdapter.getCount() == 0); setGridViewHeight(computeGridViewHeight()); } private void setFavoriteTextHeight(boolean show) { if (mAdapter.getCount() == 0) { mFavoriteText.setVisibility(View.GONE); } else { mFavoriteText.setVisibility(View.VISIBLE); } } private void setGridViewHeight(int height) { final ViewGroup.LayoutParams params = mGridView.getLayoutParams(); params.height = height; mGridView.setLayoutParams(params); } private int computeGridViewHeight() { int itemcount = mAdapter.getCount(); if (itemcount == 0) { return 0; } int curOrientation = getResources().getConfiguration().orientation; final boolean isLandscape = curOrientation == Configuration.ORIENTATION_LANDSCAPE; int columnNum = isLandscape ? LAND_COLUMN_NUM : PORT_COLUMN_NUM; int itemHeight = (int) getResources().getDimension(R.dimen.fm_gridview_item_height); int itemPadding = (int) getResources().getDimension(R.dimen.fm_gridview_item_padding); int rownum = (int) Math.ceil(itemcount / (float) columnNum); int totalHeight = rownum * itemHeight + rownum * itemPadding; if (rownum == 2) { int minGridViewHeight = getHeight() - getMinHeight(STATE_HAS_FAVORITE) - 72; totalHeight = Math.max(totalHeight, minGridViewHeight); } return totalHeight; } @Override public boolean onInterceptTouchEvent(MotionEvent event) { // The only time we want to intercept touch events is when we are being // dragged. return shouldStartDrag(event); } private boolean shouldStartDrag(MotionEvent event) { if (mIsBeingDragged) { mIsBeingDragged = false; return false; } switch (event.getAction()) { // If we are in the middle of a fling and there is a down event, // we'll steal it and // start a drag. case MotionEvent.ACTION_DOWN: updateLastEventPosition(event); if (!mScroller.isFinished()) { startDrag(); return true; } else { mReceivedDown = true; } break; // Otherwise, we will start a drag if there is enough motion in the // direction we are // capable of scrolling. case MotionEvent.ACTION_MOVE: if (motionShouldStartDrag(event)) { updateLastEventPosition(event); startDrag(); return true; } break; default: break; } return false; } @Override public boolean onTouchEvent(MotionEvent event) { final int action = event.getAction(); if (mVelocityTracker == null) { mVelocityTracker = VelocityTracker.obtain(); } mVelocityTracker.addMovement(event); if (!mIsBeingDragged) { if (shouldStartDrag(event)) { return true; } if (action == MotionEvent.ACTION_UP && mReceivedDown) { mReceivedDown = false; return performClick(); } return true; } switch (action) { case MotionEvent.ACTION_MOVE: final float delta = updatePositionAndComputeDelta(event); scrollTo(0, getScroll() + (int) delta); mReceivedDown = false; if (mIsBeingDragged) { final int distanceFromMaxScrolling = getMaximumScrollUpwards() - getScroll(); if (delta > distanceFromMaxScrolling) { // The ScrollView is being pulled upwards while there is // no more // content offscreen, and the view port is already fully // expanded. mEdgeGlowBottom.onPull(delta / getHeight(), 1 - event.getX() / getWidth()); } if (!mEdgeGlowBottom.isFinished()) { postInvalidateOnAnimation(); } } break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_CANCEL: stopDrag(action == MotionEvent.ACTION_CANCEL); mReceivedDown = false; break; default: break; } return true; } /** * Expand to maximum size or starting size. Disable clicks on the * photo until the animation is complete. */ private void expandHeader() { if (getHeaderHeight() != mMaximumHeaderHeight) { // Expand header final ObjectAnimator animator = ObjectAnimator.ofInt(this, "headerHeight", mMaximumHeaderHeight); animator.addListener(mHeaderExpandAnimationListener); animator.setDuration(300); animator.start(); // Scroll nested scroll view to its top if (mScrollView.getScrollY() != 0) { ObjectAnimator.ofInt(mScrollView, "scrollY", 0).setDuration(300).start(); } } } private void collapseHeader() { if (getHeaderHeight() != mMinimumHeaderHeight) { final ObjectAnimator animator = ObjectAnimator.ofInt(this, "headerHeight", mMinimumHeaderHeight); animator.addListener(mHeaderExpandAnimationListener); animator.start(); } } private void startDrag() { mIsBeingDragged = true; mScroller.abortAnimation(); } private void stopDrag(boolean cancelled) { mIsBeingDragged = false; if (!cancelled && getChildCount() > 0) { final float velocity = getCurrentVelocity(); if (velocity > mMinimumVelocity || velocity < -mMinimumVelocity) { fling(-velocity); } } if (mVelocityTracker != null) { mVelocityTracker.recycle(); mVelocityTracker = null; } mEdgeGlowBottom.onRelease(); } @Override public void scrollTo(int x, int y) { final int delta = y - getScroll(); if (delta > 0) { scrollUp(delta); } else { scrollDown(delta); } updateHeaderTextAndButton(); } private int getToolbarHeight() { return mHeader.getLayoutParams().height; } /** * Set the height of the toolbar and update its tint accordingly. */ @FmReflection public void setHeaderHeight(int height) { final ViewGroup.LayoutParams toolbarLayoutParams = mHeader.getLayoutParams(); toolbarLayoutParams.height = height; mHeader.setLayoutParams(toolbarLayoutParams); updateHeaderTextAndButton(); } /** * Get header height. Used in ObjectAnimator * * @return The header height */ @FmReflection public int getHeaderHeight() { return mHeader.getLayoutParams().height; } /** * Set scroll. Used in ObjectAnimator */ @FmReflection public void setScroll(int scroll) { scrollTo(0, scroll); } /** * Returns the total amount scrolled inside the nested ScrollView + the amount * of shrinking performed on the ToolBar. This is the value inspected by animators. */ @FmReflection public int getScroll() { return getMaximumScrollableHeaderHeight() - getToolbarHeight() + mScrollView.getScrollY(); } private int getMaximumScrollableHeaderHeight() { return mMaximumHeaderHeight; } /** * A variant of {@link #getScroll} that pretends the header is never * larger than than mIntermediateHeaderHeight. This function is sometimes * needed when making scrolling decisions that will not change the header * size (ie, snapping to the bottom or top). When mIsOpenContactSquare is * true, this function considers mIntermediateHeaderHeight == mMaximumHeaderHeight, * since snapping decisions will be made relative the full header size when * mIsOpenContactSquare = true. This value should never be used in conjunction * with {@link #getScroll} values. */ private int getScrollIgnoreOversizedHeaderForSnapping() { return Math.max(getMaximumScrollableHeaderHeight() - getToolbarHeight(), 0) + mScrollView.getScrollY(); } /** * Return amount of scrolling needed in order for all the visible * subviews to scroll off the bottom. */ private int getScrollUntilOffBottom() { return getHeight() + getScrollIgnoreOversizedHeaderForSnapping(); } @Override public void computeScroll() { if (mScroller.computeScrollOffset()) { // Examine the fling results in order to activate EdgeEffect when we // fling to the end. final int oldScroll = getScroll(); scrollTo(0, mScroller.getCurrY()); final int delta = mScroller.getCurrY() - oldScroll; final int distanceFromMaxScrolling = getMaximumScrollUpwards() - getScroll(); if (delta > distanceFromMaxScrolling && distanceFromMaxScrolling > 0) { mEdgeGlowBottom.onAbsorb((int) mScroller.getCurrVelocity()); } if (!awakenScrollBars()) { // Keep on drawing until the animation has finished. postInvalidateOnAnimation(); } if (mScroller.getCurrY() >= getMaximumScrollUpwards()) { mScroller.abortAnimation(); } } } @Override public void draw(Canvas canvas) { super.draw(canvas); if (!mEdgeGlowBottom.isFinished()) { final int restoreCount = canvas.save(); final int width = getWidth() - getPaddingLeft() - getPaddingRight(); final int height = getHeight(); // Draw the EdgeEffect on the bottom of the Window (Or a little bit // below the bottom // of the Window if we start to scroll upwards while EdgeEffect is // visible). This // does not need to consider the case where this MultiShrinkScroller // doesn't fill // the Window, since the nested ScrollView should be set to // fillViewport. canvas.translate(-width + getPaddingLeft(), height + getMaximumScrollUpwards() - getScroll()); canvas.rotate(180, width, 0); mEdgeGlowBottom.setSize(width, height); if (mEdgeGlowBottom.draw(canvas)) { postInvalidateOnAnimation(); } canvas.restoreToCount(restoreCount); } } private float getCurrentVelocity() { if (mVelocityTracker == null) { return 0; } mVelocityTracker.computeCurrentVelocity(PIXELS_PER_SECOND, mMaximumVelocity); return mVelocityTracker.getYVelocity(); } private void fling(float velocity) { // For reasons I do not understand, scrolling is less janky when // maxY=Integer.MAX_VALUE // then when maxY is set to an actual value. mScroller.fling(0, getScroll(), 0, (int) velocity, 0, 0, -Integer.MAX_VALUE, Integer.MAX_VALUE); invalidate(); } private int getMaximumScrollUpwards() { return // How much the Header view can compress getMaximumScrollableHeaderHeight() - getFullyCompressedHeaderHeight() // How much the ScrollView can scroll. 0, if child is // smaller than ScrollView. + Math.max(0, mScrollViewChild.getHeight() - getHeight() + getFullyCompressedHeaderHeight()); } private void scrollUp(int delta) { final ViewGroup.LayoutParams toolbarLayoutParams = mHeader.getLayoutParams(); if (toolbarLayoutParams.height > getFullyCompressedHeaderHeight()) { final int originalValue = toolbarLayoutParams.height; toolbarLayoutParams.height -= delta; toolbarLayoutParams.height = Math.max(toolbarLayoutParams.height, getFullyCompressedHeaderHeight()); mHeader.setLayoutParams(toolbarLayoutParams); delta -= originalValue - toolbarLayoutParams.height; } mScrollView.scrollBy(0, delta); } /** * Returns the minimum size that we want to compress the header to, * given that we don't want to allow the the ScrollView to scroll * unless there is new content off of the edge of ScrollView. */ private int getFullyCompressedHeaderHeight() { int height = Math.min(Math.max(mHeader.getLayoutParams().height - getOverflowingChildViewSize(), mMinimumHeaderHeight), getMaximumScrollableHeaderHeight()); return height; } /** * Returns the amount of mScrollViewChild that doesn't fit inside its parent. Outside size */ private int getOverflowingChildViewSize() { final int usedScrollViewSpace = mScrollViewChild.getHeight(); return -getHeight() + usedScrollViewSpace + mHeader.getLayoutParams().height; } private void scrollDown(int delta) { if (mScrollView.getScrollY() > 0) { final int originalValue = mScrollView.getScrollY(); mScrollView.scrollBy(0, delta); } } private void updateHeaderTextAndButton() { mAdjuster.handleScroll(); } private void updateLastEventPosition(MotionEvent event) { mLastEventPosition[0] = event.getX(); mLastEventPosition[1] = event.getY(); } private boolean motionShouldStartDrag(MotionEvent event) { final float deltaX = event.getX() - mLastEventPosition[0]; final float deltaY = event.getY() - mLastEventPosition[1]; final boolean draggedX = (deltaX > mTouchSlop || deltaX < -mTouchSlop); final boolean draggedY = (deltaY > mTouchSlop || deltaY < -mTouchSlop); return draggedY && !draggedX; } private float updatePositionAndComputeDelta(MotionEvent event) { final int vertical = 1; final float position = mLastEventPosition[vertical]; updateLastEventPosition(event); return position - mLastEventPosition[vertical]; } /** * Interpolator that enforces a specific starting velocity. * This is useful to avoid a discontinuity between dragging * speed and flinging speed. Similar to a * {@link android.view.animation.AccelerateInterpolator} in * the sense that getInterpolation() is a quadratic function. */ private static class AcceleratingFlingInterpolator implements Interpolator { private final float mStartingSpeedPixelsPerFrame; private final float mDurationMs; private final int mPixelsDelta; private final float mNumberFrames; public AcceleratingFlingInterpolator(int durationMs, float startingSpeedPixelsPerSecond, int pixelsDelta) { mStartingSpeedPixelsPerFrame = startingSpeedPixelsPerSecond / getRefreshRate(); mDurationMs = durationMs; mPixelsDelta = pixelsDelta; mNumberFrames = mDurationMs / getFrameIntervalMs(); } @Override public float getInterpolation(float input) { final float animationIntervalNumber = mNumberFrames * input; final float linearDelta = (animationIntervalNumber * mStartingSpeedPixelsPerFrame) / mPixelsDelta; // Add the results of a linear interpolator (with the initial speed) // with the // results of a AccelerateInterpolator. if (mStartingSpeedPixelsPerFrame > 0) { return Math.min(input * input + linearDelta, 1); } else { // Initial fling was in the wrong direction, make sure that the // quadratic component // grows faster in order to make up for this. return Math.min(input * (input - linearDelta) + linearDelta, 1); } } private float getRefreshRate() { DisplayInfo di = DisplayManagerGlobal.getInstance().getDisplayInfo( Display.DEFAULT_DISPLAY); return di.refreshRate; } public long getFrameIntervalMs() { return (long) (1000 / getRefreshRate()); } } private int getMaxHeight(int state) { int height = 0; switch (state) { case STATE_NO_FAVORITE: height = getHeight(); break; case STATE_HAS_FAVORITE: height = (int) getResources().getDimension(R.dimen.fm_main_header_big); break; default: break; } return height; } private int getMinHeight(int state) { int height = 0; switch (state) { case STATE_NO_FAVORITE: height = (int) getResources().getDimension(R.dimen.fm_main_header_big); break; case STATE_HAS_FAVORITE: height = (int) getResources().getDimension(R.dimen.fm_main_header_small); break; default: break; } return height; } private void setMinHeight(int height) { mMinimumHeaderHeight = height; } class FavoriteAdapter extends BaseAdapter { private Cursor mCursor; private LayoutInflater mInflater; public FavoriteAdapter(Context context) { mInflater = LayoutInflater.from(context); } public int getFrequency(int position) { if (mCursor != null && mCursor.moveToFirst()) { mCursor.moveToPosition(position); return mCursor.getInt(mCursor.getColumnIndex(FmStation.Station.FREQUENCY)); } return 0; } public void swipResult(Cursor cursor) { if (null != mCursor) { mCursor.close(); } mCursor = cursor; notifyDataSetChanged(); } @Override public int getCount() { if (null != mCursor) { return mCursor.getCount(); } return 0; } @Override public Object getItem(int position) { return null; } @Override public long getItemId(int position) { return 0; } @Override public View getView(int position, View convertView, ViewGroup parent) { ViewHolder viewHolder = null; if (null == convertView) { viewHolder = new ViewHolder(); convertView = mInflater.inflate(R.layout.favorite_gridview_item, null); viewHolder.mStationFreq = (TextView) convertView.findViewById(R.id.station_freq); viewHolder.mPlayIndicator = (FmVisualizerView) convertView .findViewById(R.id.fm_play_indicator); viewHolder.mStationName = (TextView) convertView.findViewById(R.id.station_name); viewHolder.mMoreButton = (ImageView) convertView.findViewById(R.id.station_more); viewHolder.mPopupMenuAnchor = convertView.findViewById(R.id.popupmenu_anchor); convertView.setTag(viewHolder); } else { viewHolder = (ViewHolder) convertView.getTag(); } if (mCursor != null && mCursor.moveToPosition(position)) { final int stationFreq = mCursor.getInt(mCursor .getColumnIndex(FmStation.Station.FREQUENCY)); String name = mCursor.getString(mCursor .getColumnIndex(FmStation.Station.STATION_NAME)); String rds = mCursor.getString(mCursor .getColumnIndex(FmStation.Station.RADIO_TEXT)); final int isFavorite = mCursor.getInt(mCursor .getColumnIndex(FmStation.Station.IS_FAVORITE)); if (null == name || "".equals(name)) { name = mCursor.getString(mCursor .getColumnIndex(FmStation.Station.PROGRAM_SERVICE)); } if (null == name || "".equals(name)) { name = ""; } viewHolder.mStationFreq.setText(FmUtils.formatStation(stationFreq)); viewHolder.mStationName.setText(name); if (mCurrentStation == stationFreq) { viewHolder.mPlayIndicator.setVisibility(View.VISIBLE); if (mIsFmPlaying) { viewHolder.mPlayIndicator.startAnimation(); } else { viewHolder.mPlayIndicator.stopAnimation(); } viewHolder.mStationFreq.setTextColor(Color.parseColor("#607D8B")); viewHolder.mStationFreq.setAlpha(1f); viewHolder.mStationName.setMaxLines(1); } else { viewHolder.mPlayIndicator.setVisibility(View.GONE); viewHolder.mPlayIndicator.stopAnimation(); viewHolder.mStationFreq.setTextColor(Color.parseColor("#000000")); viewHolder.mStationFreq.setAlpha(0.87f); viewHolder.mStationName.setMaxLines(2); } viewHolder.mMoreButton.setTag(viewHolder.mPopupMenuAnchor); viewHolder.mMoreButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // Use anchor view to fix PopupMenu postion and cover more button View anchor = v; if (v.getTag() != null) { anchor = (View) v.getTag(); } showPopupMenu(anchor, stationFreq); } }); } return convertView; } } private Cursor getData() { Cursor cursor = getContext().getContentResolver().query(Station.CONTENT_URI, FmStation.COLUMNS, mSelection, mSelectionArgs, FmStation.Station.FREQUENCY); return cursor; } /** * Called when FmRadioActivity.onResume(), refresh layout */ public void onResume() { Cursor c = getData(); mAdapter.swipResult(c); if (mFirstOnResume) { mFirstOnResume = false; } else { refreshStateHeight(); updateHeaderTextAndButton(); refreshFavoriteLayout(); int curOrientation = getResources().getConfiguration().orientation; final boolean isLandscape = curOrientation == Configuration.ORIENTATION_LANDSCAPE; int columnNum = isLandscape ? LAND_COLUMN_NUM : PORT_COLUMN_NUM; boolean isOneRow = c.getCount() <= columnNum; boolean hasFavoriteCurrent = c.getCount() > 0; if (mHasFavoriteWhenOnPause != hasFavoriteCurrent || isOneRow) { setHeaderHeight(getMaximumScrollableHeaderHeight()); } } } private boolean mHasFavoriteWhenOnPause = false; /** * Called when FmRadioActivity.onPause() */ public void onPause() { if (mAdapter != null && mAdapter.getCount() > 0) { mHasFavoriteWhenOnPause = true; } else { mHasFavoriteWhenOnPause = false; } } /** * Notify refresh adapter when data change */ public void notifyAdatperChange() { Cursor c = getData(); mAdapter.swipResult(c); } private void refreshStateHeight() { if (mAdapter != null && mAdapter.getCount() > 0) { mMaximumHeaderHeight = getMaxHeight(STATE_HAS_FAVORITE); mMinimumHeaderHeight = getMinHeight(STATE_HAS_FAVORITE); } else { mMaximumHeaderHeight = getMaxHeight(STATE_NO_FAVORITE); mMinimumHeaderHeight = getMinHeight(STATE_NO_FAVORITE); } } /** * Called when add a favorite */ public void onAddFavorite() { Cursor c = getData(); mAdapter.swipResult(c); refreshFavoriteLayout(); if (c.getCount() == 1) { // Last time count is 0, so need set STATE_NO_FAVORITE then collapse header mMinimumHeaderHeight = getMinHeight(STATE_NO_FAVORITE); mMaximumHeaderHeight = getMaxHeight(STATE_NO_FAVORITE); collapseHeader(); } } /** * Called when remove a favorite */ public void onRemoveFavorite() { Cursor c = getData(); mAdapter.swipResult(c); refreshFavoriteLayout(); if (c != null && c.getCount() == 0) { // Stop the play animation mMainHandler.removeCallbacks(null); // Last time count is 1, so need set STATE_NO_FAVORITE then expand header mMinimumHeaderHeight = getMinHeight(STATE_NO_FAVORITE); mMaximumHeaderHeight = getMaxHeight(STATE_NO_FAVORITE); expandHeader(); } } private void showPopupMenu(View anchor, final int frequency) { dismissPopupMenu(); mPopupMenu = new PopupMenu(getContext(), anchor); Menu menu = mPopupMenu.getMenu(); mPopupMenu.getMenuInflater().inflate(R.menu.gridview_item_more_menu, menu); mPopupMenu.setOnMenuItemClickListener(new OnMenuItemClickListener() { @Override public boolean onMenuItemClick(MenuItem item) { switch (item.getItemId()) { case R.id.remove_favorite: if (mEventListener != null) { mEventListener.onRemoveFavorite(frequency); } break; case R.id.rename: if (mEventListener != null) { mEventListener.onRename(frequency); } break; default: break; } return false; } }); mPopupMenu.show(); } private void dismissPopupMenu() { if (mPopupMenu != null) { mPopupMenu.dismiss(); mPopupMenu = null; } } /** * Called when FmRadioActivity.onDestory() */ public void closeAdapterCursor() { mAdapter.swipResult(null); } /** * Register a listener for GridView item event * * @param listener The event listener */ public void registerListener(EventListener listener) { mEventListener = listener; } /** * Unregister a listener for GridView item event * * @param listener The event listener */ public void unregisterListener(EventListener listener) { mEventListener = null; } /** * Listen for GridView item event: remove, rename, click play */ public interface EventListener { /** * Callback when click remove favorite menu * * @param frequency The frequency want to remove */ void onRemoveFavorite(int frequency); /** * Callback when click rename favorite menu * * @param frequency The frequency want to rename */ void onRename(int frequency); /** * Callback when click gridview item to play * * @param frequency The frequency want to play */ void onPlay(int frequency); } /** * Refresh the play indicator in gridview when play station or play state change * * @param currentStation current station * @param isFmPlaying whether fm is playing */ public void refreshPlayIndicator(int currentStation, boolean isFmPlaying) { mCurrentStation = currentStation; mIsFmPlaying = isFmPlaying; if (mAdapter != null) { mAdapter.notifyDataSetChanged(); } } /** * Adjust view padding and text size when scroll */ private class Adjuster { private final DisplayMetrics mDisplayMetrics; private final int mFirstTargetHeight; private final int mSecondTargetHeight; private final int mActionBarHeight = mActionBarSize; private final int mStatusBarHeight; private final int mFullHeight;// display height without status bar private final float mDensity; private final Typeface mDefaultFrequencyTypeface; // Text view private TextView mFrequencyText; private TextView mFmDescriptionText; private TextView mStationNameText; private TextView mStationRdsText; /* * The five control buttons view(previous, next, increase, * decrease, favorite) and stop button */ private View mControlView; private View mPlayButtonView; private final Context mContext; private final boolean mIsLandscape; private FirstRangeAdjuster mFirstRangeAdjuster; private SecondRangeAdjuster mSecondRangeAdjusterr; public Adjuster(Context context) { mContext = context; mDisplayMetrics = mContext.getResources().getDisplayMetrics(); mDensity = mDisplayMetrics.density; int curOrientation = getResources().getConfiguration().orientation; mIsLandscape = curOrientation == Configuration.ORIENTATION_LANDSCAPE; Resources res = mContext.getResources(); mFirstTargetHeight = res.getDimensionPixelSize(R.dimen.fm_main_header_big); mSecondTargetHeight = res.getDimensionPixelSize(R.dimen.fm_main_header_small); mStatusBarHeight = res .getDimensionPixelSize(com.android.internal.R.dimen.status_bar_height); mFullHeight = mDisplayMetrics.heightPixels - mStatusBarHeight; mFrequencyText = (TextView) findViewById(R.id.station_value); mFmDescriptionText = (TextView) findViewById(R.id.text_fm); mStationNameText = (TextView) findViewById(R.id.station_name); mStationRdsText = (TextView) findViewById(R.id.station_rds); mControlView = findViewById(R.id.rl_imgbtnpart); mPlayButtonView = findViewById(R.id.play_button_container); mFirstRangeAdjuster = new FirstRangeAdjuster(); mSecondRangeAdjusterr = new SecondRangeAdjuster(); mControlView.setMinimumWidth(mIsLandscape ? mDisplayMetrics.heightPixels : mDisplayMetrics.widthPixels); mDefaultFrequencyTypeface = mFrequencyText.getTypeface(); } public void handleScroll() { int height = getHeaderHeight(); if (mIsLandscape || height > mFirstTargetHeight) { mFirstRangeAdjuster.handleScroll(); } else if (height >= mSecondTargetHeight) { mSecondRangeAdjusterr.handleScroll(); } } private class FirstRangeAdjuster { protected int mTargetHeight; // start text size and margin protected float mFmDescriptionTextSizeStart; protected float mFrequencyStartTextSize; protected float mStationNameTextSizeStart; protected float mFmDescriptionMarginTopStart; protected float mFmDescriptionStartPaddingLeft; protected float mFrequencyMarginTopStart; protected float mStationNameMarginTopStart; protected float mStationRdsMarginTopStart; protected float mControlViewMarginTopStart; // target text size and margin protected float mFmDescriptionTextSizeTarget; protected float mFrequencyTextSizeTarget; protected float mStationNameTextSizeTarget; protected float mFmDescriptionMarginTopTarget; protected float mFrequencyMarginTopTarget; protected float mStationNameMarginTopTarget; protected float mStationRdsMarginTopTarget; protected float mControlViewMarginTopTarget; protected float mPlayButtonMarginTopStart; protected float mPlayButtonMarginTopTarget; protected float mPlayButtonHeight; // Padding adjust rate as linear protected float mFmDescriptionPaddingRate; protected float mFrequencyPaddingRate; protected float mStationNamePaddingRate; protected float mStationRdsPaddingRate; protected float mControlViewPaddingRate; // init it with display height protected float mPlayButtonPaddingRate; // Text size adjust rate as linear // adjust from first to target critical height protected float mFmDescriptionTextSizeRate; protected float mFrequencyTextSizeRate; // adjust before first critical height protected float mStationNameTextSizeRate; public FirstRangeAdjuster() { Resources res = mContext.getResources(); mTargetHeight = mFirstTargetHeight; // init start mFmDescriptionTextSizeStart = res.getDimension(R.dimen.fm_description_text_size); mFrequencyStartTextSize = res.getDimension(R.dimen.fm_frequency_text_size_start); mStationNameTextSizeStart = res .getDimension(R.dimen.fm_station_name_text_size_start); // first view, margin refer to parent mFmDescriptionMarginTopStart = res .getDimension(R.dimen.fm_description_margin_top_start) + mActionBarHeight; mFrequencyMarginTopStart = res.getDimension(R.dimen.fm_frequency_margin_top_start); mStationNameMarginTopStart = res .getDimension(R.dimen.fm_station_name_margin_top_start); mStationRdsMarginTopStart = res .getDimension(R.dimen.fm_station_rds_margin_top_start); mControlViewMarginTopStart = res .getDimension(R.dimen.fm_control_buttons_margin_top_start); // init target mFrequencyTextSizeTarget = res .getDimension(R.dimen.fm_frequency_text_size_first_target); mFmDescriptionTextSizeTarget = mFrequencyTextSizeTarget; mStationNameTextSizeTarget = res .getDimension(R.dimen.fm_station_name_text_size_first_target); mFmDescriptionMarginTopTarget = res .getDimension(R.dimen.fm_description_margin_top_first_target); mFmDescriptionStartPaddingLeft = mFrequencyText.getPaddingLeft(); // first view, margin refer to parent if not in landscape if (!mIsLandscape) { mFmDescriptionMarginTopTarget += mActionBarHeight; } else { mFrequencyMarginTopStart += mActionBarHeight + mFmDescriptionTextSizeStart; } mFrequencyMarginTopTarget = res .getDimension(R.dimen.fm_frequency_margin_top_first_target); mStationNameMarginTopTarget = res .getDimension(R.dimen.fm_station_name_margin_top_first_target); mStationRdsMarginTopTarget = res .getDimension(R.dimen.fm_station_rds_margin_top_first_target); mControlViewMarginTopTarget = res .getDimension(R.dimen.fm_control_buttons_margin_top_first_target); // init text size and margin adjust rate int scrollHeight = mFullHeight - mTargetHeight; mFmDescriptionTextSizeRate = (mFmDescriptionTextSizeStart - mFmDescriptionTextSizeTarget) / scrollHeight; mFrequencyTextSizeRate = (mFrequencyStartTextSize - mFrequencyTextSizeTarget) / scrollHeight; mStationNameTextSizeRate = (mStationNameTextSizeStart - mStationNameTextSizeTarget) / scrollHeight; mFmDescriptionPaddingRate = (mFmDescriptionMarginTopStart - mFmDescriptionMarginTopTarget) / scrollHeight; mFrequencyPaddingRate = (mFrequencyMarginTopStart - mFrequencyMarginTopTarget) / scrollHeight; mStationNamePaddingRate = (mStationNameMarginTopStart - mStationNameMarginTopTarget) / scrollHeight; mStationRdsPaddingRate = (mStationRdsMarginTopStart - mStationRdsMarginTopTarget) / scrollHeight; mControlViewPaddingRate = (mControlViewMarginTopStart - mControlViewMarginTopTarget) / scrollHeight; // init play button padding, it different to others, padding top refer to parent mPlayButtonHeight = res.getDimension(R.dimen.play_button_height); mPlayButtonMarginTopStart = mFullHeight - mPlayButtonHeight - 16 * mDensity; mPlayButtonMarginTopTarget = mFirstTargetHeight - mPlayButtonHeight / 2; mPlayButtonPaddingRate = (mPlayButtonMarginTopStart - mPlayButtonMarginTopTarget) / scrollHeight; } public void handleScroll() { if (mIsLandscape) { handleScrollLandscapeMode(); return; } int currentHeight = getHeaderHeight(); float newMargin = 0; float lastHeight = 0; float newTextSize; // 1.FM description (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mFmDescriptionMarginTopTarget, mFmDescriptionPaddingRate); lastHeight = setNewPadding(mFmDescriptionText, newMargin); // 2. frequency text (text size and margin) newTextSize = getNewSize(currentHeight, mTargetHeight, mFrequencyTextSizeTarget, mFrequencyTextSizeRate); mFrequencyText.setTextSize(newTextSize / mDensity); newMargin = getNewSize(currentHeight, mTargetHeight, mFrequencyMarginTopTarget, mFrequencyPaddingRate); lastHeight = setNewPadding(mFrequencyText, newMargin + lastHeight); // 3. station name (margin and text size) newMargin = getNewSize(currentHeight, mTargetHeight, mStationNameMarginTopTarget, mStationNamePaddingRate); lastHeight = setNewPadding(mStationNameText, newMargin + lastHeight); newTextSize = getNewSize(currentHeight, mTargetHeight, mStationNameTextSizeTarget, mStationNameTextSizeRate); mStationNameText.setTextSize(newTextSize / mDensity); // 4. station rds (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mStationRdsMarginTopTarget, mStationRdsPaddingRate); lastHeight = setNewPadding(mStationRdsText, newMargin + lastHeight); // 5. control buttons (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mControlViewMarginTopTarget, mControlViewPaddingRate); setNewPadding(mControlView, newMargin + lastHeight); // 6. stop button (padding), it different to others, padding top refer to parent newMargin = getNewSize(currentHeight, mTargetHeight, mPlayButtonMarginTopTarget, mPlayButtonPaddingRate); setNewPadding(mPlayButtonView, newMargin); } private void handleScrollLandscapeMode() { int currentHeight = getHeaderHeight(); float newMargin = 0; float lastHeight = 0; float newTextSize; // 1. FM description (color, alpha and margin) newMargin = getNewSize(currentHeight, mTargetHeight, mFmDescriptionMarginTopTarget, mFmDescriptionPaddingRate); setNewPadding(mFmDescriptionText, newMargin); newTextSize = getNewSize(currentHeight, mTargetHeight, mFmDescriptionTextSizeTarget, mFmDescriptionTextSizeRate); mFmDescriptionText.setTextSize(newTextSize / mDensity); boolean reachTop = (mSecondTargetHeight == getHeaderHeight()); mFmDescriptionText.setTextColor(reachTop ? Color.WHITE : getResources().getColor(R.color.text_fm_color)); mFmDescriptionText.setAlpha(reachTop ? 0.87f : 1.0f); // 2. frequency text (text size, padding and margin) newTextSize = getNewSize(currentHeight, mTargetHeight, mFrequencyTextSizeTarget, mFrequencyTextSizeRate); mFrequencyText.setTextSize(newTextSize / mDensity); newMargin = getNewSize(currentHeight, mTargetHeight, mFrequencyMarginTopTarget, mFrequencyPaddingRate); // Move frequency text like "103.7" from middle to action bar in landscape, // or opposite direction. For example: // ************************* ************************* // * * * FM 103.7 * // * FM * <--> * * // * 103.7 * * * // ************************* ************************* // "FM", "103.7" and other subviews are in a RelativeLayout (id actionbar_parent) // in main_header.xml. The position is controlled by the padding of each subview. // Because "FM" and "103.7" move up, we need to change the padding top and change // the padding left of "103.7". // The padding between "FM" and "103.7" is 0.2 (e.g. paddingRate) times // the length of "FM" string length. float paddingRate = 0.2f; float addPadding = (((1 + paddingRate) * computeFmDescriptionWidth()) * (mFullHeight - currentHeight)) / (mFullHeight - mTargetHeight); mFrequencyText.setPadding((int) (addPadding + mFmDescriptionStartPaddingLeft), (int) (newMargin), mFrequencyText.getPaddingRight(), mFrequencyText.getPaddingBottom()); lastHeight = newMargin + lastHeight + mFrequencyText.getTextSize(); // If frequency text move to action bar, change it to bold setNewTypefaceForFrequencyText(); // 3. station name (text size and margin) newTextSize = getNewSize(currentHeight, mTargetHeight, mStationNameTextSizeTarget, mStationNameTextSizeRate); mStationNameText.setTextSize(newTextSize / mDensity); newMargin = getNewSize(currentHeight, mTargetHeight, mStationNameMarginTopTarget, mStationNamePaddingRate); // if move to target position, need not move over the edge of actionbar if (lastHeight <= mActionBarHeight) { lastHeight = mActionBarHeight; } lastHeight = setNewPadding(mStationNameText, newMargin + lastHeight); /* * 4. station rds (margin), in landscape with favorite * it need parallel to station name */ newMargin = getNewSize(currentHeight, mTargetHeight, mStationRdsMarginTopTarget, mStationRdsPaddingRate); int targetHeight = mFullHeight - (mFullHeight - mTargetHeight) / 2; if (currentHeight <= targetHeight) { String stationName = "" + mStationNameText.getText(); int stationNameTextWidth = mStationNameText.getPaddingLeft(); if (!stationName.equals("")) { Paint paint = mStationNameText.getPaint(); stationNameTextWidth += (int) paint.measureText(stationName) + 8; } mStationRdsText.setPadding((int) stationNameTextWidth, (int) (newMargin + lastHeight), mStationRdsText.getPaddingRight(), mStationRdsText.getPaddingBottom()); } else { mStationRdsText.setPadding((int) (16 * mDensity), (int) (newMargin + lastHeight), mStationRdsText.getPaddingRight(), mStationRdsText.getPaddingBottom()); } // 5. control buttons (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mControlViewMarginTopTarget, mControlViewPaddingRate); setNewPadding(mControlView, newMargin + lastHeight); // 6. stop button (padding), it different to others, padding top refer to parent newMargin = getNewSize(currentHeight, mTargetHeight, mPlayButtonMarginTopTarget, mPlayButtonPaddingRate); setNewPadding(mPlayButtonView, newMargin); } // Compute the text "FM" width private float computeFmDescriptionWidth() { Paint paint = mFmDescriptionText.getPaint(); return (float) paint.measureText(mFmDescriptionText.getText().toString()); } } private class SecondRangeAdjuster extends FirstRangeAdjuster { public SecondRangeAdjuster() { Resources res = mContext.getResources(); mTargetHeight = mSecondTargetHeight; // init start mFrequencyStartTextSize = res .getDimension(R.dimen.fm_frequency_text_size_first_target); mStationNameTextSizeStart = res .getDimension(R.dimen.fm_station_name_text_size_first_target); mFmDescriptionMarginTopStart = res .getDimension(R.dimen.fm_description_margin_top_first_target) + mActionBarHeight;// first view, margin refer to parent mFrequencyMarginTopStart = res .getDimension(R.dimen.fm_frequency_margin_top_first_target); mStationNameMarginTopStart = res .getDimension(R.dimen.fm_station_name_margin_top_first_target); mStationRdsMarginTopStart = res .getDimension(R.dimen.fm_station_rds_margin_top_first_target); mControlViewMarginTopStart = res .getDimension(R.dimen.fm_control_buttons_margin_top_first_target); // init target mFrequencyTextSizeTarget = res .getDimension(R.dimen.fm_frequency_text_size_second_target); mStationNameTextSizeTarget = res .getDimension(R.dimen.fm_station_name_text_size_second_target); mFmDescriptionMarginTopTarget = res .getDimension(R.dimen.fm_description_margin_top_second_target); mFrequencyMarginTopTarget = res .getDimension(R.dimen.fm_frequency_margin_top_second_target); mStationNameMarginTopTarget = res .getDimension(R.dimen.fm_station_name_margin_top_second_target); mStationRdsMarginTopTarget = res .getDimension(R.dimen.fm_station_rds_margin_top_second_target); mControlViewMarginTopTarget = res .getDimension(R.dimen.fm_control_buttons_margin_top_second_target); // init text size and margin adjust rate float scrollHeight = mFirstTargetHeight - mTargetHeight; mFrequencyTextSizeRate = (mFrequencyStartTextSize - mFrequencyTextSizeTarget) / scrollHeight; mStationNameTextSizeRate = (mStationNameTextSizeStart - mStationNameTextSizeTarget) / scrollHeight; mFmDescriptionPaddingRate = (mFmDescriptionMarginTopStart - mFmDescriptionMarginTopTarget) / scrollHeight; mFrequencyPaddingRate = (mFrequencyMarginTopStart - mFrequencyMarginTopTarget) / scrollHeight; mStationNamePaddingRate = (mStationNameMarginTopStart - mStationNameMarginTopTarget) / scrollHeight; mStationRdsPaddingRate = (mStationRdsMarginTopStart - mStationRdsMarginTopTarget) / scrollHeight; mControlViewPaddingRate = (mControlViewMarginTopStart - mControlViewMarginTopTarget) / scrollHeight; // init play button padding, it different to others, padding top refer to parent mPlayButtonHeight = res.getDimension(R.dimen.play_button_height); mPlayButtonMarginTopStart = mFullHeight - mPlayButtonHeight - 16 * mDensity; mPlayButtonMarginTopTarget = mFirstTargetHeight - mPlayButtonHeight / 2; mPlayButtonPaddingRate = (mPlayButtonMarginTopStart - mPlayButtonMarginTopTarget) / scrollHeight; } @Override public void handleScroll() { int currentHeight = getHeaderHeight(); float newMargin = 0; float lastHeight = 0; float newTextSize; // 1. FM description (alpha and margin) float alpha = 0f; int offset = (int) ((mFirstTargetHeight - currentHeight) / mDensity);// dip if (offset <= 0) { alpha = 1f; } else if (offset <= 16) { alpha = 1 - offset / 16f; } mFmDescriptionText.setAlpha(alpha); newMargin = getNewSize(currentHeight, mTargetHeight, mFmDescriptionMarginTopTarget, mFmDescriptionPaddingRate); lastHeight = setNewPadding(mFmDescriptionText, newMargin); // 2. frequency text (text size and margin) newTextSize = getNewSize(currentHeight, mTargetHeight, mFrequencyTextSizeTarget, mFrequencyTextSizeRate); mFrequencyText.setTextSize(newTextSize / mDensity); newMargin = getNewSize(currentHeight, mTargetHeight, mFrequencyMarginTopTarget, mFrequencyPaddingRate); lastHeight = setNewPadding(mFrequencyText, newMargin + lastHeight); // If frequency text move to action bar, change it to bold setNewTypefaceForFrequencyText(); // 3. station name (text size and margin) newTextSize = getNewSize(currentHeight, mTargetHeight, mStationNameTextSizeTarget, mStationNameTextSizeRate); mStationNameText.setTextSize(newTextSize / mDensity); newMargin = getNewSize(currentHeight, mTargetHeight, mStationNameMarginTopTarget, mStationNamePaddingRate); // if move to target position, need not move over the edge of actionbar if (lastHeight <= mActionBarHeight) { lastHeight = mActionBarHeight; } lastHeight = setNewPadding(mStationNameText, newMargin + lastHeight); // 4. station rds (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mStationRdsMarginTopTarget, mStationRdsPaddingRate); lastHeight = setNewPadding(mStationRdsText, newMargin + lastHeight); // 5. control buttons (margin) newMargin = getNewSize(currentHeight, mTargetHeight, mControlViewMarginTopTarget, mControlViewPaddingRate); setNewPadding(mControlView, newMargin + lastHeight); // 6. stop button (padding), it different to others, padding top refer to parent newMargin = currentHeight - mPlayButtonHeight / 2; setNewPadding(mPlayButtonView, newMargin); } } private void setNewTypefaceForFrequencyText() { boolean needBold = (mSecondTargetHeight == getHeaderHeight()); mFrequencyText.setTypeface(needBold ? Typeface.SANS_SERIF : mDefaultFrequencyTypeface); } private float setNewPadding(TextView current, float newMargin) { current.setPadding(current.getPaddingLeft(), (int) (newMargin), current.getPaddingRight(), current.getPaddingBottom()); float nextLayoutPadding = newMargin + current.getTextSize(); return nextLayoutPadding; } private void setNewPadding(View current, float newMargin) { float newPadding = newMargin; current.setPadding(current.getPaddingLeft(), (int) (newPadding), current.getPaddingRight(), current.getPaddingBottom()); } private float getNewSize(int currentHeight, int targetHeight, float targetSize, float rate) { if (currentHeight == targetHeight) { return targetSize; } return targetSize + (currentHeight - targetHeight) * rate; } } private final class ViewHolder { ImageView mMoreButton; FmVisualizerView mPlayIndicator; TextView mStationFreq; TextView mStationName; View mPopupMenuAnchor; } }