private boolean mIsPaused = false;
- private boolean mFromTouch = false;
-
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
*/
private void initPlaybackControls() {
mPlayPauseProgressButton = (PlayPauseProgressButton)mRootView.findViewById(R.id.playPauseProgressButton);
+ mPlayPauseProgressButton.setDragEnabled(true);
mShuffleButton = (ShuffleButton)mRootView.findViewById(R.id.action_button_shuffle);
mRepeatButton = (RepeatButton)mRootView.findViewById(R.id.action_button_repeat);
mPreviousButton = (RepeatingImageButton)mRootView.findViewById(R.id.action_button_previous);
}
private void refreshCurrentTimeText(final long pos) {
- mCurrentTime.setText(MusicUtils.makeShortTimeString(getActivity(), pos / 1000));
+ if (mPlayPauseProgressButton.isDragging()) {
+ mCurrentTime.setText(MusicUtils.makeShortTimeString(getActivity(),
+ mPlayPauseProgressButton.getDragProgressInMs() / 1000));
+ } else {
+ mCurrentTime.setText(MusicUtils.makeShortTimeString(getActivity(), pos / 1000));
+ }
}
/* Used to update the current time string */
private long refreshCurrentTime() {
if (mService == null) {
- return 500;
+ return MusicUtils.UPDATE_FREQUENCY_MS;
}
try {
final long pos = MusicUtils.position();
if (pos >= 0 && MusicUtils.duration() > 0) {
refreshCurrentTimeText(pos);
- if (mFromTouch) {
- return 500;
+ if (mPlayPauseProgressButton.isDragging()) {
+ mCurrentTime.setVisibility(View.VISIBLE);
+ return MusicUtils.UPDATE_FREQUENCY_FAST_MS;
} else if (MusicUtils.isPlaying()) {
mCurrentTime.setVisibility(View.VISIBLE);
+
+ // calculate the number of milliseconds until the next full second,
+ // so the counter can be updated at just the right time
+ return Math.max(20, 1000 - pos % 1000);
} else {
// blink the counter
final int vis = mCurrentTime.getVisibility();
mCurrentTime.setVisibility(vis == View.INVISIBLE ? View.VISIBLE
: View.INVISIBLE);
- return 500;
}
} else {
mCurrentTime.setText("--:--");
}
-
- // calculate the number of milliseconds until the next full second,
- // so
- // the counter can be updated at just the right time
- final long remaining = 1000 - pos % 1000;
- if (remaining < 20) {
- return 20;
- }
-
- return remaining;
} catch (final Exception ignored) {
if (ignored.getMessage() != null) {
Log.e(TAG, ignored.getMessage());
}
}
- return 500;
+ return MusicUtils.UPDATE_FREQUENCY_MS;
}
/**
/*
-* Copyright (C) 2014 The CyanogenMod Project
+* Copyright (c) 2013, The Linux Foundation. All rights reserved.
+* Copyright (C) 2015 The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import android.content.Context;
import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
import android.widget.FrameLayout;
import android.widget.ProgressBar;
* updates while the activity/fragment is not visible
*/
public class PlayPauseProgressButton extends FrameLayout {
- private static final long UPDATE_FREQUENCY_MS = 500;
+ private static String TAG = PlayPauseProgressButton.class.getSimpleName();
+ private static boolean DEBUG = false;
+ private static final int REVOLUTION_IN_DEGREES = 360;
+ private static final int HALF_REVOLUTION_IN_DEGREES = REVOLUTION_IN_DEGREES / 2;
+
private ProgressBar mProgressBar;
private PlayPauseButton mPlayPauseButton;
private Runnable mUpdateProgress;
private boolean mPaused;
+ private final int mSmallDistance;
+ private float mDragPercentage = 0.0f;
+ private boolean mDragEnabled = false;
+ private boolean mDragging = false;
+ private float mDownAngle;
+ private float mDragAngle;
+ private float mDownX;
+ private float mDownY;
+ private int mWidth;
+ private long mCurrentSongDuration;
+ private long mCurrentSongProgress;
+
public PlayPauseProgressButton(Context context, AttributeSet attrs) {
super(context, attrs);
// set paused to false since we shouldn't be typically created while not visible
mPaused = false;
+
+ mSmallDistance = ViewConfiguration.get(context).getScaledTouchSlop();
}
@Override
setVisibility(GONE);
}
+ /**
+ * Sets whether the user can drag the progress in a circular motion to seek the track
+ */
+ public void setDragEnabled(boolean enabled) {
+ mDragEnabled = enabled;
+ }
+
+ /**
+ * @return true if the user is actively dragging to seek
+ */
+ public boolean isDragging() {
+ return mDragEnabled && mDragging;
+ }
+
+ /**
+ * @return how far the user has dragged in the track in ms
+ */
+ public long getDragProgressInMs() {
+ return (long)(mDragPercentage * mCurrentSongDuration);
+ }
+
@Override
public void setEnabled(boolean enabled) {
// if the enabled state isn't changed, quit
* Updates the state of the progress bar and the play pause button
*/
private void updateState() {
- final long duration = MusicUtils.duration();
-
- if (duration > 0) {
- final long pos = MusicUtils.position();
-
- int progress = (int) (mProgressBar.getMax() * pos / duration);
- mProgressBar.setProgress(progress);
- } else {
- // this is when there are no tracks loaded or some kind of error condition
- mProgressBar.setProgress(0);
+ mCurrentSongDuration = MusicUtils.duration();
+ mCurrentSongProgress = MusicUtils.position();
+
+ int progress = 0;
+ if (isDragging()) {
+ progress = (int) (mDragPercentage * mProgressBar.getMax());
+ } else if (mCurrentSongDuration > 0) {
+ progress = (int) (mProgressBar.getMax() * mCurrentSongProgress / mCurrentSongDuration);
}
+ mProgressBar.setProgress(progress);
mPlayPauseButton.updateState();
}
@Override
public void run() {
updateState();
- postDelayed(mUpdateProgress, UPDATE_FREQUENCY_MS);
+ postDelayed(mUpdateProgress, isDragging() ? MusicUtils.UPDATE_FREQUENCY_FAST_MS
+ : MusicUtils.UPDATE_FREQUENCY_MS);
}
};
}
removeCallbacks(mUpdateProgress);
// post ourselves as a delayed
- postDelayed(mUpdateProgress, UPDATE_FREQUENCY_MS);
+ post(mUpdateProgress);
}
/**
removeCallbacks(mUpdateProgress);
}
}
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldW, int oldH) {
+ mWidth = Math.min(w, h);
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ if (!mDragEnabled) {
+ return false;
+ }
+
+ return onTouchEvent(ev);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ final float x = event.getX();
+ final float y = event.getY();
+
+ if (!mDragEnabled || mCurrentSongDuration <= 0) {
+ return false;
+ }
+
+ switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ mDownX = event.getX();
+ mDownY = event.getY();
+ mDownAngle = angle(mDownX, mDownY);
+ mDragAngle = REVOLUTION_IN_DEGREES
+ * (mCurrentSongProgress / (float) mCurrentSongDuration);
+ mDragPercentage = mDragAngle / REVOLUTION_IN_DEGREES;
+ mDragging = false;
+ break;
+ case MotionEvent.ACTION_MOVE:
+ // if the user has moved a certain distance
+ if (Math.sqrt(Math.pow(event.getX() - mDownX, 2)
+ + Math.pow(event.getY() - mDownY, 2)) < mSmallDistance) {
+ return false;
+ }
+
+ // if we weren't previously dragging, immediately kick off an update to reflect
+ // the change faster
+ if (!mDragging) {
+ postUpdate();
+ }
+
+ mDragging = true;
+ getParent().requestDisallowInterceptTouchEvent(true);
+
+ // calculate the amount of angle we've moved
+ final float deltaAngle = getDelta(x, y);
+ mDragAngle = cropAngle(mDragAngle + deltaAngle);
+ mDragPercentage = mDragAngle / REVOLUTION_IN_DEGREES;
+
+ if (DEBUG) {
+ Log.d(TAG, "Delta Angle: " + deltaAngle + ", Target Angle: " + mDownAngle);
+ }
+
+ return true;
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_CANCEL:
+ // if we were dragging, seek to where we dragged to
+ if (mDragging) {
+ MusicUtils.seek((long)(mDragPercentage * mCurrentSongDuration));
+ }
+ mDragging = false;
+ default:
+ break;
+ }
+ return mDragging;
+ }
+
+ /**
+ * Crops the angle between 0 and 360 - if the angle is < 0, it will return 0, if it is more than
+ * 360 it will return 360
+ */
+ private static float cropAngle(float angle) {
+ return Math.min(REVOLUTION_IN_DEGREES, Math.max(0.0f, angle));
+ }
+
+ /**
+ * Wraps the angle between -180 and 180. This assumes that the passed in
+ * angle is >= -360 and <= 360
+ */
+ private static float wrapHalfRevolution(float angle) {
+ if (angle < -HALF_REVOLUTION_IN_DEGREES) {
+ return angle + REVOLUTION_IN_DEGREES;
+ } else if (angle > HALF_REVOLUTION_IN_DEGREES) {
+ return angle - REVOLUTION_IN_DEGREES;
+ }
+
+ return angle;
+ }
+
+ /**
+ * Gets the change in angle from the down angle and updates the down angle to the current angle
+ */
+ private float getDelta(float x, float y) {
+ float angle = angle(x, y);
+ float deltaAngle = wrapHalfRevolution(angle - mDownAngle);
+ mDownAngle = angle;
+ return deltaAngle;
+ }
+
+ /**
+ * Calculates the angle at the point passed in based on the center of the button
+ */
+ private float angle(float x, float y) {
+ float center = mWidth / 2.0f;
+ x -= center;
+ y -= center;
+
+ if (x == 0.0f) {
+ if (y > 0.0f) {
+ return 180.0f;
+ } else {
+ return 0.0f;
+ }
+ }
+
+ float angle = (float) (Math.atan(y / x) / Math.PI * 180.0);
+ if (x > 0.0f) {
+ angle += 90;
+ } else {
+ angle += 270;
+ }
+ return angle;
+ }
}
OSDN Git Service
