/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.music;
import android.app.ListActivity;
import android.content.AsyncQueryHandler;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.database.CharArrayBuffer;
import android.database.Cursor;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcelable;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RadioButton;
import android.widget.SectionIndexer;
import android.widget.SimpleCursorAdapter;
import android.widget.TextView;
import java.io.IOException;
import java.text.Collator;
import java.util.Formatter;
import java.util.Locale;
/**
* Activity allowing the user to select a music track on the device, and
* return it to its caller. The music picker user interface is fairly
* extensive, providing information about each track like the music
* application (title, author, album, duration), as well as the ability to
* previous tracks and sort them in different orders.
*
* <p>This class also illustrates how you can load data from a content
* provider asynchronously, providing a good UI while doing so, perform
* indexing of the content for use inside of a {@link FastScrollView}, and
* perform filtering of the data as the user presses keys.
*/
public class MusicPicker extends ListActivity
implements View.OnClickListener, MediaPlayer.OnCompletionListener,
MusicUtils.Defs {
static final boolean DBG = false;
static final String TAG = "MusicPicker";
/** Holds the previous state of the list, to restore after the async
* query has completed. */
static final String LIST_STATE_KEY = "liststate";
/** Remember whether the list last had focus for restoring its state. */
static final String FOCUS_KEY = "focused";
/** Remember the last ordering mode for restoring state. */
static final String SORT_MODE_KEY = "sortMode";
/** Arbitrary number, doesn't matter since we only do one query type. */
static final int MY_QUERY_TOKEN = 42;
/** Menu item to sort the music list by track title. */
static final int TRACK_MENU = Menu.FIRST;
/** Menu item to sort the music list by album title. */
static final int ALBUM_MENU = Menu.FIRST+1;
/** Menu item to sort the music list by artist name. */
static final int ARTIST_MENU = Menu.FIRST+2;
/** These are the columns in the music cursor that we are interested in. */
static final String[] CURSOR_COLS = new String[] {
MediaStore.Audio.Media._ID,
MediaStore.Audio.Media.TITLE,
MediaStore.Audio.Media.TITLE_KEY,
MediaStore.Audio.Media.DATA,
MediaStore.Audio.Media.ALBUM,
MediaStore.Audio.Media.ARTIST,
MediaStore.Audio.Media.ARTIST_ID,
MediaStore.Audio.Media.DURATION,
MediaStore.Audio.Media.TRACK
};
/** Formatting optimization to avoid creating many temporary objects. */
static StringBuilder sFormatBuilder = new StringBuilder();
/** Formatting optimization to avoid creating many temporary objects. */
static Formatter sFormatter = new Formatter(sFormatBuilder, Locale.getDefault());
/** Formatting optimization to avoid creating many temporary objects. */
static final Object[] sTimeArgs = new Object[5];
/** Uri to the directory of all music being displayed. */
Uri mBaseUri;
/** This is the adapter used to display all of the tracks. */
TrackListAdapter mAdapter;
/** Our instance of QueryHandler used to perform async background queries. */
QueryHandler mQueryHandler;
/** Used to keep track of the last scroll state of the list. */
Parcelable mListState = null;
/** Used to keep track of whether the list last had focus. */
boolean mListHasFocus;
/** The current cursor on the music that is being displayed. */
Cursor mCursor;
/** The actual sort order the user has selected. */
int mSortMode = -1;
/** SQL order by string describing the currently selected sort order. */
String mSortOrder;
/** Container of the in-screen progress indicator, to be able to hide it
* when done loading the initial cursor. */
View mProgressContainer;
/** Container of the list view hierarchy, to be able to show it when done
* loading the initial cursor. */
View mListContainer;
/** Set to true when the list view has been shown for the first time. */
boolean mListShown;
/** View holding the okay button. */
View mOkayButton;
/** View holding the cancel button. */
View mCancelButton;
/** Which track row ID the user has last selected. */
long mSelectedId = -1;
/** Completel Uri that the user has last selected. */
Uri mSelectedUri;
/** If >= 0, we are currently playing a track for preview, and this is its
* row ID. */
long mPlayingId = -1;
/** This is used for playing previews of the music files. */
MediaPlayer mMediaPlayer;
/**
* A special implementation of SimpleCursorAdapter that knows how to bind
* our cursor data to our list item structure, and takes care of other
* advanced features such as indexing and filtering.
*/
class TrackListAdapter extends SimpleCursorAdapter
implements SectionIndexer {
final ListView mListView;
private final StringBuilder mBuilder = new StringBuilder();
private final String mUnknownArtist;
private final String mUnknownAlbum;
private int mIdIdx;
private int mTitleIdx;
private int mArtistIdx;
private int mAlbumIdx;
private int mDurationIdx;
private boolean mLoading = true;
private int mIndexerSortMode;
private MusicAlphabetIndexer mIndexer;
class ViewHolder {
TextView line1;
TextView line2;
TextView duration;
RadioButton radio;
ImageView play_indicator;
CharArrayBuffer buffer1;
char [] buffer2;
}
TrackListAdapter(Context context, ListView listView, int layout,
String[] from, int[] to) {
super(context, layout, null, from, to);
mListView = listView;
mUnknownArtist = context.getString(R.string.unknown_artist_name);
mUnknownAlbum = context.getString(R.string.unknown_album_name);
}
/**
* The mLoading flag is set while we are performing a background
* query, to avoid displaying the "No music" empty view during
* this time.
*/
public void setLoading(boolean loading) {
mLoading = loading;
}
@Override
public boolean isEmpty() {
if (mLoading) {
// We don't want the empty state to show when loading.
return false;
} else {
return super.isEmpty();
}
}
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
View v = super.newView(context, cursor, parent);
ViewHolder vh = new ViewHolder();
vh.line1 = (TextView) v.findViewById(R.id.line1);
vh.line2 = (TextView) v.findViewById(R.id.line2);
vh.duration = (TextView) v.findViewById(R.id.duration);
vh.radio = (RadioButton) v.findViewById(R.id.radio);
vh.play_indicator = (ImageView) v.findViewById(R.id.play_indicator);
vh.buffer1 = new CharArrayBuffer(100);
vh.buffer2 = new char[200];
v.setTag(vh);
return v;
}
@Override
public void bindView(View view, Context context, Cursor cursor) {
ViewHolder vh = (ViewHolder) view.getTag();
cursor.copyStringToBuffer(mTitleIdx, vh.buffer1);
vh.line1.setText(vh.buffer1.data, 0, vh.buffer1.sizeCopied);
int secs = cursor.getInt(mDurationIdx) / 1000;
if (secs == 0) {
vh.duration.setText("");
} else {
vh.duration.setText(MusicUtils.makeTimeString(context, secs));
}
final StringBuilder builder = mBuilder;
builder.delete(0, builder.length());
String name = cursor.getString(mAlbumIdx);
if (name == null || name.equals("<unknown>")) {
builder.append(mUnknownAlbum);
} else {
builder.append(name);
}
builder.append('\n');
name = cursor.getString(mArtistIdx);
if (name == null || name.equals("<unknown>")) {
builder.append(mUnknownArtist);
} else {
builder.append(name);
}
int len = builder.length();
if (vh.buffer2.length < len) {
vh.buffer2 = new char[len];
}
builder.getChars(0, len, vh.buffer2, 0);
vh.line2.setText(vh.buffer2, 0, len);
// Update the checkbox of the item, based on which the user last
// selected. Note that doing it this way means we must have the
// list view update all of its items when the selected item
// changes.
final long id = cursor.getLong(mIdIdx);
vh.radio.setChecked(id == mSelectedId);
if (DBG) Log.v(TAG, "Binding id=" + id + " sel=" + mSelectedId
+ " playing=" + mPlayingId + " cursor=" + cursor);
// Likewise, display the "now playing" icon if this item is
// currently being previewed for the user.
ImageView iv = vh.play_indicator;
if (id == mPlayingId) {
iv.setImageResource(R.drawable.indicator_ic_mp_playing_list);
iv.setVisibility(View.VISIBLE);
} else {
iv.setVisibility(View.GONE);
}
}
/**
* This method is called whenever we receive a new cursor due to
* an async query, and must take care of plugging the new one in
* to the adapter.
*/
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
if (DBG) Log.v(TAG, "Setting cursor to: " + cursor
+ " from: " + MusicPicker.this.mCursor);
MusicPicker.this.mCursor = cursor;
if (cursor != null) {
// Retrieve indices of the various columns we are interested in.
mIdIdx = cursor.getColumnIndex(MediaStore.Audio.Media._ID);
mTitleIdx = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE);
mArtistIdx = cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST);
mAlbumIdx = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM);
mDurationIdx = cursor.getColumnIndex(MediaStore.Audio.Media.DURATION);
// If the sort mode has changed, or we haven't yet created an
// indexer one, then create a new one that is indexing the
// appropriate column based on the sort mode.
if (mIndexerSortMode != mSortMode || mIndexer == null) {
mIndexerSortMode = mSortMode;
int idx = mTitleIdx;
switch (mIndexerSortMode) {
case ARTIST_MENU:
idx = mArtistIdx;
break;
case ALBUM_MENU:
idx = mAlbumIdx;
break;
}
mIndexer = new MusicAlphabetIndexer(cursor, idx,
getResources().getString(R.string.fast_scroll_alphabet));
// If we have a valid indexer, but the cursor has changed since
// its last use, then point it to the current cursor.
} else {
mIndexer.setCursor(cursor);
}
}
// Ensure that the list is shown (and initial progress indicator
// hidden) in case this is the first cursor we have gotten.
makeListShown();
}
/**
* This method is called from a background thread by the list view
* when the user has typed a letter that should result in a filtering
* of the displayed items. It returns a Cursor, when will then be
* handed to changeCursor.
*/
@Override
public Cursor runQueryOnBackgroundThread(CharSequence constraint) {
if (DBG) Log.v(TAG, "Getting new cursor...");
return doQuery(true, constraint.toString());
}
public int getPositionForSection(int section) {
Cursor cursor = getCursor();
if (cursor == null) {
// No cursor, the section doesn't exist so just return 0
return 0;
}
return mIndexer.getPositionForSection(section);
}
public int getSectionForPosition(int position) {
return 0;
}
public Object[] getSections() {
if (mIndexer != null) {
return mIndexer.getSections();
}
return null;
}
}
/**
* This is our specialization of AsyncQueryHandler applies new cursors
* to our state as they become available.
*/
private final class QueryHandler extends AsyncQueryHandler {
public QueryHandler(Context context) {
super(context.getContentResolver());
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
if (!isFinishing()) {
// Update the adapter: we are no longer loading, and have
// a new cursor for it.
mAdapter.setLoading(false);
mAdapter.changeCursor(cursor);
setProgressBarIndeterminateVisibility(false);
// Now that the cursor is populated again, it's possible to restore the list state
if (mListState != null) {
getListView().onRestoreInstanceState(mListState);
if (mListHasFocus) {
getListView().requestFocus();
}
mListHasFocus = false;
mListState = null;
}
} else {
cursor.close();
}
}
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
int sortMode = TRACK_MENU;
if (icicle == null) {
mSelectedUri = getIntent().getParcelableExtra(
RingtoneManager.EXTRA_RINGTONE_EXISTING_URI);
} else {
mSelectedUri = (Uri)icicle.getParcelable(
RingtoneManager.EXTRA_RINGTONE_EXISTING_URI);
// Retrieve list state. This will be applied after the
// QueryHandler has run
mListState = icicle.getParcelable(LIST_STATE_KEY);
mListHasFocus = icicle.getBoolean(FOCUS_KEY);
sortMode = icicle.getInt(SORT_MODE_KEY, sortMode);
}
if (Intent.ACTION_GET_CONTENT.equals(getIntent().getAction())) {
mBaseUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
} else {
mBaseUri = getIntent().getData();
if (mBaseUri == null) {
Log.w("MusicPicker", "No data URI given to PICK action");
finish();
return;
}
}
setContentView(R.layout.music_picker);
mSortOrder = MediaStore.Audio.Media.TITLE_KEY;
final ListView listView = getListView();
listView.setItemsCanFocus(false);
mAdapter = new TrackListAdapter(this, listView,
R.layout.music_picker_item, new String[] {},
new int[] {});
setListAdapter(mAdapter);
listView.setTextFilterEnabled(true);
// We manually save/restore the listview state
listView.setSaveEnabled(false);
mQueryHandler = new QueryHandler(this);
mProgressContainer = findViewById(R.id.progressContainer);
mListContainer = findViewById(R.id.listContainer);
mOkayButton = findViewById(R.id.okayButton);
mOkayButton.setOnClickListener(this);
mCancelButton = findViewById(R.id.cancelButton);
mCancelButton.setOnClickListener(this);
// If there is a currently selected Uri, then try to determine who
// it is.
if (mSelectedUri != null) {
Uri.Builder builder = mSelectedUri.buildUpon();
String path = mSelectedUri.getEncodedPath();
int idx = path.lastIndexOf('/');
if (idx >= 0) {
path = path.substring(0, idx);
}
builder.encodedPath(path);
Uri baseSelectedUri = builder.build();
if (DBG) Log.v(TAG, "Selected Uri: " + mSelectedUri);
if (DBG) Log.v(TAG, "Selected base Uri: " + baseSelectedUri);
if (DBG) Log.v(TAG, "Base Uri: " + mBaseUri);
if (baseSelectedUri.equals(mBaseUri)) {
// If the base Uri of the selected Uri is the same as our
// content's base Uri, then use the selection!
mSelectedId = ContentUris.parseId(mSelectedUri);
}
}
setSortMode(sortMode);
}
@Override public void onRestart() {
super.onRestart();
doQuery(false, null);
}
@Override public boolean onOptionsItemSelected(MenuItem item) {
if (setSortMode(item.getItemId())) {
return true;
}
return super.onOptionsItemSelected(item);
}
@Override public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(Menu.NONE, TRACK_MENU, Menu.NONE, R.string.sort_by_track);
menu.add(Menu.NONE, ALBUM_MENU, Menu.NONE, R.string.sort_by_album);
menu.add(Menu.NONE, ARTIST_MENU, Menu.NONE, R.string.sort_by_artist);
return true;
}
@Override protected void onSaveInstanceState(Bundle icicle) {
super.onSaveInstanceState(icicle);
// Save list state in the bundle so we can restore it after the
// QueryHandler has run
icicle.putParcelable(LIST_STATE_KEY, getListView().onSaveInstanceState());
icicle.putBoolean(FOCUS_KEY, getListView().hasFocus());
icicle.putInt(SORT_MODE_KEY, mSortMode);
}
@Override public void onPause() {
super.onPause();
stopMediaPlayer();
}
@Override public void onStop() {
super.onStop();
// We don't want the list to display the empty state, since when we
// resume it will still be there and show up while the new query is
// happening. After the async query finishes in response to onResume()
// setLoading(false) will be called.
mAdapter.setLoading(true);
mAdapter.changeCursor(null);
}
/**
* Changes the current sort order, building the appropriate query string
* for the selected order.
*/
boolean setSortMode(int sortMode) {
if (sortMode != mSortMode) {
switch (sortMode) {
case TRACK_MENU:
mSortMode = sortMode;
mSortOrder = MediaStore.Audio.Media.TITLE_KEY;
doQuery(false, null);
return true;
case ALBUM_MENU:
mSortMode = sortMode;
mSortOrder = MediaStore.Audio.Media.ALBUM_KEY + " ASC, "
+ MediaStore.Audio.Media.TRACK + " ASC, "
+ MediaStore.Audio.Media.TITLE_KEY + " ASC";
doQuery(false, null);
return true;
case ARTIST_MENU:
mSortMode = sortMode;
mSortOrder = MediaStore.Audio.Media.ARTIST_KEY + " ASC, "
+ MediaStore.Audio.Media.ALBUM_KEY + " ASC, "
+ MediaStore.Audio.Media.TRACK + " ASC, "
+ MediaStore.Audio.Media.TITLE_KEY + " ASC";
doQuery(false, null);
return true;
}
}
return false;
}
/**
* The first time this is called, we hide the large progress indicator
* and show the list view, doing fade animations between them.
*/
void makeListShown() {
if (!mListShown) {
mListShown = true;
mProgressContainer.startAnimation(AnimationUtils.loadAnimation(
this, android.R.anim.fade_out));
mProgressContainer.setVisibility(View.GONE);
mListContainer.startAnimation(AnimationUtils.loadAnimation(
this, android.R.anim.fade_in));
mListContainer.setVisibility(View.VISIBLE);
}
}
/**
* Common method for performing a query of the music database, called for
* both top-level queries and filtering.
*
* @param sync If true, this query should be done synchronously and the
* resulting cursor returned. If false, it will be done asynchronously and
* null returned.
* @param filterstring If non-null, this is a filter to apply to the query.
*/
Cursor doQuery(boolean sync, String filterstring) {
// Cancel any pending queries
mQueryHandler.cancelOperation(MY_QUERY_TOKEN);
StringBuilder where = new StringBuilder();
where.append(MediaStore.Audio.Media.TITLE + " != ''");
// We want to show all audio files, even recordings. Enforcing the
// following condition would hide recordings.
//where.append(" AND " + MediaStore.Audio.Media.IS_MUSIC + "=1");
Uri uri = mBaseUri;
if (!TextUtils.isEmpty(filterstring)) {
uri = uri.buildUpon().appendQueryParameter("filter", Uri.encode(filterstring)).build();
}
if (sync) {
try {
return getContentResolver().query(uri, CURSOR_COLS,
where.toString(), null, mSortOrder);
} catch (UnsupportedOperationException ex) {
}
} else {
mAdapter.setLoading(true);
setProgressBarIndeterminateVisibility(true);
mQueryHandler.startQuery(MY_QUERY_TOKEN, null, uri, CURSOR_COLS,
where.toString(), null, mSortOrder);
}
return null;
}
@Override protected void onListItemClick(ListView l, View v, int position,
long id) {
mCursor.moveToPosition(position);
if (DBG) Log.v(TAG, "Click on " + position + " (id=" + id
+ ", cursid="
+ mCursor.getLong(mCursor.getColumnIndex(MediaStore.Audio.Media._ID))
+ ") in cursor " + mCursor
+ " adapter=" + l.getAdapter());
setSelected(mCursor);
}
void setSelected(Cursor c) {
Uri uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
long newId = mCursor.getLong(mCursor.getColumnIndex(MediaStore.Audio.Media._ID));
mSelectedUri = ContentUris.withAppendedId(uri, newId);
mSelectedId = newId;
if (newId != mPlayingId || mMediaPlayer == null) {
stopMediaPlayer();
mMediaPlayer = new MediaPlayer();
try {
mMediaPlayer.setDataSource(this, mSelectedUri);
mMediaPlayer.setOnCompletionListener(this);
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_RING);
mMediaPlayer.prepare();
mMediaPlayer.start();
mPlayingId = newId;
getListView().invalidateViews();
} catch (IOException e) {
Log.w("MusicPicker", "Unable to play track", e);
}
} else if (mMediaPlayer != null) {
stopMediaPlayer();
getListView().invalidateViews();
}
}
public void onCompletion(MediaPlayer mp) {
if (mMediaPlayer == mp) {
mp.stop();
mp.release();
mMediaPlayer = null;
mPlayingId = -1;
getListView().invalidateViews();
}
}
void stopMediaPlayer() {
if (mMediaPlayer != null) {
mMediaPlayer.stop();
mMediaPlayer.release();
mMediaPlayer = null;
mPlayingId = -1;
}
}
public void onClick(View v) {
switch (v.getId()) {
case R.id.okayButton:
if (mSelectedId >= 0) {
setResult(RESULT_OK, new Intent().setData(mSelectedUri));
finish();
}
break;
case R.id.cancelButton:
finish();
break;
}
}
}