<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2012 Andrew Neal
Copyright (C) 2014 The CyanogenMod Project
+ Copyright (C) 2019 The LineageOS Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
limitations under the License.
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
package="org.lineageos.eleven"
android:versionCode="3"
- android:versionName="3.0">
+ android:versionName="3.0"
+ tools:ignore="GradleOverrides">
<uses-sdk
android:minSdkVersion="26"
<category android:name="android.intent.category.APP_MUSIC" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
- <intent-filter>
+ <intent-filter tools:ignore="AppLinkUrlError">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
- xmlns:app="http://schemas.android.com/apk/res/org.lineageos.eleven"
android:id="@+id/bottom_action_bar"
android:layout_width="match_parent"
android:layout_height="@dimen/bottom_action_bar_height"
partial scaled up values for different resolutions -->
<dimen name="divider_height">1px</dimen>
- <item name="letter_to_tile_ratio" type="dimen">53%</item>
+ <item name="letter_to_tile_ratio" type="fraction">53%</item>
<!-- Audio preview -->
<dimen name="preview_layout_height">125dp</dimen>
private String mLyrics;
- private ArrayList<MusicPlaybackTrack> mPlaylist = new ArrayList<MusicPlaybackTrack>(100);
+ private ArrayList<MusicPlaybackTrack> mPlaylist = new ArrayList<>(100);
private long[] mAutoShuffleList = null;
// Make sure we don't indefinitely hold the wake lock under any circumstances
mHeadsetHookWakeLock.acquire(10000);
- Message msg = mPlayerHandler.obtainMessage(HEADSET_HOOK_EVENT, Long.valueOf(timestamp));
+ Message msg = mPlayerHandler.obtainMessage(HEADSET_HOOK_EVENT, timestamp);
msg.sendToTarget();
}
position = mPlaylist.size();
}
- final ArrayList<MusicPlaybackTrack> arrayList = new ArrayList<MusicPlaybackTrack>(addlen);
+ final ArrayList<MusicPlaybackTrack> arrayList = new ArrayList<>(addlen);
for (int i = 0; i < list.length; i++) {
arrayList.add(new MusicPlaybackTrack(list[i], sourceId, sourceType, i));
}
// has been played
final int numHistory = mHistory.size();
for (int i = 0; i < numHistory; i++) {
- final int idx = mHistory.get(i).intValue();
+ final int idx = mHistory.get(i);
if (idx >= 0 && idx < numTracks) {
trackNumPlays[idx]++;
}
// how many tracks share that count
int minNumPlays = Integer.MAX_VALUE;
int numTracksWithMinNumPlays = 0;
- for (int i = 0; i < trackNumPlays.length; i++) {
+ for (final int trackNumPlay : trackNumPlays) {
// if we found a new track that has less number of plays, reset the counters
- if (trackNumPlays[i] < minNumPlays) {
- minNumPlays = trackNumPlays[i];
+ if (trackNumPlay < minNumPlays) {
+ minNumPlays = trackNumPlay;
numTracksWithMinNumPlays = 1;
- } else if (trackNumPlays[i] == minNumPlays) {
+ } else if (trackNumPlay == minNumPlays) {
// increment this track shares the # of tracks
numTracksWithMinNumPlays++;
}
musicIntent.setAction(what.replace(ELEVEN_PACKAGE_NAME, MUSIC_PACKAGE_NAME));
sendStickyBroadcast(musicIntent);
- if (what.equals(META_CHANGED)) {
- // Add the track to the recently played list.
- mRecentsCache.addSongId(getAudioId());
-
- mSongPlayCountCache.bumpSongCount(getAudioId());
- } else if (what.equals(QUEUE_CHANGED)) {
- saveQueue(true);
- if (isPlaying()) {
- // if we are in shuffle mode and our next track is still valid,
- // try to re-use the track
- // We need to reimplement the queue to prevent hacky solutions like this
- if (mNextPlayPos >= 0 && mNextPlayPos < mPlaylist.size()
- && getShuffleMode() != SHUFFLE_NONE) {
- setNextTrack(mNextPlayPos);
- } else {
- setNextTrack();
+ switch (what) {
+ case META_CHANGED:
+ // Add the track to the recently played list.
+ mRecentsCache.addSongId(getAudioId());
+
+ mSongPlayCountCache.bumpSongCount(getAudioId());
+ break;
+ case QUEUE_CHANGED:
+ saveQueue(true);
+ if (isPlaying()) {
+ // if we are in shuffle mode and our next track is still valid,
+ // try to re-use the track
+ // We need to reimplement the queue to prevent hacky solutions like this
+ if (mNextPlayPos >= 0 && mNextPlayPos < mPlaylist.size()
+ && getShuffleMode() != SHUFFLE_NONE) {
+ setNextTrack(mNextPlayPos);
+ } else {
+ setNextTrack();
+ }
}
- }
- } else {
- saveQueue(false);
+ break;
+ default:
+ saveQueue(false);
+ break;
}
if (what.equals(PLAYSTATE_CHANGED)) {
*/
private String getValueForDownloadedFile(Context context, Uri uri, String column) {
- Cursor cursor = null;
final String[] projection = {
column
};
-
- try {
- cursor = context.getContentResolver().query(uri, projection, null, null, null);
+ try (Cursor cursor = context.getContentResolver().query(uri, projection, null, null, null)) {
if (cursor != null && cursor.moveToFirst()) {
return cursor.getString(0);
}
- } finally {
- if (cursor != null) {
- cursor.close();
- }
}
return null;
}
if (removeFromHistory) {
mHistory.remove(histsize - 1);
}
- return pos.intValue();
+ return pos;
} else {
if (mPlayPos > 0) {
return mPlayPos - 1;
*/
public MusicPlayerHandler(final MusicPlaybackService service, final Looper looper) {
super(looper);
- mService = new WeakReference<MusicPlaybackService>(service);
+ mService = new WeakReference<>(service);
}
/**
private static final class Shuffler {
- private final LinkedList<Integer> mHistoryOfNumbers = new LinkedList<Integer>();
+ private final LinkedList<Integer> mHistoryOfNumbers = new LinkedList<>();
- private final TreeSet<Integer> mPreviousNumbers = new TreeSet<Integer>();
+ private final TreeSet<Integer> mPreviousNumbers = new TreeSet<>();
private final Random mRandom = new Random();
int next;
do {
next = mRandom.nextInt(interval);
- } while (next == mPrevious && interval > 1
- && !mPreviousNumbers.contains(Integer.valueOf(next)));
+ } while (next == mPrevious && interval > 1 && !mPreviousNumbers.contains(next));
mPrevious = next;
mHistoryOfNumbers.add(mPrevious);
mPreviousNumbers.add(mPrevious);
* Constructor of <code>MultiPlayer</code>
*/
public MultiPlayer(final MusicPlaybackService service) {
- mService = new WeakReference<MusicPlaybackService>(service);
+ mService = new WeakReference<>(service);
mSrtManager = new SrtManager() {
@Override
public void onTimedText(String text) {
private final WeakReference<MusicPlaybackService> mService;
private ServiceStub(final MusicPlaybackService service) {
- mService = new WeakReference<MusicPlaybackService>(service);
+ mService = new WeakReference<>(service);
}
/**
private static final int MAX_ALBUM_ARTIST_SIZE = 10;
// This helps with flickering and jumping and reloading the same tracks
- private final static LinkedList<AlbumArtistDetails> sCacheAlbumArtistDetails = new LinkedList<AlbumArtistDetails>();
+ private final static LinkedList<AlbumArtistDetails> sCacheAlbumArtistDetails = new LinkedList<>();
/**
* Adds the album artist details to the cache
*/
public class PagerAdapter extends FragmentPagerAdapter {
- private final SparseArray<WeakReference<Fragment>> mFragmentArray = new SparseArray<WeakReference<Fragment>>();
+ private final SparseArray<WeakReference<Fragment>> mFragmentArray = new SparseArray<>();
private final List<Holder> mHolderList = Lists.newArrayList();
if (mWeakFragment != null) {
mWeakFragment.clear();
}
- mFragmentArray.put(position, new WeakReference<Fragment>(mFragment));
+ mFragmentArray.put(position, new WeakReference<>(mFragment));
return mFragment;
}
import android.content.Context;
import android.content.Intent;
-import org.lineageos.eleven.MusicPlaybackService;
-
public abstract class AppWidgetBase extends AppWidgetProvider {
protected PendingIntent buildPendingIntent(Context context, final String action,
import org.lineageos.eleven.MusicPlaybackService;
import org.lineageos.eleven.R;
import org.lineageos.eleven.ui.activities.HomeActivity;
-import org.lineageos.eleven.utils.ElevenUtils;
/**
* 4x2 App-Widget
import org.lineageos.eleven.MusicPlaybackService;
import org.lineageos.eleven.R;
import org.lineageos.eleven.ui.activities.HomeActivity;
-import org.lineageos.eleven.utils.ElevenUtils;
import org.lineageos.eleven.widgets.RepeatButton;
import org.lineageos.eleven.widgets.ShuffleButton;
import org.lineageos.eleven.MusicPlaybackService;
import org.lineageos.eleven.R;
import org.lineageos.eleven.ui.activities.HomeActivity;
-import org.lineageos.eleven.utils.ElevenUtils;
/**
* 4x1 App-Widget
mImageCache = ImageCache.getInstance(mContext);
mResources = mContext.getResources();
- mImageReference = new WeakReference<ImageView>(imageView);
+ mImageReference = new WeakReference<>(imageView);
mImageType = imageType;
// A transparent image (layer 0) and the new result (layer 1)
final ImageType imageType, final Drawable fromDrawable,
final Context context, final RenderScript renderScript) {
super(key, blurScrimImage.getImageView(), imageType, fromDrawable, context);
- mBlurScrimImage = new WeakReference<BlurScrimImage>(blurScrimImage);
+ mBlurScrimImage = new WeakReference<>(blurScrimImage);
mRenderScript = renderScript;
// use the existing image as the drawable and if it doesn't exist fallback to transparent
}
return null;
}
-}
\ No newline at end of file
+}
private Writer journalWriter;
- private final LinkedHashMap<String, Entry> lruEntries = new LinkedHashMap<String, Entry>(0,
+ private final LinkedHashMap<String, Entry> lruEntries = new LinkedHashMap<>(0,
0.75f, true);
private int redundantOpCount;
if (journalWriter == null) {
return; // already closed
}
- for (final Entry entry : new ArrayList<Entry>(lruEntries.values())) {
+ for (final Entry entry : new ArrayList<>(lruEntries.values())) {
if (entry.currentEditor != null) {
entry.currentEditor.abort();
}
/**
* listeners to the cache state
*/
- private HashSet<ICacheListener> mListeners = new HashSet<ICacheListener>();
+ private HashSet<ICacheListener> mListeners = new HashSet<>();
private static ImageCache sInstance;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.TransitionDrawable;
import android.support.v8.renderscript.RenderScript;
-import android.text.TextUtils;
import android.view.View;
import android.widget.ImageView;
-import org.lineageos.eleven.R;
import org.lineageos.eleven.provider.PlaylistArtworkStore;
import org.lineageos.eleven.utils.ElevenUtils;
import org.lineageos.eleven.utils.ImageUtils;
* Constructor of <code>AsyncDrawable</code>
*/
public AsyncTaskContainer(final BitmapWorkerTask bitmapWorkerTask) {
- mBitmapWorkerTaskReference = new WeakReference<BitmapWorkerTask>(bitmapWorkerTask);
+ mBitmapWorkerTaskReference = new WeakReference<>(bitmapWorkerTask);
mKey = bitmapWorkerTask.mKey;
}
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
- this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
+ this.map = new LinkedHashMap<>(0, 0.75f, true);
}
/**
* recently accessed to most recently accessed.
*/
public synchronized final Map<K, V> snapshot() {
- return new LinkedHashMap<K, V>(this.map);
+ return new LinkedHashMap<>(this.map);
}
@SuppressLint("DefaultLocale")
import android.provider.MediaStore;
import android.widget.ImageView;
-import org.lineageos.eleven.R;
import org.lineageos.eleven.cache.ImageWorker.ImageType;
import org.lineageos.eleven.loaders.PlaylistSongLoader;
import org.lineageos.eleven.loaders.SortedCursor;
}
// otherwise re-run the logic to get the bitmap
- Cursor sortedCursor = null;
-
- try {
+ try (Cursor sortedCursor = getTopSongsForPlaylist()) {
// get the top songs for our playlist
- sortedCursor = getTopSongsForPlaylist();
if (isCancelled()) {
return null;
} else {
bitmap = loadTopSongs(sortedCursor);
}
- } finally {
- if (sortedCursor != null) {
- sortedCursor.close();
- }
}
// if we have a bitmap create a transition drawable
return null;
}
- ArrayList<Bitmap> loadedBitmaps = new ArrayList<Bitmap>(MAX_NUM_BITMAPS_TO_LOAD);
+ ArrayList<Bitmap> loadedBitmaps = new ArrayList<>(MAX_NUM_BITMAPS_TO_LOAD);
final int artistIdx = sortedCursor.getColumnIndex(MediaStore.Audio.AudioColumns.ARTIST);
final int albumIdIdx = sortedCursor.getColumnIndex(MediaStore.Audio.AudioColumns.ALBUM_ID);
long albumId = -1;
// create a hashset of the keys so we don't load images from the same album multiple times
- HashSet<String> keys = new HashSet<String>(sortedCursor.getCount());
+ HashSet<String> keys = new HashSet<>(sortedCursor.getCount());
do {
if (isCancelled()) {
mSize = mNowPlaying.length;
if (mSize == 0) {
mCursorIndexes = null;
- return;
}
}
}
final int idCol = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members.AUDIO_ID);
final Uri uri = MediaStore.Audio.Playlists.Members.getContentUri("external", playlistId);
- ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
+ ArrayList<ContentProviderOperation> ops = new ArrayList<>();
// Delete all results in the playlist
ops.add(ContentProviderOperation.newDelete(uri).build());
* @param sortOrder the song ordering preference selected by the user
*/
private static LocalizedStore.SortParameter getSortParameter(String sortOrder) {
- if (sortOrder.equals(SortOrder.SongSortOrder.SONG_A_Z) ||
- sortOrder.equals(SortOrder.SongSortOrder.SONG_Z_A)) {
- return LocalizedStore.SortParameter.Song;
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_ALBUM)) {
- return LocalizedStore.SortParameter.Album;
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_ARTIST)) {
- return LocalizedStore.SortParameter.Artist;
+ switch (sortOrder) {
+ case SortOrder.SongSortOrder.SONG_A_Z:
+ case SortOrder.SongSortOrder.SONG_Z_A:
+ return SortParameter.Song;
+ case SortOrder.SongSortOrder.SONG_ALBUM:
+ return SortParameter.Album;
+ case SortOrder.SongSortOrder.SONG_ARTIST:
+ return SortParameter.Artist;
}
return null;
*/
private ArrayList<Long> buildCursorPositionMapping(final long[] order,
final String columnName, final List<? extends Object> extraData) {
- ArrayList<Long> missingIds = new ArrayList<Long>();
+ ArrayList<Long> missingIds = new ArrayList<>();
- mOrderedPositions = new ArrayList<Integer>(mCursor.getCount());
- mExtraData = new ArrayList<Object>();
+ mOrderedPositions = new ArrayList<>(mCursor.getCount());
+ mExtraData = new ArrayList<>();
- mMapCursorPositions = new HashMap<Long, Integer>(mCursor.getCount());
+ mMapCursorPositions = new HashMap<>(mCursor.getCount());
final int idPosition = mCursor.getColumnIndex(columnName);
if (mCursor.moveToFirst()) {
public ArrayList<String> getLabels() {
final int bucketCount = getBucketCount();
- final ArrayList<String> labels = new ArrayList<String>(bucketCount);
+ final ArrayList<String> labels = new ArrayList<>(bucketCount);
for(int i = 0; i < bucketCount; ++i) {
labels.add(getBucketLabel(i));
}
import org.lineageos.eleven.Config;
import org.lineageos.eleven.R;
import org.lineageos.eleven.ui.activities.HomeActivity;
-import org.lineageos.eleven.utils.ElevenUtils;
import org.lineageos.eleven.utils.Lists;
import org.lineageos.eleven.utils.MusicUtils;
}
// Dialog item Adapter
final HomeActivity activity = (HomeActivity) getActivity();
- final ListAdapter adapter = new ArrayAdapter<String>(activity,
+ final ListAdapter adapter = new ArrayAdapter<>(activity,
android.R.layout.select_dialog_item, mChoices);
return new AlertDialog.Builder(activity).setTitle(title)
.setAdapter(adapter, new DialogInterface.OnClickListener() {
Log.d(TAG, "Running selection: " + selection);
}
- Cursor c = null;
- try {
- c = mMusicDatabase.getReadableDatabase().rawQuery(selection, null);
-
+ try (Cursor c = mMusicDatabase.getReadableDatabase().rawQuery(selection, null)) {
if (c != null && c.moveToFirst()) {
sortData.ids = new long[c.getCount()];
- sortData.bucketLabels = new ArrayList<String>(c.getCount());
+ sortData.bucketLabels = new ArrayList<>(c.getCount());
do {
sortData.ids[c.getPosition()] = c.getLong(0);
sortData.bucketLabels.add(c.getString(1));
} while (c.moveToNext());
}
- } finally {
- if (c != null) {
- c.close();
- }
}
return sortData;
public ArrayList<String> getRecentSearches() {
Cursor searches = queryRecentSearches(String.valueOf(MAX_ITEMS_IN_DB));
- ArrayList<String> results = new ArrayList<String>(MAX_ITEMS_IN_DB);
+ ArrayList<String> results = new ArrayList<>(MAX_ITEMS_IN_DB);
try {
if (searches != null && searches.moveToFirst()) {
return null;
}
- HashSet<Long> uniqueIds = new HashSet<Long>(ids.length);
+ HashSet<Long> uniqueIds = new HashSet<>(ids.length);
// create the list of ids to select against
StringBuilder selection = new StringBuilder();
}
// append the remaining items - these are songs that haven't been played recently
- Iterator<Long> iter = uniqueIds.iterator();
- while (iter.hasNext()) {
- sortedList[idx++] = iter.next();
+ for (final Long uniqueId : uniqueIds) {
+ sortedList[idx++] = uniqueId;
}
return sortedList;
mContext = context;
mUnderlyingAdapter = underlyingAdapter;
mUnderlyingAdapter.setPopupMenuClickedListener(this);
- mSections = new TreeMap<Integer, Section>();
+ mSections = new TreeMap<>();
setupHeaderParameters(R.layout.list_header, false);
// since we have no good default footer, just re-use the header layout
setupFooterParameters(R.layout.list_header, false);
sections = SectionCreatorUtils.createSections(results, mComparator);
}
- return new SectionListContainer<T>(sections, results);
+ return new SectionListContainer<>(sections, results);
}
}
public MusicHolder(final View view) {
super();
// Initialize mImage
- mImage = new WeakReference<ImageView>((ImageView)view.findViewById(R.id.image));
+ mImage = new WeakReference<>((ImageView) view.findViewById(R.id.image));
// Initialize mLineOne
- mLineOne = new WeakReference<TextView>((TextView)view.findViewById(R.id.line_one));
+ mLineOne = new WeakReference<>((TextView) view.findViewById(R.id.line_one));
// Initialize mLineOneRight
- mLineOneRight = new WeakReference<TextView>(
- (TextView)view.findViewById(R.id.line_one_right));
+ mLineOneRight = new WeakReference<>(
+ (TextView) view.findViewById(R.id.line_one_right));
// Initialize mLineTwo
- mLineTwo = new WeakReference<TextView>((TextView)view.findViewById(R.id.line_two));
+ mLineTwo = new WeakReference<>((TextView) view.findViewById(R.id.line_two));
// Initialize Circular progress bar container
- mPlayPauseProgressButton = new WeakReference<PlayPauseProgressButton>(
- (PlayPauseProgressButton)view.findViewById(R.id.playPauseProgressButton));
+ mPlayPauseProgressButton = new WeakReference<>(
+ (PlayPauseProgressButton) view.findViewById(R.id.playPauseProgressButton));
// Get the padding container for the progress bar
- mPlayPauseProgressContainer = new WeakReference<View>(
+ mPlayPauseProgressContainer = new WeakReference<>(
view.findViewById(R.id.play_pause_container));
- mNowPlayingIndicator = new WeakReference<View>(view.findViewById(R.id.now_playing));
+ mNowPlayingIndicator = new WeakReference<>(view.findViewById(R.id.now_playing));
// Get the divider for the list item
- mDivider = new WeakReference<View>(view.findViewById(R.id.divider));
+ mDivider = new WeakReference<>(view.findViewById(R.id.divider));
// Get the pop up menu button
- mPopupMenuButton = new WeakReference<PopupMenuButton>(
- (PopupMenuButton)view.findViewById(R.id.popup_menu_button));
+ mPopupMenuButton = new WeakReference<>(
+ (PopupMenuButton) view.findViewById(R.id.popup_menu_button));
}
/**
* Constructor of <code>PlaybackStatus</code>
*/
public PlaybackStatus(final BaseActivity activity) {
- mReference = new WeakReference<BaseActivity>(activity);
+ mReference = new WeakReference<>(activity);
}
/**
@Override
public void onReceive(final Context context, final Intent intent) {
final String action = intent.getAction();
- BaseActivity baseActivity = mReference.get();
+ if (action == null || action.isEmpty()) {
+ return;
+ }
+
+ final BaseActivity baseActivity = mReference.get();
if (baseActivity != null) {
- if (action.equals(MusicPlaybackService.META_CHANGED)) {
- baseActivity.onMetaChanged();
- } else if (action.equals(MusicPlaybackService.PLAYSTATE_CHANGED)) {
- // Set the play and pause image
- baseActivity.mPlayPauseProgressButton.getPlayPauseButton().updateState();
- } else if (action.equals(MusicPlaybackService.REFRESH)) {
- baseActivity.restartLoader();
- } else if (action.equals(MusicPlaybackService.PLAYLIST_CHANGED)) {
- baseActivity.onPlaylistChanged();
- } else if (action.equals(MusicPlaybackService.TRACK_ERROR)) {
- final String errorMsg = context.getString(R.string.error_playing_track,
- intent.getStringExtra(MusicPlaybackService.TrackErrorExtra.TRACK_NAME));
- Toast.makeText(baseActivity, errorMsg, Toast.LENGTH_SHORT).show();
+ switch (action) {
+ case MusicPlaybackService.META_CHANGED:
+ baseActivity.onMetaChanged();
+ break;
+ case MusicPlaybackService.PLAYSTATE_CHANGED:
+ // Set the play and pause image
+ baseActivity.mPlayPauseProgressButton.getPlayPauseButton().updateState();
+ break;
+ case MusicPlaybackService.REFRESH:
+ baseActivity.restartLoader();
+ break;
+ case MusicPlaybackService.PLAYLIST_CHANGED:
+ baseActivity.onPlaylistChanged();
+ break;
+ case MusicPlaybackService.TRACK_ERROR:
+ final String errorMsg = context.getString(R.string.error_playing_track,
+ intent.getStringExtra(MusicPlaybackService.TrackErrorExtra.TRACK_NAME));
+ Toast.makeText(baseActivity, errorMsg, Toast.LENGTH_SHORT).show();
+ break;
}
}
}
}
private boolean needRequestStoragePermission() {
- if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return false;
-
boolean needRequest = false;
String[] permissions = {
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE
};
- ArrayList<String> permissionList = new ArrayList<String>();
+ ArrayList<String> permissionList = new ArrayList<>();
for (String permission : permissions) {
if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
permissionList.add(permission);
// Initialize the adapter
SummarySearchAdapter adapter = new SummarySearchAdapter(this);
- mAdapter = new SectionAdapter<SearchResult, SummarySearchAdapter>(this, adapter);
+ mAdapter = new SectionAdapter<>(this, adapter);
// Set the prefix
mAdapter.getUnderlyingAdapter().setPrefix(mFilterString);
mAdapter.setupHeaderParameters(R.layout.list_search_header, false);
comparator = SectionCreatorUtils.createSearchResultComparison(this);
}
- return new SectionCreator<SearchResult>(this,
+ return new SectionCreator<>(this,
new SummarySearchLoader(this, mFilterString, mSearchType),
comparator);
}
* @return the results for that search
*/
protected List<SearchResult> runSearchForType() {
- ArrayList<SearchResult> results = new ArrayList<SearchResult>();
+ ArrayList<SearchResult> results = new ArrayList<>();
Cursor cursor = null;
try {
if (mSearchType == ResultType.Playlist) {
* @return the results for that search
*/
public List<SearchResult> runGenericSearch() {
- ArrayList<SearchResult> results = new ArrayList<SearchResult>();
+ ArrayList<SearchResult> results = new ArrayList<>();
// number of types to query for
final int numTypes = ResultType.getNumTypes();
keywords[i] = "%" + keywords[i] + "%";
}
- String where = "";
-
- // make the where clause
+ final StringBuilder where = new StringBuilder();
for (int i = 0; i < keywords.length; i++) {
if (i == 0) {
- where = "name LIKE ?";
+ where.append("name LIKE ?");
} else {
- where += " AND name LIKE ?";
+ where.append(" AND name LIKE ?");
}
}
BaseColumns._ID,
/* 1 */
MediaStore.Audio.PlaylistsColumns.NAME
- }, where, keywords, MediaStore.Audio.Playlists.DEFAULT_SORT_ORDER);
+ }, where.toString(), keywords, MediaStore.Audio.Playlists.DEFAULT_SORT_ORDER);
}
}
@Override
public ArrayAdapter<String> loadInBackground() {
ArrayList<String> strings = SearchHistory.getInstance(getContext()).getRecentSearches();
- ArrayAdapter<String> adapter = new ArrayAdapter<String>(getContext(),
+ ArrayAdapter<String> adapter = new ArrayAdapter<>(getContext(),
R.layout.list_item_search_history, R.id.line_one);
adapter.addAll(strings);
return adapter;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceClickListener;
import android.preference.PreferenceActivity;
-import android.preference.PreferenceManager;
import android.view.MenuItem;
import org.lineageos.eleven.R;
import android.os.Message;
import android.provider.MediaStore.Audio.Media;
import android.text.TextUtils;
-import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
if (activity == null) {
throw new IllegalArgumentException("'activity' cannot be null!");
}
- mActivityReference = new WeakReference<AudioPreviewActivity>(activity);
+ mActivityReference = new WeakReference<>(activity);
setOnErrorListener(activity);
setOnCompletionListener(activity);
}
mLoadingEmptyContainer.showLoading();
// if we ever decide to add section headers for grid items, we can pass a compartor
// instead of null
- return new SectionCreator<Album>(getActivity(), new AlbumLoader(getActivity()), null);
+ return new SectionCreator<>(getActivity(), new AlbumLoader(getActivity()), null);
}
/**
*/
package org.lineageos.eleven.ui.fragments;
-import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.LoaderManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
-import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
import android.widget.ListView;
mHero.getViewTreeObserver().addOnGlobalLayoutListener( new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
- mHero.getViewTreeObserver().removeOnGlobalLayoutListener(this);
- } else {
- mHero.getViewTreeObserver().removeGlobalOnLayoutListener(this);
- }
+ mHero.getViewTreeObserver().removeOnGlobalLayoutListener(this);
ImageFetcher.getInstance(getActivity()).loadArtistImage(mArtistName, mHero, true);
}
});
// Create the adapter
final int layout = R.layout.list_item_normal;
ArtistAdapter adapter = new ArtistAdapter(getActivity(), layout);
- mAdapter = new SectionAdapter<Artist, ArtistAdapter>(getActivity(), adapter);
+ mAdapter = new SectionAdapter<>(getActivity(), adapter);
mAdapter.setPopupMenuClickedListener(new IPopupMenuCallback.IListener() {
@Override
public void onPopupMenuClicked(View v, int position) {
mLoadingEmptyContainer.showLoading();
final Context context = getActivity();
IItemCompare<Artist> comparator = SectionCreatorUtils.createArtistComparison(context);
- return new SectionCreator<Artist>(getActivity(), new ArtistLoader(context), comparator);
+ return new SectionCreator<>(getActivity(), new ArtistLoader(context), comparator);
}
/**
import org.lineageos.eleven.utils.MusicUtils;
import org.lineageos.eleven.utils.NavUtils;
import org.lineageos.eleven.utils.PreferenceUtils;
-import org.lineageos.eleven.widgets.BrowseButton;
import org.lineageos.eleven.widgets.LoadingEmptyContainer;
import org.lineageos.eleven.widgets.NoResultsContainer;
import org.lineageos.eleven.widgets.PlayPauseProgressButton;
-import org.lineageos.eleven.widgets.QueueButton;
import org.lineageos.eleven.widgets.RepeatButton;
import org.lineageos.eleven.widgets.RepeatingImageButton;
import org.lineageos.eleven.widgets.ShuffleButton;
* Constructor of <code>TimeHandler</code>
*/
public TimeHandler(final AudioPlayerFragment player) {
- mAudioPlayer = new WeakReference<AudioPlayerFragment>(player);
+ mAudioPlayer = new WeakReference<>(player);
}
@Override
* Constructor of <code>PlaybackStatus</code>
*/
public PlaybackStatus(final AudioPlayerFragment fragment) {
- mReference = new WeakReference<AudioPlayerFragment>(fragment);
+ mReference = new WeakReference<>(fragment);
}
/**
*/
@Override
public void onReceive(final Context context, final Intent intent) {
- final AudioPlayerFragment audioPlayerFragment = mReference.get();
final String action = intent.getAction();
- if (action.equals(MusicPlaybackService.META_CHANGED)) {
- // if we are repeating current and the track has changed, re-create the adapter
- if (MusicUtils.getRepeatMode() == MusicPlaybackService.REPEAT_CURRENT) {
- mReference.get().createAndSetAdapter();
- }
+ if (action == null || action.isEmpty()) {
+ return;
+ }
- // Current info
- audioPlayerFragment.updateNowPlayingInfo();
- audioPlayerFragment.dismissPopupMenu();
- } else if (action.equals(MusicPlaybackService.PLAYSTATE_CHANGED)) {
- // Set the play and pause image
- audioPlayerFragment.mPlayPauseProgressButton.getPlayPauseButton().updateState();
- audioPlayerFragment.mVisualizerView.setPlaying(MusicUtils.isPlaying());
- } else if (action.equals(MusicPlaybackService.REPEATMODE_CHANGED)
- || action.equals(MusicPlaybackService.SHUFFLEMODE_CHANGED)) {
- // Set the repeat image
- audioPlayerFragment.mRepeatButton.updateRepeatState();
- // Set the shuffle image
- audioPlayerFragment.mShuffleButton.updateShuffleState();
-
- // Update the queue
- audioPlayerFragment.createAndSetAdapter();
- } else if (action.equals(MusicPlaybackService.QUEUE_CHANGED)) {
- audioPlayerFragment.createAndSetAdapter();
- } else if (action.equals(MusicPlaybackService.NEW_LYRICS)) {
- audioPlayerFragment.onLyrics(intent.getStringExtra("lyrics"));
- } else if (action.equals(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED)) {
- audioPlayerFragment.updateVisualizerPowerSaveMode();
+ final AudioPlayerFragment audioPlayerFragment = mReference.get();
+ switch (action) {
+ case MusicPlaybackService.META_CHANGED:
+ // if we are repeating current and the track has changed, re-create the adapter
+ if (MusicUtils.getRepeatMode() == MusicPlaybackService.REPEAT_CURRENT) {
+ mReference.get().createAndSetAdapter();
+ }
+
+ // Current info
+ audioPlayerFragment.updateNowPlayingInfo();
+ audioPlayerFragment.dismissPopupMenu();
+ break;
+ case MusicPlaybackService.PLAYSTATE_CHANGED:
+ // Set the play and pause image
+ audioPlayerFragment.mPlayPauseProgressButton.getPlayPauseButton().updateState();
+ audioPlayerFragment.mVisualizerView.setPlaying(MusicUtils.isPlaying());
+ break;
+ case MusicPlaybackService.REPEATMODE_CHANGED:
+ case MusicPlaybackService.SHUFFLEMODE_CHANGED:
+ // Set the repeat image
+ audioPlayerFragment.mRepeatButton.updateRepeatState();
+ // Set the shuffle image
+ audioPlayerFragment.mShuffleButton.updateShuffleState();
+
+ // Update the queue
+ audioPlayerFragment.createAndSetAdapter();
+ break;
+ case MusicPlaybackService.QUEUE_CHANGED:
+ audioPlayerFragment.createAndSetAdapter();
+ break;
+ case MusicPlaybackService.NEW_LYRICS:
+ audioPlayerFragment.onLyrics(intent.getStringExtra("lyrics"));
+ break;
+ case PowerManager.ACTION_POWER_SAVE_MODE_CHANGED:
+ audioPlayerFragment.updateVisualizerPowerSaveMode();
+ break;
}
}
}
* Constructor of <code>PlaybackStatus</code>
*/
public QueueUpdateListener(final QueueFragment fragment) {
- mReference = new WeakReference<QueueFragment>(fragment);
+ mReference = new WeakReference<>(fragment);
}
/**
public void onReceive(final Context context, final Intent intent) {
// TODO: Invalid options menu if opened?
final String action = intent.getAction();
- if (action.equals(MusicPlaybackService.META_CHANGED)) {
- mReference.get().mAdapter.setCurrentQueuePosition(MusicUtils.getQueuePosition());
- } else if (action.equals(MusicPlaybackService.PLAYSTATE_CHANGED)) {
- mReference.get().mAdapter.notifyDataSetChanged();
- } else if (action.equals(MusicPlaybackService.QUEUE_CHANGED)) {
- mReference.get().refreshQueue();
+ if (action == null || action.isEmpty()) {
+ return;
+ }
+
+ switch (action) {
+ case MusicPlaybackService.META_CHANGED:
+ mReference.get().mAdapter.setCurrentQueuePosition(MusicUtils.getQueuePosition());
+ break;
+ case MusicPlaybackService.PLAYSTATE_CHANGED:
+ mReference.get().mAdapter.notifyDataSetChanged();
+ break;
+ case MusicPlaybackService.QUEUE_CHANGED:
+ mReference.get().refreshQueue();
+ break;
}
}
}
-}
\ No newline at end of file
+}
TopTracksLoader loader = new TopTracksLoader(getActivity(),
TopTracksLoader.QueryType.RecentSongs);
- return new SectionCreator<Song>(getActivity(), loader, null);
+ return new SectionCreator<>(getActivity(), loader, null);
}
/**
@Override
protected void clearList() { MusicUtils.clearRecent(getActivity()); }
-}
\ No newline at end of file
+}
SectionCreatorUtils.IItemCompare<Song> songComparison = SectionCreatorUtils.createSongComparison(context);
// return the wrapped section creator
- return new SectionCreator<Song>(context, songLoader, songComparison);
+ return new SectionCreator<>(context, songLoader, songComparison);
}
};
// Create the adapter
- mAdapter = new SectionAdapter<Song, SongAdapter>(getActivity(), createAdapter());
+ mAdapter = new SectionAdapter<>(getActivity(), createAdapter());
mAdapter.setPopupMenuClickedListener(new IPopupMenuCallback.IListener() {
@Override
public void onPopupMenuClicked(View v, int position) {
mLoadingEmptyContainer.showLoading();
LastAddedLoader loader = new LastAddedLoader(getActivity());
- return new SectionCreator<Song>(getActivity(), loader, null);
+ return new SectionCreator<>(getActivity(), loader, null);
}
@Override
@Override
protected void clearList() { MusicUtils.clearLastAdded(getActivity()); }
-}
\ No newline at end of file
+}
TopTracksLoader loader = new TopTracksLoader(getActivity(),
TopTracksLoader.QueryType.TopTracks);
- return new SectionCreator<Song>(getActivity(), loader, null);
+ return new SectionCreator<>(getActivity(), loader, null);
}
@Override
@Override
protected void clearList() { MusicUtils.clearTopTracks(getActivity()); }
-}
\ No newline at end of file
+}
import android.graphics.Color;
import android.os.Looper;
import android.support.v7.graphics.Palette;
-import android.support.v7.graphics.Target;
import android.util.LruCache;
public class BitmapWithColors {
private static final int CACHE_SIZE_MAX = 20;
private static final LruCache<Integer, BitmapColors> sCachedColors =
- new LruCache<Integer, BitmapColors>(CACHE_SIZE_MAX);
+ new LruCache<>(CACHE_SIZE_MAX);
private Bitmap mBitmap;
private int mBitmapKey;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.AsyncTask;
-import android.os.Build;
import android.provider.BaseColumns;
import android.provider.MediaStore;
import android.util.Log;
* @param context The {@link Context} to use.
* @return True if the device is a tablet, false otherwise.
*/
- public static final boolean isTablet(final Context context) {
+ public static boolean isTablet(final Context context) {
final int layout = context.getResources().getConfiguration().screenLayout;
return (layout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}
* @param context The {@link Context} to use.
* @return True if the device is in landscape mode, false otherwise.
*/
- public static final boolean isLandscape(final Context context) {
+ public static boolean isLandscape(final Context context) {
final int orientation = context.getResources().getConfiguration().orientation;
return orientation == Configuration.ORIENTATION_LANDSCAPE;
}
* {@link AsyncTask#execute(Object[])}
* @param <T> Task argument type
*/
- @SuppressLint("NewApi")
public static <T> void execute(final boolean forceSerial, final AsyncTask<T, ?, ?> task,
final T... args) {
- if (Build.VERSION.SDK_INT < Build.VERSION_CODES.DONUT) {
- throw new UnsupportedOperationException(
- "This class can only be used on API 4 and newer.");
- }
- if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB || forceSerial) {
+ if (forceSerial) {
task.execute(args);
} else {
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, args);
* settings, the mobile data and other network connections aren't
* returned at all
*/
- public static final boolean isOnline(final Context context) {
+ public static boolean isOnline(final Context context) {
/*
* This sort of handles a sudden configuration change, but I think it
* should be dealt with in a more professional way.
* @return a newly-created, initially-empty {@code ArrayList}
*/
public static final <E> ArrayList<E> newArrayList() {
- return new ArrayList<E>();
+ return new ArrayList<>();
}
/**
* @return a newly-created, initially-empty {@code LinkedList}
*/
public static final <E> LinkedList<E> newLinkedList() {
- return new LinkedList<E>();
+ return new LinkedList<>();
}
}
import android.content.ServiceConnection;
import android.database.Cursor;
import android.net.Uri;
-import android.os.AsyncTask;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.SystemClock;
import org.lineageos.eleven.loaders.TopTracksLoader;
import org.lineageos.eleven.locale.LocaleUtils;
import org.lineageos.eleven.menu.FragmentMenuItems;
-import org.lineageos.eleven.model.Album;
import org.lineageos.eleven.model.AlbumArtistDetails;
-import org.lineageos.eleven.model.Artist;
-import org.lineageos.eleven.model.Song;
import org.lineageos.eleven.provider.RecentStore;
import org.lineageos.eleven.provider.SongPlayCount;
import org.lineageos.eleven.service.MusicPlaybackTrack;
public static final long UPDATE_FREQUENCY_FAST_MS = 30;
static {
- mConnectionMap = new WeakHashMap<Context, ServiceBinder>();
+ mConnectionMap = new WeakHashMap<>();
sEmptyList = new long[0];
}
*
* @NOTE The AIDL isn't used here in order to properly use the previous
* action. When the user is shuffling, because {@link
- * MusicPlaybackService.#openCurrentAndNext()} is used, the user won't
+ * MusicPlaybackService#openCurrentAndNext()} is used, the user won't
* be able to travel to the previously skipped track. To remedy this,
- * {@link MusicPlaybackService.#openCurrent()} is called in {@link
- * MusicPlaybackService.#prev()}. {@code #startService(Intent intent)}
+ * {@link MusicPlaybackService#openCurrent()} is called in {@link
+ * MusicPlaybackService#prev(boolean)}. {@code #startService(Intent intent)}
* is called here to specifically invoke the onStartCommand used by
* {@link MusicPlaybackService}, which states if the current position
* less than 2000 ms, start the track over, otherwise move to the
};
String selection = (AudioColumns.IS_MUSIC + "=1") +
" AND " + MediaColumns.TITLE + "!=''";
- final Uri uri = MediaStore.Audio.Genres.Members.getContentUri("external", Long.valueOf(id));
+ final Uri uri = MediaStore.Audio.Genres.Members.getContentUri("external", id);
Cursor cursor = context.getContentResolver().query(uri, projection, selection,
null, null);
if (cursor != null) {
public static void clearPlaylist(final Context context, final int playlistId) {
final Uri uri = MediaStore.Audio.Playlists.Members.getContentUri("external", playlistId);
context.getContentResolver().delete(uri, null, null);
- return;
}
/** remove all backing data for top tracks playlist */
import android.content.ActivityNotFoundException;
import android.content.Intent;
import android.content.pm.PackageManager;
-import android.content.pm.ResolveInfo;
import android.media.audiofx.AudioEffect;
import android.os.Bundle;
import android.provider.MediaStore;
-import android.util.Log;
import android.widget.Toast;
import org.lineageos.eleven.Config;
import org.lineageos.eleven.ui.activities.SearchActivity;
import org.lineageos.eleven.ui.activities.SettingsActivity;
-import java.util.List;
-
/**
* Various navigation helpers.
*
* @param menu Menu to use for adding to
*/
public void createPopupMenu(final Menu menu) {
- TreeSet<Integer> menuItems = new TreeSet<Integer>();
+ TreeSet<Integer> menuItems = new TreeSet<>();
// get the default items and add them
int[] defaultItems = getIdsForType(mType);
/** @parm lastAddedMillis timestamp in millis used as a cutoff for last added playlist */
public void setLastAddedCutoff(long lastAddedMillis) {
- mPreferences.edit().putLong(LAST_ADDED_CUTOFF, lastAddedMillis).commit();
+ mPreferences.edit().putLong(LAST_ADDED_CUTOFF, lastAddedMillis).apply();
}
public long getLastAddedCutoff() {
public boolean getShowAlbumArtOnLockscreen() {
return mPreferences.getBoolean(SHOW_ALBUM_ART_ON_LOCKSCREEN, true);
}
-}
\ No newline at end of file
+}
public static <T> TreeMap<Integer, Section> createSections(final List<T> list,
final IItemCompare<T> comparator) {
if (list != null && list.size() > 0) {
- TreeMap<Integer, Section> sections = new TreeMap<Integer, Section>();
+ TreeMap<Integer, Section> sections = new TreeMap<>();
for (int i = 0; i < list.size() + 1; i++) {
T first = (i == 0 ? null : list.get(i - 1));
T second = (i == list.size() ? null : list.get(i));
public static IItemCompare<Artist> createArtistComparison(final Context context) {
IItemCompare<Artist> sectionCreator = null;
- String sortOrder = PreferenceUtils.getInstance(context).getArtistSortOrder();
- if (sortOrder.equals(SortOrder.ArtistSortOrder.ARTIST_A_Z)
- || sortOrder.equals(SortOrder.ArtistSortOrder.ARTIST_Z_A)) {
- sectionCreator = new SectionCreatorUtils.LocalizedCompare<Artist>(context) {
- @Override
- public String getString(Artist item) {
- return item.mArtistName;
- }
-
- @Override
- public String createHeaderLabel(Artist item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ final String sortOrder = PreferenceUtils.getInstance(context).getArtistSortOrder();
+ switch (sortOrder) {
+ case SortOrder.ArtistSortOrder.ARTIST_A_Z:
+ case SortOrder.ArtistSortOrder.ARTIST_Z_A:
+ sectionCreator = new LocalizedCompare<Artist>(context) {
+ @Override
+ public String getString(Artist item) {
+ return item.mArtistName;
}
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.ArtistSortOrder.ARTIST_NUMBER_OF_ALBUMS)) {
- sectionCreator = new SectionCreatorUtils.NumberOfAlbumsCompare<Artist>(context) {
- @Override
- public int getInt(Artist item) {
- return item.mAlbumNumber;
- }
- };
- } else if (sortOrder.equals(SortOrder.ArtistSortOrder.ARTIST_NUMBER_OF_SONGS)) {
- sectionCreator = new NumberOfSongsCompare<Artist>(context) {
- @Override
- public int getInt(Artist item) {
- return item.mSongNumber;
- }
- };
+ @Override
+ public String createHeaderLabel(Artist item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
+
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
+ case SortOrder.ArtistSortOrder.ARTIST_NUMBER_OF_ALBUMS:
+ sectionCreator = new NumberOfAlbumsCompare<Artist>(context) {
+ @Override
+ public int getInt(Artist item) {
+ return item.mAlbumNumber;
+ }
+ };
+ break;
+ case SortOrder.ArtistSortOrder.ARTIST_NUMBER_OF_SONGS:
+ sectionCreator = new NumberOfSongsCompare<Artist>(context) {
+ @Override
+ public int getInt(Artist item) {
+ return item.mSongNumber;
+ }
+ };
+ break;
}
return sectionCreator;
public static IItemCompare<Album> createAlbumComparison(final Context context) {
IItemCompare<Album> sectionCreator = null;
- String sortOrder = PreferenceUtils.getInstance(context).getAlbumSortOrder();
- if (sortOrder.equals(SortOrder.AlbumSortOrder.ALBUM_A_Z)
- || sortOrder.equals(SortOrder.AlbumSortOrder.ALBUM_Z_A)) {
- sectionCreator = new LocalizedCompare<Album>(context) {
- @Override
- public String getString(Album item) {
- return item.mAlbumName;
- }
-
- @Override
- public String createHeaderLabel(Album item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ final String sortOrder = PreferenceUtils.getInstance(context).getAlbumSortOrder();
+ switch (sortOrder) {
+ case SortOrder.AlbumSortOrder.ALBUM_A_Z:
+ case SortOrder.AlbumSortOrder.ALBUM_Z_A:
+ sectionCreator = new LocalizedCompare<Album>(context) {
+ @Override
+ public String getString(Album item) {
+ return item.mAlbumName;
}
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.AlbumSortOrder.ALBUM_ARTIST)) {
- sectionCreator = new LocalizedCompare<Album>(context) {
- @Override
- public String getString(Album item) {
- return item.mArtistName;
- }
+ @Override
+ public String createHeaderLabel(Album item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
- @Override
- public String createHeaderLabel(Album item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ return super.createHeaderLabel(item);
}
-
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.AlbumSortOrder.ALBUM_NUMBER_OF_SONGS)) {
- sectionCreator = new NumberOfSongsCompare<Album>(context) {
- @Override
- public int getInt(Album item) {
- return item.mSongNumber;
- }
- };
- } else if (sortOrder.equals(SortOrder.AlbumSortOrder.ALBUM_YEAR)) {
- sectionCreator = new IntCompare<Album>() {
- private static final int INVALID_YEAR = -1;
-
- @Override
- public int getInt(Album item) {
- // if we don't have a year, treat it as invalid
- if (item.mYear == null) {
- return INVALID_YEAR;
+ };
+ break;
+ case SortOrder.AlbumSortOrder.ALBUM_ARTIST:
+ sectionCreator = new LocalizedCompare<Album>(context) {
+ @Override
+ public String getString(Album item) {
+ return item.mArtistName;
}
- int year = Integer.valueOf(item.mYear);
+ @Override
+ public String createHeaderLabel(Album item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
- // if the year is extremely low, treat it as invalid too
- if (MusicUtils.isInvalidYear(year)) {
- return INVALID_YEAR;
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
+ case SortOrder.AlbumSortOrder.ALBUM_NUMBER_OF_SONGS:
+ sectionCreator = new NumberOfSongsCompare<Album>(context) {
+ @Override
+ public int getInt(Album item) {
+ return item.mSongNumber;
}
+ };
+ break;
+ case SortOrder.AlbumSortOrder.ALBUM_YEAR:
+ sectionCreator = new IntCompare<Album>() {
+ private static final int INVALID_YEAR = -1;
+
+ @Override
+ public int getInt(Album item) {
+ // if we don't have a year, treat it as invalid
+ if (item.mYear == null) {
+ return INVALID_YEAR;
+ }
- return year;
- }
+ int year = Integer.valueOf(item.mYear);
+
+ // if the year is extremely low, treat it as invalid too
+ if (MusicUtils.isInvalidYear(year)) {
+ return INVALID_YEAR;
+ }
- @Override
- public String createHeaderLabel(Album item) {
- if (MusicUtils.isInvalidYear(getInt(item))) {
- return context.getString(R.string.header_unknown_year);
+ return year;
}
- return item.mYear;
- }
- };
+ @Override
+ public String createHeaderLabel(Album item) {
+ if (MusicUtils.isInvalidYear(getInt(item))) {
+ return context.getString(R.string.header_unknown_year);
+ }
+
+ return item.mYear;
+ }
+ };
+ break;
}
return sectionCreator;
public static IItemCompare<Song> createSongComparison(final Context context) {
IItemCompare<Song> sectionCreator = null;
- String sortOrder = PreferenceUtils.getInstance(context).getSongSortOrder();
+ final String sortOrder = PreferenceUtils.getInstance(context).getSongSortOrder();
// doesn't make sense to have headers for SONG_FILENAME
// so we will not return a sectionCreator for that one
- if (sortOrder.equals(SortOrder.SongSortOrder.SONG_A_Z)
- || sortOrder.equals(SortOrder.SongSortOrder.SONG_Z_A)) {
- sectionCreator = new LocalizedCompare<Song>(context) {
- @Override
- public String getString(Song item) {
- return item.mSongName;
- }
-
- @Override
- public String createHeaderLabel(Song item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ switch (sortOrder) {
+ case SortOrder.SongSortOrder.SONG_A_Z:
+ case SortOrder.SongSortOrder.SONG_Z_A:
+ sectionCreator = new LocalizedCompare<Song>(context) {
+ @Override
+ public String getString(Song item) {
+ return item.mSongName;
}
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_ALBUM)) {
- sectionCreator = new LocalizedCompare<Song>(context) {
- @Override
- public String getString(Song item) {
- return item.mAlbumName;
- }
+ @Override
+ public String createHeaderLabel(Song item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
- @Override
- public String createHeaderLabel(Song item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
+ case SortOrder.SongSortOrder.SONG_ALBUM:
+ sectionCreator = new LocalizedCompare<Song>(context) {
+ @Override
+ public String getString(Song item) {
+ return item.mAlbumName;
}
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_ARTIST)) {
- sectionCreator = new LocalizedCompare<Song>(context) {
- @Override
- public String getString(Song item) {
- return item.mArtistName;
- }
+ @Override
+ public String createHeaderLabel(Song item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
- @Override
- public String createHeaderLabel(Song item) {
- if (item.mBucketLabel != null) {
- return super.createHeaderLabel(item.mBucketLabel);
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
+ case SortOrder.SongSortOrder.SONG_ARTIST:
+ sectionCreator = new LocalizedCompare<Song>(context) {
+ @Override
+ public String getString(Song item) {
+ return item.mArtistName;
}
- return super.createHeaderLabel(item);
- }
- };
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_DURATION)) {
- sectionCreator = new DurationCompare<Song>(context) {
- @Override
- public int getInt(Song item) {
- return item.mDuration;
- }
- };
- } else if (sortOrder.equals(SortOrder.SongSortOrder.SONG_YEAR)) {
- sectionCreator = new SectionCreatorUtils.IntCompare<Song>() {
- @Override
- public int getInt(Song item) {
- return item.mYear;
- }
+ @Override
+ public String createHeaderLabel(Song item) {
+ if (item.mBucketLabel != null) {
+ return super.createHeaderLabel(item.mBucketLabel);
+ }
- @Override
- public String createHeaderLabel(Song item) {
- // I have seen tracks in my library where it would return 0 or 2
- // so have this check to return a more friendly label in that case
- if (MusicUtils.isInvalidYear(item.mYear)) {
- return context.getString(R.string.header_unknown_year);
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
+ case SortOrder.SongSortOrder.SONG_DURATION:
+ sectionCreator = new DurationCompare<Song>(context) {
+ @Override
+ public int getInt(Song item) {
+ return item.mDuration;
+ }
+ };
+ break;
+ case SortOrder.SongSortOrder.SONG_YEAR:
+ sectionCreator = new IntCompare<Song>() {
+ @Override
+ public int getInt(Song item) {
+ return item.mYear;
}
- return super.createHeaderLabel(item);
- }
- };
+ @Override
+ public String createHeaderLabel(Song item) {
+ // I have seen tracks in my library where it would return 0 or 2
+ // so have this check to return a more friendly label in that case
+ if (MusicUtils.isInvalidYear(item.mYear)) {
+ return context.getString(R.string.header_unknown_year);
+ }
+
+ return super.createHeaderLabel(item);
+ }
+ };
+ break;
}
return sectionCreator;
/** Copies the samples into a list, with the oldest entry at index 0. */
List<Sample> asList() {
- List<Sample> list = new ArrayList<Sample>();
+ List<Sample> list = new ArrayList<>();
Sample s = oldest;
while (s != null) {
list.add(s);
entry.mStartTimeMs = parseMs(startEnd[0]);
entry.mEndTimeMs = parseMs(startEnd[1]);
- StringBuilder subtitleBuilder = new StringBuilder("");
+ StringBuilder subtitleBuilder = new StringBuilder();
String s = br.readLine();
if (!TextUtils.isEmpty(s)) {
entry.mLine = subtitleBuilder.toString();
if (ret == null) {
- ret = new ArrayList<SrtEntry>();
+ ret = new ArrayList<>();
}
ret.add(entry);
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Paint;
+import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
*/
@Override
public int getOpacity() {
- return 0;
+ return PixelFormat.OPAQUE;
}
/**
final int mHeight = bounds.height();
final int mWidth = bounds.width();
- numRectanglesHorizontal = (int)Math.ceil((mWidth / mRectangleSize));
- numRectanglesVertical = (int)Math.ceil(mHeight / mRectangleSize);
+ numRectanglesHorizontal = (int) Math.ceil(((double) mWidth / mRectangleSize));
+ numRectanglesVertical = (int) Math.ceil((double) mHeight / mRectangleSize);
generatePatternBitmap();
}
package org.lineageos.eleven.widgets;
+import android.annotation.SuppressLint;
import android.content.Context;
import android.util.AttributeSet;
import android.widget.ImageView;
/**
* {@inheritDoc}
*/
+ @SuppressLint("MissingSuperCall")
@Override
public void requestLayout() {
forceLayout();
import android.graphics.Rect;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
+import android.support.v4.content.ContextCompat;
import android.text.TextUtils;
import org.lineageos.eleven.R;
private ImageType mImageType;
- private static synchronized void initializeStaticVariables(final Resources res) {
+ private static synchronized void initializeStaticVariables(final Context context) {
if (sColors == null) {
+ final Resources res = context.getResources();
sColors = res.obtainTypedArray(R.array.letter_tile_colors);
sVibrantDarkColors = res.obtainTypedArray(R.array.letter_tile_vibrant_dark_colors);
- sDefaultColor = res.getColor(R.color.letter_tile_default_color);
- sTileFontColor = res.getColor(R.color.letter_tile_font_color);
- sLetterToTileRatio = res.getFraction(R.dimen.letter_to_tile_ratio, 1, 1);
+ sDefaultColor = ContextCompat.getColor(context, R.color.letter_tile_default_color);
+ sTileFontColor = ContextCompat.getColor(context, R.color.letter_tile_font_color);
+ sLetterToTileRatio = res.getFraction(R.fraction.letter_to_tile_ratio, 1, 1);
DEFAULT_ARTIST = BitmapFactory.decodeResource(res, R.drawable.ic_artist);
DEFAULT_ARTIST_LARGE = BitmapFactory.decodeResource(res, R.drawable.ic_artist_lg);
DEFAULT_ALBUM = BitmapFactory.decodeResource(res, R.drawable.ic_album);
mPaint.setDither(true);
res = context.getResources();
- initializeStaticVariables(res);
+ initializeStaticVariables(context);
}
@Override
final int minDimension = Math.min(bounds.width(), bounds.height());
if (mIsCircle) {
- canvas.drawCircle(bounds.centerX(), bounds.centerY(), minDimension / 2, sPaint);
+ canvas.drawCircle(bounds.centerX(), bounds.centerY(), (float) minDimension / 2, sPaint);
} else {
canvas.drawRect(bounds, sPaint);
}
// Draw the letter in the canvas, vertically shifted up or down by the user-defined
// offset
canvas.drawText(sChars, 0, numChars, bounds.centerX(),
- bounds.centerY() + mOffset * bounds.height() + sRect.height() / 2,
+ bounds.centerY() + mOffset * bounds.height() + (float) sRect.height() / 2,
sPaint);
} else {
// Draw the default image if there is no letter/digit to be drawn
*/
public static BitmapWithColors createDefaultBitmap(Context context, String identifier,
ImageType type, boolean isCircle, boolean smallArtwork) {
- initializeStaticVariables(context.getResources());
+ initializeStaticVariables(context);
identifier = MusicUtils.getTrimmedName(identifier);
final int minDimension = Math.min(bounds.width(), bounds.height());
if (isCircle) {
- canvas.drawCircle(bounds.centerX(), bounds.centerY(), minDimension / 2, paint);
+ canvas.drawCircle(bounds.centerX(), bounds.centerY(), (float) minDimension / 2, paint);
} else {
canvas.drawRect(bounds, paint);
}
import android.view.ViewAnimationUtils;
import android.view.View.OnClickListener;
import android.view.View.OnLongClickListener;
-import android.view.animation.Animation;
-import android.view.animation.AnimationUtils;
import android.widget.ImageButton;
import org.lineageos.eleven.R;
public class SeparatedListAdapter extends BaseAdapter {
- public final Map<String, Adapter> mSections = new LinkedHashMap<String, Adapter>();
+ public final Map<String, Adapter> mSections = new LinkedHashMap<>();
public final ArrayAdapter<String> mHeaders;
* @param context The {@link Context} to use.
*/
public SeparatedListAdapter(final Context context) {
- mHeaders = new ArrayAdapter<String>(context, R.layout.list_header);
+ mHeaders = new ArrayAdapter<>(context, R.layout.list_header);
}
/**
package org.lineageos.eleven.widgets;
+import android.annotation.SuppressLint;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
/**
* {@inheritDoc}
*/
+ @SuppressWarnings("SuspiciousNameCombination")
@Override
protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
final View mChildren = getChildAt(0);
/**
* {@inheritDoc}
*/
+ @SuppressLint("MissingSuperCall")
@Override
public void requestLayout() {
forceLayout();
OSDN Git Service
