983 lines
37 KiB
Java
983 lines
37 KiB
Java
/*
|
|
This file is part of Subsonic.
|
|
Subsonic is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
Subsonic is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
|
along with Subsonic. If not, see <http://www.gnu.org/licenses/>.
|
|
Copyright 2014 (C) Scott Jackson
|
|
*/
|
|
package net.nullsum.audinaut.fragments;
|
|
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.support.v7.widget.LinearLayoutManager;
|
|
import android.support.v7.widget.RecyclerView;
|
|
import android.support.v7.widget.helper.ItemTouchHelper;
|
|
import android.view.Display;
|
|
import android.view.GestureDetector;
|
|
import android.view.GestureDetector.OnGestureListener;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.WindowManager;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.widget.ImageButton;
|
|
import android.widget.ImageView;
|
|
import android.widget.SeekBar;
|
|
import android.widget.TextView;
|
|
import android.widget.ViewFlipper;
|
|
|
|
import net.nullsum.audinaut.R;
|
|
import net.nullsum.audinaut.activity.SubsonicFragmentActivity;
|
|
import net.nullsum.audinaut.adapter.DownloadFileAdapter;
|
|
import net.nullsum.audinaut.adapter.SectionAdapter;
|
|
import net.nullsum.audinaut.audiofx.EqualizerController;
|
|
import net.nullsum.audinaut.domain.PlayerState;
|
|
import net.nullsum.audinaut.domain.RepeatMode;
|
|
import net.nullsum.audinaut.service.DownloadFile;
|
|
import net.nullsum.audinaut.service.DownloadService;
|
|
import net.nullsum.audinaut.service.DownloadService.OnSongChangedListener;
|
|
import net.nullsum.audinaut.util.Constants;
|
|
import net.nullsum.audinaut.util.DownloadFileItemHelperCallback;
|
|
import net.nullsum.audinaut.util.DrawableTint;
|
|
import net.nullsum.audinaut.util.FileUtil;
|
|
import net.nullsum.audinaut.util.MenuUtil;
|
|
import net.nullsum.audinaut.util.SilentBackgroundTask;
|
|
import net.nullsum.audinaut.util.Util;
|
|
import net.nullsum.audinaut.view.AutoRepeatButton;
|
|
import net.nullsum.audinaut.view.FadeOutAnimation;
|
|
import net.nullsum.audinaut.view.FastScroller;
|
|
import net.nullsum.audinaut.view.UpdateView;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.ScheduledExecutorService;
|
|
import java.util.concurrent.ScheduledFuture;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import static net.nullsum.audinaut.domain.MusicDirectory.Entry;
|
|
import static net.nullsum.audinaut.domain.PlayerState.COMPLETED;
|
|
import static net.nullsum.audinaut.domain.PlayerState.IDLE;
|
|
import static net.nullsum.audinaut.domain.PlayerState.PAUSED;
|
|
import static net.nullsum.audinaut.domain.PlayerState.STOPPED;
|
|
|
|
public class NowPlayingFragment extends SubsonicFragment implements OnGestureListener, SectionAdapter.OnItemClickedListener<DownloadFile>, OnSongChangedListener {
|
|
private static final int PERCENTAGE_OF_SCREEN_FOR_SWIPE = 10;
|
|
|
|
private static final int ACTION_PREVIOUS = 1;
|
|
private static final int ACTION_NEXT = 2;
|
|
private static final int ACTION_REWIND = 3;
|
|
private static final int ACTION_FORWARD = 4;
|
|
|
|
private ViewFlipper playlistFlipper;
|
|
private TextView emptyTextView;
|
|
private TextView songTitleTextView;
|
|
private ImageView albumArtImageView;
|
|
private RecyclerView playlistView;
|
|
private TextView positionTextView;
|
|
private TextView durationTextView;
|
|
private TextView statusTextView;
|
|
private SeekBar progressBar;
|
|
private AutoRepeatButton previousButton;
|
|
private AutoRepeatButton nextButton;
|
|
private AutoRepeatButton rewindButton;
|
|
private AutoRepeatButton fastforwardButton;
|
|
private View pauseButton;
|
|
private View stopButton;
|
|
private View startButton;
|
|
private ImageButton repeatButton;
|
|
private View toggleListButton;
|
|
|
|
private ScheduledExecutorService executorService;
|
|
private DownloadFile currentPlaying;
|
|
private int swipeDistance;
|
|
private int swipeVelocity;
|
|
private ScheduledFuture<?> hideControlsFuture;
|
|
private List<DownloadFile> songList;
|
|
private DownloadFileAdapter songListAdapter;
|
|
private boolean seekInProgress = false;
|
|
private boolean startFlipped = false;
|
|
private boolean scrollWhenLoaded = false;
|
|
private int lastY = 0;
|
|
private int currentPlayingSize = 0;
|
|
|
|
/**
|
|
* Called when the activity is first created.
|
|
*/
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
if (savedInstanceState != null) {
|
|
if (savedInstanceState.getInt(Constants.FRAGMENT_DOWNLOAD_FLIPPER) == 1) {
|
|
startFlipped = true;
|
|
}
|
|
}
|
|
primaryFragment = false;
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
outState.putInt(Constants.FRAGMENT_DOWNLOAD_FLIPPER, playlistFlipper.getDisplayedChild());
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle bundle) {
|
|
rootView = inflater.inflate(R.layout.download, container, false);
|
|
setTitle(R.string.button_bar_now_playing);
|
|
|
|
WindowManager w = context.getWindowManager();
|
|
Display d = w.getDefaultDisplay();
|
|
swipeDistance = (d.getWidth() + d.getHeight()) * PERCENTAGE_OF_SCREEN_FOR_SWIPE / 100;
|
|
swipeVelocity = (d.getWidth() + d.getHeight()) * PERCENTAGE_OF_SCREEN_FOR_SWIPE / 100;
|
|
gestureScanner = new GestureDetector(context, this);
|
|
|
|
playlistFlipper = rootView.findViewById(R.id.download_playlist_flipper);
|
|
emptyTextView = rootView.findViewById(R.id.download_empty);
|
|
songTitleTextView = rootView.findViewById(R.id.download_song_title);
|
|
albumArtImageView = rootView.findViewById(R.id.download_album_art_image);
|
|
positionTextView = rootView.findViewById(R.id.download_position);
|
|
durationTextView = rootView.findViewById(R.id.download_duration);
|
|
statusTextView = rootView.findViewById(R.id.download_status);
|
|
progressBar = rootView.findViewById(R.id.download_progress_bar);
|
|
previousButton = rootView.findViewById(R.id.download_previous);
|
|
nextButton = rootView.findViewById(R.id.download_next);
|
|
rewindButton = rootView.findViewById(R.id.download_rewind);
|
|
fastforwardButton = rootView.findViewById(R.id.download_fastforward);
|
|
pauseButton = rootView.findViewById(R.id.download_pause);
|
|
stopButton = rootView.findViewById(R.id.download_stop);
|
|
startButton = rootView.findViewById(R.id.download_start);
|
|
repeatButton = rootView.findViewById(R.id.download_repeat);
|
|
toggleListButton = rootView.findViewById(R.id.download_toggle_list);
|
|
|
|
playlistView = rootView.findViewById(R.id.download_list);
|
|
FastScroller fastScroller = rootView.findViewById(R.id.download_fast_scroller);
|
|
fastScroller.attachRecyclerView(playlistView);
|
|
setupLayoutManager(playlistView, false);
|
|
ItemTouchHelper touchHelper = new ItemTouchHelper(new DownloadFileItemHelperCallback(this, true));
|
|
touchHelper.attachToRecyclerView(playlistView);
|
|
|
|
View.OnTouchListener touchListener = (v, me) -> gestureScanner.onTouchEvent(me);
|
|
pauseButton.setOnTouchListener(touchListener);
|
|
stopButton.setOnTouchListener(touchListener);
|
|
startButton.setOnTouchListener(touchListener);
|
|
emptyTextView.setOnTouchListener(touchListener);
|
|
albumArtImageView.setOnTouchListener((v, me) -> {
|
|
if (me.getAction() == MotionEvent.ACTION_DOWN) {
|
|
lastY = (int) me.getRawY();
|
|
}
|
|
return gestureScanner.onTouchEvent(me);
|
|
});
|
|
|
|
previousButton.setOnClickListener(view -> {
|
|
warnIfStorageUnavailable();
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().previous();
|
|
return null;
|
|
}
|
|
}.execute();
|
|
setControlsVisible(true);
|
|
});
|
|
previousButton.setOnRepeatListener(() -> changeProgress(true));
|
|
|
|
nextButton.setOnClickListener(view -> {
|
|
warnIfStorageUnavailable();
|
|
new SilentBackgroundTask<Boolean>(context) {
|
|
@Override
|
|
protected Boolean doInBackground() throws Throwable {
|
|
getDownloadService().next();
|
|
return true;
|
|
}
|
|
}.execute();
|
|
setControlsVisible(true);
|
|
});
|
|
nextButton.setOnRepeatListener(() -> changeProgress(false));
|
|
|
|
rewindButton.setOnClickListener(view -> changeProgress(true));
|
|
rewindButton.setOnRepeatListener(() -> changeProgress(true));
|
|
|
|
fastforwardButton.setOnClickListener(view -> changeProgress(false));
|
|
fastforwardButton.setOnRepeatListener(() -> changeProgress(false));
|
|
|
|
|
|
pauseButton.setOnClickListener(view -> new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().pause();
|
|
return null;
|
|
}
|
|
}.execute());
|
|
|
|
stopButton.setOnClickListener(view -> new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().reset();
|
|
return null;
|
|
}
|
|
}.execute());
|
|
|
|
startButton.setOnClickListener(view -> {
|
|
warnIfStorageUnavailable();
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
start();
|
|
return null;
|
|
}
|
|
}.execute();
|
|
});
|
|
|
|
repeatButton.setOnClickListener(view -> {
|
|
RepeatMode repeatMode = getDownloadService().getRepeatMode().next();
|
|
getDownloadService().setRepeatMode(repeatMode);
|
|
switch (repeatMode) {
|
|
case OFF:
|
|
Util.toast(context, R.string.download_repeat_off);
|
|
break;
|
|
case ALL:
|
|
Util.toast(context, R.string.download_repeat_all);
|
|
break;
|
|
case SINGLE:
|
|
Util.toast(context, R.string.download_repeat_single);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
updateRepeatButton();
|
|
setControlsVisible(true);
|
|
});
|
|
|
|
toggleListButton.setOnClickListener(view -> {
|
|
toggleFullscreenAlbumArt();
|
|
setControlsVisible(true);
|
|
});
|
|
|
|
View overlay = rootView.findViewById(R.id.download_overlay_buttons);
|
|
final int overlayHeight = overlay != null ? overlay.getHeight() : -1;
|
|
albumArtImageView.setOnClickListener(view -> {
|
|
if (overlayHeight == -1 || lastY < (view.getBottom() - overlayHeight)) {
|
|
toggleFullscreenAlbumArt();
|
|
setControlsVisible(true);
|
|
}
|
|
});
|
|
|
|
progressBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
|
|
@Override
|
|
public void onStopTrackingTouch(final SeekBar seekBar) {
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().seekTo(progressBar.getProgress());
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void done(Void result) {
|
|
seekInProgress = false;
|
|
}
|
|
}.execute();
|
|
}
|
|
|
|
@Override
|
|
public void onStartTrackingTouch(final SeekBar seekBar) {
|
|
seekInProgress = true;
|
|
}
|
|
|
|
@Override
|
|
public void onProgressChanged(final SeekBar seekBar, final int position, final boolean fromUser) {
|
|
if (fromUser) {
|
|
positionTextView.setText(Util.formatDuration(position / 1000));
|
|
setControlsVisible(true);
|
|
}
|
|
}
|
|
});
|
|
|
|
return rootView;
|
|
}
|
|
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
|
|
DownloadService downloadService = getDownloadService();
|
|
if (Util.isOffline(context)) {
|
|
menuInflater.inflate(R.menu.nowplaying_offline, menu);
|
|
} else {
|
|
menuInflater.inflate(R.menu.nowplaying, menu);
|
|
}
|
|
if (downloadService != null && downloadService.isRemovePlayed()) {
|
|
menu.findItem(R.id.menu_remove_played).setChecked(true);
|
|
}
|
|
|
|
if (downloadService != null) {
|
|
SharedPreferences prefs = Util.getPreferences(context);
|
|
boolean equalizerOn = prefs.getBoolean(Constants.PREFERENCES_EQUALIZER_ON, false);
|
|
if (equalizerOn && downloadService != null) {
|
|
if (downloadService.getEqualizerController() != null && downloadService.getEqualizerController().isEnabled()) {
|
|
menu.findItem(R.id.menu_equalizer).setChecked(true);
|
|
}
|
|
}
|
|
} else {
|
|
menu.removeItem(R.id.menu_equalizer);
|
|
}
|
|
|
|
if (Util.getPreferences(context).getBoolean(Constants.PREFERENCES_KEY_BATCH_MODE, false)) {
|
|
menu.findItem(R.id.menu_batch_mode).setChecked(true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem menuItem) {
|
|
return menuItemSelected(menuItem.getItemId(), null) || super.onOptionsItemSelected(menuItem);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onCreateContextMenu(Menu menu, MenuInflater menuInflater, UpdateView<DownloadFile> updateView, DownloadFile downloadFile) {
|
|
if (Util.isOffline(context)) {
|
|
menuInflater.inflate(R.menu.nowplaying_context_offline, menu);
|
|
} else {
|
|
menuInflater.inflate(R.menu.nowplaying_context, menu);
|
|
}
|
|
|
|
if (downloadFile.getSong().getParent() == null) {
|
|
menu.findItem(R.id.menu_show_album).setVisible(false);
|
|
menu.findItem(R.id.menu_show_artist).setVisible(false);
|
|
}
|
|
|
|
MenuUtil.hideMenuItems(context, menu, updateView);
|
|
}
|
|
|
|
@Override
|
|
public boolean onContextItemSelected(MenuItem menuItem, UpdateView<DownloadFile> updateView, DownloadFile downloadFile) {
|
|
return onContextItemSelected(menuItem, downloadFile.getSong()) || menuItemSelected(menuItem.getItemId(), downloadFile);
|
|
|
|
}
|
|
|
|
private boolean menuItemSelected(int menuItemId, final DownloadFile song) {
|
|
switch (menuItemId) {
|
|
case R.id.menu_show_album:
|
|
case R.id.menu_show_artist:
|
|
Entry entry = song.getSong();
|
|
|
|
Intent intent = new Intent(context, SubsonicFragmentActivity.class);
|
|
intent.putExtra(Constants.INTENT_EXTRA_VIEW_ALBUM, true);
|
|
String albumId;
|
|
String albumName;
|
|
if (menuItemId == R.id.menu_show_album) {
|
|
albumId = entry.getAlbumId();
|
|
albumName = entry.getAlbum();
|
|
} else {
|
|
albumId = entry.getArtistId();
|
|
albumName = entry.getArtist();
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_ARTIST, true);
|
|
}
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_ID, albumId);
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_NAME, albumName);
|
|
intent.putExtra(Constants.INTENT_EXTRA_FRAGMENT_TYPE, "Artist");
|
|
|
|
if (Util.isOffline(context)) {
|
|
try {
|
|
// This should only be successful if this is a online song in offline mode
|
|
Integer.parseInt(entry.getParent());
|
|
String root = FileUtil.getMusicDirectory(context).getPath();
|
|
String id = root + "/" + entry.getPath();
|
|
id = id.substring(0, id.lastIndexOf("/"));
|
|
if (menuItemId == R.id.menu_show_album) {
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_ID, id);
|
|
}
|
|
id = id.substring(0, id.lastIndexOf("/"));
|
|
if (menuItemId != R.id.menu_show_album) {
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_ID, id);
|
|
intent.putExtra(Constants.INTENT_EXTRA_NAME_NAME, entry.getArtist());
|
|
intent.removeExtra(Constants.INTENT_EXTRA_NAME_CHILD_ID);
|
|
}
|
|
} catch (Exception e) {
|
|
// Do nothing, entry.getParent() is fine
|
|
}
|
|
}
|
|
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
|
|
Util.startActivityWithoutTransition(context, intent);
|
|
return true;
|
|
case R.id.menu_remove_all:
|
|
Util.confirmDialog(context, R.string.download_menu_remove_all, "", (dialog, which) -> new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().setShufflePlayEnabled(false);
|
|
getDownloadService().clear();
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void done(Void result) {
|
|
context.closeNowPlaying();
|
|
}
|
|
}.execute());
|
|
return true;
|
|
case R.id.menu_remove_played:
|
|
if (getDownloadService().isRemovePlayed()) {
|
|
getDownloadService().setRemovePlayed(false);
|
|
} else {
|
|
getDownloadService().setRemovePlayed(true);
|
|
}
|
|
context.supportInvalidateOptionsMenu();
|
|
return true;
|
|
case R.id.menu_shuffle:
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().shuffle();
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void done(Void result) {
|
|
Util.toast(context, R.string.download_menu_shuffle_notification);
|
|
}
|
|
}.execute();
|
|
return true;
|
|
case R.id.menu_save_playlist:
|
|
List<Entry> entries = new LinkedList<>();
|
|
for (DownloadFile downloadFile : getDownloadService().getSongs()) {
|
|
entries.add(downloadFile.getSong());
|
|
}
|
|
createNewPlaylist(entries, true);
|
|
return true;
|
|
case R.id.menu_info:
|
|
displaySongInfo(song.getSong());
|
|
return true;
|
|
case R.id.menu_equalizer: {
|
|
DownloadService downloadService = getDownloadService();
|
|
if (downloadService != null) {
|
|
EqualizerController controller = downloadService.getEqualizerController();
|
|
if (controller != null) {
|
|
SubsonicFragment fragment = new EqualizerFragment();
|
|
replaceFragment(fragment);
|
|
setControlsVisible(true);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Any failed condition will get here
|
|
Util.toast(context, "Failed to start equalizer. Try restarting.");
|
|
return true;
|
|
}
|
|
case R.id.menu_batch_mode:
|
|
if (Util.isBatchMode(context)) {
|
|
Util.setBatchMode(context, false);
|
|
songListAdapter.notifyDataSetChanged();
|
|
} else {
|
|
Util.setBatchMode(context, true);
|
|
songListAdapter.notifyDataSetChanged();
|
|
}
|
|
context.supportInvalidateOptionsMenu();
|
|
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
if (this.primaryFragment) {
|
|
onResumeHandlers();
|
|
} else {
|
|
update();
|
|
}
|
|
}
|
|
|
|
private void onResumeHandlers() {
|
|
executorService = Executors.newSingleThreadScheduledExecutor();
|
|
setControlsVisible(true);
|
|
|
|
final DownloadService downloadService = getDownloadService();
|
|
if (downloadService == null || downloadService.getCurrentPlaying() == null || startFlipped) {
|
|
playlistFlipper.setDisplayedChild(1);
|
|
startFlipped = false;
|
|
}
|
|
|
|
if (currentPlaying == null && downloadService != null && currentPlaying == downloadService.getCurrentPlaying()) {
|
|
getImageLoader().loadImage(albumArtImageView, null, true, false);
|
|
}
|
|
|
|
context.runWhenServiceAvailable(() -> {
|
|
if (primaryFragment) {
|
|
DownloadService downloadService1 = getDownloadService();
|
|
downloadService1.addOnSongChangedListener(NowPlayingFragment.this);
|
|
}
|
|
updateRepeatButton();
|
|
updateTitle();
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
super.onPause();
|
|
onPauseHandlers();
|
|
}
|
|
|
|
private void onPauseHandlers() {
|
|
if (executorService != null) {
|
|
DownloadService downloadService = getDownloadService();
|
|
if (downloadService != null) {
|
|
downloadService.removeOnSongChangeListener(this);
|
|
}
|
|
playlistFlipper.setDisplayedChild(0);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setPrimaryFragment(boolean primary) {
|
|
super.setPrimaryFragment(primary);
|
|
if (rootView != null) {
|
|
if (primary) {
|
|
onResumeHandlers();
|
|
} else {
|
|
onPauseHandlers();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void setTitle(int title) {
|
|
this.title = context.getResources().getString(title);
|
|
if (this.primaryFragment) {
|
|
context.setTitle(this.title);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void setSubtitle(CharSequence title) {
|
|
this.subtitle = title;
|
|
if (this.primaryFragment) {
|
|
context.setSubtitle(title);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public SectionAdapter getCurrentAdapter() {
|
|
return songListAdapter;
|
|
}
|
|
|
|
private void scheduleHideControls() {
|
|
if (hideControlsFuture != null) {
|
|
hideControlsFuture.cancel(false);
|
|
}
|
|
|
|
final Handler handler = new Handler();
|
|
Runnable runnable = () -> handler.post(() -> setControlsVisible(false));
|
|
hideControlsFuture = executorService.schedule(runnable, 3000L, TimeUnit.MILLISECONDS);
|
|
}
|
|
|
|
private void setControlsVisible(boolean visible) {
|
|
try {
|
|
long duration = 1700L;
|
|
FadeOutAnimation.createAndStart(rootView.findViewById(R.id.download_overlay_buttons), !visible, duration);
|
|
|
|
if (visible) {
|
|
scheduleHideControls();
|
|
}
|
|
} catch (Exception ignored) {
|
|
|
|
}
|
|
}
|
|
|
|
// Scroll to current playing/downloading.
|
|
private void scrollToCurrent() {
|
|
if (getDownloadService() == null || songListAdapter == null) {
|
|
scrollWhenLoaded = true;
|
|
return;
|
|
}
|
|
|
|
// Try to get position of current playing/downloading
|
|
int position = songListAdapter.getItemPosition(currentPlaying);
|
|
if (position == -1) {
|
|
DownloadFile currentDownloading = getDownloadService().getCurrentDownloading();
|
|
position = songListAdapter.getItemPosition(currentDownloading);
|
|
}
|
|
|
|
// If found, scroll to it
|
|
if (position != -1) {
|
|
// RecyclerView.scrollToPosition just puts it on the screen (ie: bottom if scrolled below it)
|
|
LinearLayoutManager layoutManager = (LinearLayoutManager) playlistView.getLayoutManager();
|
|
layoutManager.scrollToPositionWithOffset(position, 0);
|
|
}
|
|
}
|
|
|
|
private void update() {
|
|
if (startFlipped) {
|
|
startFlipped = false;
|
|
scrollToCurrent();
|
|
}
|
|
}
|
|
|
|
private void toggleFullscreenAlbumArt() {
|
|
if (playlistFlipper.getDisplayedChild() == 1) {
|
|
playlistFlipper.setInAnimation(AnimationUtils.loadAnimation(context, R.anim.push_down_in));
|
|
playlistFlipper.setOutAnimation(AnimationUtils.loadAnimation(context, R.anim.push_down_out));
|
|
playlistFlipper.setDisplayedChild(0);
|
|
} else {
|
|
scrollToCurrent();
|
|
playlistFlipper.setInAnimation(AnimationUtils.loadAnimation(context, R.anim.push_up_in));
|
|
playlistFlipper.setOutAnimation(AnimationUtils.loadAnimation(context, R.anim.push_up_out));
|
|
playlistFlipper.setDisplayedChild(1);
|
|
|
|
UpdateView.triggerUpdate();
|
|
}
|
|
}
|
|
|
|
private void start() {
|
|
DownloadService service = getDownloadService();
|
|
PlayerState state = service.getPlayerState();
|
|
if (state == PAUSED || state == COMPLETED || state == STOPPED) {
|
|
service.start();
|
|
} else if (state == STOPPED || state == IDLE) {
|
|
warnIfStorageUnavailable();
|
|
int current = service.getCurrentPlayingIndex();
|
|
// TODO: Use play() method.
|
|
if (current == -1) {
|
|
service.play(0);
|
|
} else {
|
|
service.play(current);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void changeProgress(final boolean rewind) {
|
|
final DownloadService downloadService = getDownloadService();
|
|
if (downloadService == null) {
|
|
return;
|
|
}
|
|
|
|
new SilentBackgroundTask<Void>(context) {
|
|
int seekTo;
|
|
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
if (rewind) {
|
|
seekTo = downloadService.rewind();
|
|
} else {
|
|
seekTo = downloadService.fastForward();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void done(Void result) {
|
|
progressBar.setProgress(seekTo);
|
|
}
|
|
}.execute();
|
|
}
|
|
|
|
@Override
|
|
public boolean onDown(MotionEvent me) {
|
|
setControlsVisible(true);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
|
|
final DownloadService downloadService = getDownloadService();
|
|
if (downloadService == null || e1 == null || e2 == null) {
|
|
return false;
|
|
}
|
|
|
|
// Right to Left swipe
|
|
int action = 0;
|
|
if (e1.getX() - e2.getX() > swipeDistance && Math.abs(velocityX) > swipeVelocity) {
|
|
action = ACTION_NEXT;
|
|
}
|
|
// Left to Right swipe
|
|
else if (e2.getX() - e1.getX() > swipeDistance && Math.abs(velocityX) > swipeVelocity) {
|
|
action = ACTION_PREVIOUS;
|
|
}
|
|
// Top to Bottom swipe
|
|
else if (e2.getY() - e1.getY() > swipeDistance && Math.abs(velocityY) > swipeVelocity) {
|
|
action = ACTION_FORWARD;
|
|
}
|
|
// Bottom to Top swipe
|
|
else if (e1.getY() - e2.getY() > swipeDistance && Math.abs(velocityY) > swipeVelocity) {
|
|
action = ACTION_REWIND;
|
|
}
|
|
|
|
if (action > 0) {
|
|
final int performAction = action;
|
|
warnIfStorageUnavailable();
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
switch (performAction) {
|
|
case ACTION_NEXT:
|
|
downloadService.next();
|
|
break;
|
|
case ACTION_PREVIOUS:
|
|
downloadService.previous();
|
|
break;
|
|
case ACTION_FORWARD:
|
|
downloadService.seekTo(downloadService.getPlayerPosition() + DownloadService.FAST_FORWARD);
|
|
break;
|
|
case ACTION_REWIND:
|
|
downloadService.seekTo(downloadService.getPlayerPosition() - DownloadService.REWIND);
|
|
break;
|
|
}
|
|
return null;
|
|
}
|
|
}.execute();
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onLongPress(MotionEvent e) {
|
|
}
|
|
|
|
@Override
|
|
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onShowPress(MotionEvent e) {
|
|
}
|
|
|
|
@Override
|
|
public boolean onSingleTapUp(MotionEvent e) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onItemClicked(UpdateView<DownloadFile> updateView, final DownloadFile item) {
|
|
warnIfStorageUnavailable();
|
|
new SilentBackgroundTask<Void>(context) {
|
|
@Override
|
|
protected Void doInBackground() throws Throwable {
|
|
getDownloadService().play(item);
|
|
return null;
|
|
}
|
|
}.execute();
|
|
}
|
|
|
|
@Override
|
|
public void onSongChanged(DownloadFile currentPlaying, int currentPlayingIndex) {
|
|
this.currentPlaying = currentPlaying;
|
|
setupSubtitle(currentPlayingIndex);
|
|
|
|
if (currentPlaying != null && !currentPlaying.isSong()) {
|
|
previousButton.setVisibility(View.GONE);
|
|
nextButton.setVisibility(View.GONE);
|
|
|
|
rewindButton.setVisibility(View.VISIBLE);
|
|
fastforwardButton.setVisibility(View.VISIBLE);
|
|
} else {
|
|
previousButton.setVisibility(View.VISIBLE);
|
|
nextButton.setVisibility(View.VISIBLE);
|
|
|
|
rewindButton.setVisibility(View.GONE);
|
|
fastforwardButton.setVisibility(View.GONE);
|
|
}
|
|
updateTitle();
|
|
}
|
|
|
|
private void setupSubtitle(int currentPlayingIndex) {
|
|
if (currentPlaying != null) {
|
|
Entry song = currentPlaying.getSong();
|
|
songTitleTextView.setText(song.getTitle());
|
|
getImageLoader().loadImage(albumArtImageView, song, true, true);
|
|
|
|
DownloadService downloadService = getDownloadService();
|
|
if (downloadService.isShufflePlayEnabled()) {
|
|
setSubtitle(context.getResources().getString(R.string.download_playerstate_playing_shuffle));
|
|
} else {
|
|
setSubtitle(context.getResources().getString(R.string.download_playing_out_of, currentPlayingIndex + 1, currentPlayingSize));
|
|
}
|
|
} else {
|
|
songTitleTextView.setText(null);
|
|
getImageLoader().loadImage(albumArtImageView, null, true, false);
|
|
setSubtitle(null);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSongsChanged(List<DownloadFile> songs, DownloadFile currentPlaying, int currentPlayingIndex) {
|
|
currentPlayingSize = songs.size();
|
|
|
|
DownloadService downloadService = getDownloadService();
|
|
if (downloadService.isShufflePlayEnabled()) {
|
|
emptyTextView.setText(R.string.download_shuffle_loading);
|
|
} else {
|
|
emptyTextView.setText(R.string.download_empty);
|
|
}
|
|
|
|
if (songListAdapter == null) {
|
|
songList = new ArrayList<>();
|
|
songList.addAll(songs);
|
|
playlistView.setAdapter(songListAdapter = new DownloadFileAdapter(context, songList, NowPlayingFragment.this));
|
|
} else {
|
|
songList.clear();
|
|
songList.addAll(songs);
|
|
songListAdapter.notifyDataSetChanged();
|
|
}
|
|
|
|
emptyTextView.setVisibility(songs.isEmpty() ? View.VISIBLE : View.GONE);
|
|
|
|
if (scrollWhenLoaded) {
|
|
scrollToCurrent();
|
|
scrollWhenLoaded = false;
|
|
}
|
|
|
|
if (this.currentPlaying != currentPlaying) {
|
|
onSongChanged(currentPlaying, currentPlayingIndex);
|
|
onMetadataUpdate(currentPlaying != null ? currentPlaying.getSong() : null, DownloadService.METADATA_UPDATED_ALL);
|
|
} else {
|
|
setupSubtitle(currentPlayingIndex);
|
|
}
|
|
|
|
toggleListButton.setVisibility(View.VISIBLE);
|
|
repeatButton.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
@Override
|
|
public void onSongProgress(DownloadFile currentPlaying, int millisPlayed, Integer duration, boolean isSeekable) {
|
|
if (currentPlaying != null) {
|
|
int millisTotal = duration == null ? 0 : duration;
|
|
|
|
positionTextView.setText(Util.formatDuration(millisPlayed / 1000));
|
|
if (millisTotal > 0) {
|
|
durationTextView.setText(Util.formatDuration(millisTotal / 1000));
|
|
} else {
|
|
durationTextView.setText("-:--");
|
|
}
|
|
progressBar.setMax(millisTotal == 0 ? 100 : millisTotal); // Work-around for apparent bug.
|
|
if (!seekInProgress) {
|
|
progressBar.setProgress(millisPlayed);
|
|
}
|
|
progressBar.setEnabled(isSeekable);
|
|
} else {
|
|
positionTextView.setText("0:00");
|
|
durationTextView.setText("-:--");
|
|
progressBar.setProgress(0);
|
|
progressBar.setEnabled(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStateUpdate(PlayerState playerState) {
|
|
switch (playerState) {
|
|
case DOWNLOADING:
|
|
if (currentPlaying != null) {
|
|
if (Util.isWifiRequiredForDownload(context)) {
|
|
statusTextView.setText(context.getResources().getString(R.string.download_playerstate_mobile_disabled));
|
|
} else {
|
|
long bytes = currentPlaying.getPartialFile().length();
|
|
statusTextView.setText(context.getResources().getString(R.string.download_playerstate_downloading, Util.formatLocalizedBytes(bytes, context)));
|
|
}
|
|
}
|
|
break;
|
|
case PREPARING:
|
|
statusTextView.setText(R.string.download_playerstate_buffering);
|
|
break;
|
|
default:
|
|
if (currentPlaying != null) {
|
|
Entry entry = currentPlaying.getSong();
|
|
if (entry.getAlbum() != null) {
|
|
String artist = "";
|
|
if (entry.getArtist() != null) {
|
|
artist = currentPlaying.getSong().getArtist().trim() + " - ";
|
|
}
|
|
statusTextView.setText(artist + entry.getAlbum().trim());
|
|
} else {
|
|
statusTextView.setText(null);
|
|
}
|
|
} else {
|
|
statusTextView.setText(null);
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (playerState) {
|
|
case STARTED:
|
|
pauseButton.setVisibility(View.VISIBLE);
|
|
stopButton.setVisibility(View.INVISIBLE);
|
|
startButton.setVisibility(View.INVISIBLE);
|
|
break;
|
|
case DOWNLOADING:
|
|
case PREPARING:
|
|
pauseButton.setVisibility(View.INVISIBLE);
|
|
stopButton.setVisibility(View.VISIBLE);
|
|
startButton.setVisibility(View.INVISIBLE);
|
|
break;
|
|
default:
|
|
pauseButton.setVisibility(View.INVISIBLE);
|
|
stopButton.setVisibility(View.INVISIBLE);
|
|
startButton.setVisibility(View.VISIBLE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onMetadataUpdate(Entry song, int fieldChange) {
|
|
if (song != null && albumArtImageView != null && fieldChange == DownloadService.METADATA_UPDATED_COVER_ART) {
|
|
getImageLoader().loadImage(albumArtImageView, song, true, true);
|
|
}
|
|
}
|
|
|
|
private void updateRepeatButton() {
|
|
DownloadService downloadService = getDownloadService();
|
|
switch (downloadService.getRepeatMode()) {
|
|
case OFF:
|
|
repeatButton.setImageResource(DrawableTint.getDrawableRes(context, R.attr.media_button_repeat_off));
|
|
break;
|
|
case ALL:
|
|
repeatButton.setImageResource(DrawableTint.getDrawableRes(context, R.attr.media_button_repeat_all));
|
|
break;
|
|
case SINGLE:
|
|
repeatButton.setImageResource(DrawableTint.getDrawableRes(context, R.attr.media_button_repeat_single));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void updateTitle() {
|
|
String title = context.getResources().getString(R.string.button_bar_now_playing);
|
|
|
|
setTitle(title);
|
|
}
|
|
|
|
@Override
|
|
protected List<Entry> getSelectedEntries() {
|
|
List<DownloadFile> selected = getCurrentAdapter().getSelected();
|
|
List<Entry> entries = new ArrayList<>();
|
|
|
|
for (DownloadFile downloadFile : selected) {
|
|
if (downloadFile.getSong() != null) {
|
|
entries.add(downloadFile.getSong());
|
|
}
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
}
|