Merge "Music app: Handle audio VIEW and PICK in TrackBrowserActivity"
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index b8e337b..6adb4b3 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -60,6 +60,63 @@
</intent-filter>
</activity>
+ <activity android:name="AudioPreview" android:theme="@android:style/Theme.Dialog"
+ android:taskAffinity=""
+ android:excludeFromRecents="true" android:exported="true" >
+ <intent-filter>
+ <action android:name="android.intent.action.VIEW" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <data android:scheme="file"/>
+ <data android:mimeType="audio/*"/>
+ <data android:mimeType="application/ogg"/>
+ <data android:mimeType="application/x-ogg"/>
+ <data android:mimeType="application/itunes"/>
+ </intent-filter>
+ <intent-filter>
+ <action android:name="android.intent.action.VIEW" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <category android:name="android.intent.category.BROWSABLE" />
+ <data android:scheme="http" />
+ <data android:mimeType="audio/*"/>
+ <data android:mimeType="application/ogg"/>
+ <data android:mimeType="application/x-ogg"/>
+ <data android:mimeType="application/itunes"/>
+ </intent-filter>
+ <intent-filter
+ android:priority="-1">
+ <action android:name="android.intent.action.VIEW" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <category android:name="android.intent.category.BROWSABLE" />
+ <data android:scheme="content" />
+ <data android:mimeType="audio/*"/>
+ <data android:mimeType="application/ogg"/>
+ <data android:mimeType="application/x-ogg"/>
+ <data android:mimeType="application/itunes"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="com.android.music.MusicPicker"
+ android:label="@string/music_picker_title" android:exported="true" >
+ <!-- First way to invoke us: someone asks to get content of
+ any of the audio types we support. -->
+ <intent-filter>
+ <action android:name="android.intent.action.GET_CONTENT" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <category android:name="android.intent.category.OPENABLE" />
+ <data android:mimeType="audio/*"/>
+ <data android:mimeType="application/ogg"/>
+ <data android:mimeType="application/x-ogg"/>
+ </intent-filter>
+ <!-- Second way to invoke us: someone asks to pick an item from
+ some media Uri. -->
+ <intent-filter>
+ <action android:name="android.intent.action.PICK" />
+ <category android:name="android.intent.category.DEFAULT" />
+ <category android:name="android.intent.category.OPENABLE" />
+ <data android:mimeType="vnd.android.cursor.dir/audio"/>
+ </intent-filter>
+ </activity>
+
<!--
This is the "current music playing" panel, which has special
launch behavior. We clear its task affinity, so it will not
diff --git a/src/com/android/music/AudioPreview.java b/src/com/android/music/AudioPreview.java
new file mode 100644
index 0000000..c05884b
--- /dev/null
+++ b/src/com/android/music/AudioPreview.java
@@ -0,0 +1,487 @@
+/*
+ * Copyright (C) 2010 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.Activity;
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.AudioManager.OnAudioFocusChangeListener;
+import android.media.MediaPlayer.OnCompletionListener;
+import android.media.MediaPlayer.OnErrorListener;
+import android.media.MediaPlayer.OnPreparedListener;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.MediaStore;
+import android.provider.OpenableColumns;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.ImageButton;
+import android.widget.ProgressBar;
+import android.widget.SeekBar;
+import android.widget.TextView;
+import android.widget.SeekBar.OnSeekBarChangeListener;
+import android.widget.Toast;
+
+import java.io.IOException;
+
+/**
+ * Dialog that comes up in response to various music-related VIEW intents.
+ */
+public class AudioPreview
+ extends Activity implements OnPreparedListener, OnErrorListener, OnCompletionListener {
+ private final static String TAG = "AudioPreview";
+ private PreviewPlayer mPlayer;
+ private TextView mTextLine1;
+ private TextView mTextLine2;
+ private TextView mLoadingText;
+ private SeekBar mSeekBar;
+ private Handler mProgressRefresher;
+ private boolean mSeeking = false;
+ private boolean mUiPaused = true;
+ private int mDuration;
+ private Uri mUri;
+ private long mMediaId = -1;
+ private static final int OPEN_IN_MUSIC = 1;
+ private AudioManager mAudioManager;
+ private boolean mPausedByTransientLossOfFocus;
+
+ @Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+
+ Intent intent = getIntent();
+ if (intent == null) {
+ finish();
+ return;
+ }
+ mUri = intent.getData();
+ if (mUri == null) {
+ finish();
+ return;
+ }
+ String scheme = mUri.getScheme();
+
+ setVolumeControlStream(AudioManager.STREAM_MUSIC);
+ requestWindowFeature(Window.FEATURE_NO_TITLE);
+ setContentView(R.layout.audiopreview);
+
+ mTextLine1 = (TextView) findViewById(R.id.line1);
+ mTextLine2 = (TextView) findViewById(R.id.line2);
+ mLoadingText = (TextView) findViewById(R.id.loading);
+ if (scheme.equals("http")) {
+ String msg = getString(R.string.streamloadingtext, mUri.getHost());
+ mLoadingText.setText(msg);
+ } else {
+ mLoadingText.setVisibility(View.GONE);
+ }
+ mSeekBar = (SeekBar) findViewById(R.id.progress);
+ mProgressRefresher = new Handler();
+ mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
+
+ PreviewPlayer player = (PreviewPlayer) getLastNonConfigurationInstance();
+ if (player == null) {
+ mPlayer = new PreviewPlayer();
+ mPlayer.setActivity(this);
+ try {
+ mPlayer.setDataSourceAndPrepare(mUri);
+ } catch (Exception ex) {
+ // catch generic Exception, since we may be called with a media
+ // content URI, another content provider's URI, a file URI,
+ // an http URI, and there are different exceptions associated
+ // with failure to open each of those.
+ Log.d(TAG, "Failed to open file: " + ex);
+ Toast.makeText(this, R.string.playback_failed, Toast.LENGTH_SHORT).show();
+ finish();
+ return;
+ }
+ } else {
+ mPlayer = player;
+ mPlayer.setActivity(this);
+ // onResume will update the UI
+ }
+
+ AsyncQueryHandler mAsyncQueryHandler = new AsyncQueryHandler(getContentResolver()) {
+ @Override
+ protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+ if (cursor != null && cursor.moveToFirst()) {
+ int titleIdx = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE);
+ int artistIdx = cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST);
+ int idIdx = cursor.getColumnIndex(MediaStore.Audio.Media._ID);
+ int displaynameIdx = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+
+ if (idIdx >= 0) {
+ mMediaId = cursor.getLong(idIdx);
+ }
+
+ if (titleIdx >= 0) {
+ String title = cursor.getString(titleIdx);
+ mTextLine1.setText(title);
+ if (artistIdx >= 0) {
+ String artist = cursor.getString(artistIdx);
+ mTextLine2.setText(artist);
+ }
+ } else if (displaynameIdx >= 0) {
+ String name = cursor.getString(displaynameIdx);
+ mTextLine1.setText(name);
+ } else {
+ // Couldn't find anything to display, what to do now?
+ Log.w(TAG, "Cursor had no names for us");
+ }
+ } else {
+ Log.w(TAG, "empty cursor");
+ }
+
+ if (cursor != null) {
+ cursor.close();
+ }
+ setNames();
+ }
+ };
+
+ if (scheme.equals(ContentResolver.SCHEME_CONTENT)) {
+ if (mUri.getAuthority() == MediaStore.AUTHORITY) {
+ // try to get title and artist from the media content provider
+ mAsyncQueryHandler.startQuery(0, null, mUri,
+ new String[] {MediaStore.Audio.Media.TITLE, MediaStore.Audio.Media.ARTIST},
+ null, null, null);
+ } else {
+ // Try to get the display name from another content provider.
+ // Don't specifically ask for the display name though, since the
+ // provider might not actually support that column.
+ mAsyncQueryHandler.startQuery(0, null, mUri, null, null, null, null);
+ }
+ } else if (scheme.equals("file")) {
+ // check if this file is in the media database (clicking on a download
+ // in the download manager might follow this path
+ String path = mUri.getPath();
+ mAsyncQueryHandler.startQuery(0, null, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
+ new String[] {MediaStore.Audio.Media._ID, MediaStore.Audio.Media.TITLE,
+ MediaStore.Audio.Media.ARTIST},
+ MediaStore.Audio.Media.DATA + "=?", new String[] {path}, null);
+ } else {
+ // We can't get metadata from the file/stream itself yet, because
+ // that API is hidden, so instead we display the URI being played
+ if (mPlayer.isPrepared()) {
+ setNames();
+ }
+ }
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+ mUiPaused = true;
+ if (mProgressRefresher != null) {
+ mProgressRefresher.removeCallbacksAndMessages(null);
+ }
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ mUiPaused = false;
+ if (mPlayer.isPrepared()) {
+ showPostPrepareUI();
+ }
+ }
+
+ @Override
+ public Object onRetainNonConfigurationInstance() {
+ PreviewPlayer player = mPlayer;
+ mPlayer = null;
+ return player;
+ }
+
+ @Override
+ public void onDestroy() {
+ stopPlayback();
+ super.onDestroy();
+ }
+
+ private void stopPlayback() {
+ if (mProgressRefresher != null) {
+ mProgressRefresher.removeCallbacksAndMessages(null);
+ }
+ if (mPlayer != null) {
+ mPlayer.release();
+ mPlayer = null;
+ mAudioManager.abandonAudioFocus(mAudioFocusListener);
+ }
+ }
+
+ @Override
+ public void onUserLeaveHint() {
+ stopPlayback();
+ finish();
+ super.onUserLeaveHint();
+ }
+
+ public void onPrepared(MediaPlayer mp) {
+ if (isFinishing()) return;
+ mPlayer = (PreviewPlayer) mp;
+ setNames();
+ mPlayer.start();
+ showPostPrepareUI();
+ }
+
+ private void showPostPrepareUI() {
+ ProgressBar pb = (ProgressBar) findViewById(R.id.spinner);
+ pb.setVisibility(View.GONE);
+ mDuration = mPlayer.getDuration();
+ if (mDuration != 0) {
+ mSeekBar.setMax(mDuration);
+ mSeekBar.setVisibility(View.VISIBLE);
+ if (!mSeeking) {
+ mSeekBar.setProgress(mPlayer.getCurrentPosition());
+ }
+ }
+ mSeekBar.setOnSeekBarChangeListener(mSeekListener);
+ mLoadingText.setVisibility(View.GONE);
+ View v = findViewById(R.id.titleandbuttons);
+ v.setVisibility(View.VISIBLE);
+ mAudioManager.requestAudioFocus(mAudioFocusListener, AudioManager.STREAM_MUSIC,
+ AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
+ if (mProgressRefresher != null) {
+ mProgressRefresher.removeCallbacksAndMessages(null);
+ mProgressRefresher.postDelayed(new ProgressRefresher(), 200);
+ }
+ updatePlayPause();
+ }
+
+ private OnAudioFocusChangeListener mAudioFocusListener = new OnAudioFocusChangeListener() {
+ public void onAudioFocusChange(int focusChange) {
+ if (mPlayer == null) {
+ // this activity has handed its MediaPlayer off to the next activity
+ // (e.g. portrait/landscape switch) and should abandon its focus
+ mAudioManager.abandonAudioFocus(this);
+ return;
+ }
+ switch (focusChange) {
+ case AudioManager.AUDIOFOCUS_LOSS:
+ mPausedByTransientLossOfFocus = false;
+ mPlayer.pause();
+ break;
+ case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
+ case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
+ if (mPlayer.isPlaying()) {
+ mPausedByTransientLossOfFocus = true;
+ mPlayer.pause();
+ }
+ break;
+ case AudioManager.AUDIOFOCUS_GAIN:
+ if (mPausedByTransientLossOfFocus) {
+ mPausedByTransientLossOfFocus = false;
+ start();
+ }
+ break;
+ }
+ updatePlayPause();
+ }
+ };
+
+ private void start() {
+ mAudioManager.requestAudioFocus(mAudioFocusListener, AudioManager.STREAM_MUSIC,
+ AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
+ mPlayer.start();
+ mProgressRefresher.postDelayed(new ProgressRefresher(), 200);
+ }
+
+ public void setNames() {
+ if (TextUtils.isEmpty(mTextLine1.getText())) {
+ mTextLine1.setText(mUri.getLastPathSegment());
+ }
+ if (TextUtils.isEmpty(mTextLine2.getText())) {
+ mTextLine2.setVisibility(View.GONE);
+ } else {
+ mTextLine2.setVisibility(View.VISIBLE);
+ }
+ }
+
+ class ProgressRefresher implements Runnable {
+ @Override
+ public void run() {
+ if (mPlayer != null && !mSeeking && mDuration != 0) {
+ mSeekBar.setProgress(mPlayer.getCurrentPosition());
+ }
+ mProgressRefresher.removeCallbacksAndMessages(null);
+ if (!mUiPaused) {
+ mProgressRefresher.postDelayed(new ProgressRefresher(), 200);
+ }
+ }
+ }
+
+ private void updatePlayPause() {
+ ImageButton b = (ImageButton) findViewById(R.id.playpause);
+ if (b != null && mPlayer != null) {
+ if (mPlayer.isPlaying()) {
+ b.setImageResource(R.drawable.btn_playback_ic_pause_small);
+ } else {
+ b.setImageResource(R.drawable.btn_playback_ic_play_small);
+ mProgressRefresher.removeCallbacksAndMessages(null);
+ }
+ }
+ }
+
+ private OnSeekBarChangeListener mSeekListener = new OnSeekBarChangeListener() {
+ public void onStartTrackingTouch(SeekBar bar) {
+ mSeeking = true;
+ }
+ public void onProgressChanged(SeekBar bar, int progress, boolean fromuser) {
+ if (!fromuser) {
+ return;
+ }
+ // Protection for case of simultaneously tapping on seek bar and exit
+ if (mPlayer == null) {
+ return;
+ }
+ mPlayer.seekTo(progress);
+ }
+ public void onStopTrackingTouch(SeekBar bar) {
+ mSeeking = false;
+ }
+ };
+
+ public boolean onError(MediaPlayer mp, int what, int extra) {
+ Toast.makeText(this, R.string.playback_failed, Toast.LENGTH_SHORT).show();
+ finish();
+ return true;
+ }
+
+ public void onCompletion(MediaPlayer mp) {
+ mSeekBar.setProgress(mDuration);
+ updatePlayPause();
+ }
+
+ public void playPauseClicked(View v) {
+ // Protection for case of simultaneously tapping on play/pause and exit
+ if (mPlayer == null) {
+ return;
+ }
+ if (mPlayer.isPlaying()) {
+ mPlayer.pause();
+ } else {
+ start();
+ }
+ updatePlayPause();
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ super.onCreateOptionsMenu(menu);
+ // TODO: if mMediaId != -1, then the playing file has an entry in the media
+ // database, and we could open it in the full music app instead.
+ // Ideally, we would hand off the currently running mediaplayer
+ // to the music UI, which can probably be done via a public static
+ menu.add(0, OPEN_IN_MUSIC, 0, "open in music");
+ return true;
+ }
+
+ @Override
+ public boolean onPrepareOptionsMenu(Menu menu) {
+ MenuItem item = menu.findItem(OPEN_IN_MUSIC);
+ if (mMediaId >= 0) {
+ item.setVisible(true);
+ return true;
+ }
+ item.setVisible(false);
+ return false;
+ }
+
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ switch (keyCode) {
+ case KeyEvent.KEYCODE_HEADSETHOOK:
+ case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
+ if (mPlayer.isPlaying()) {
+ mPlayer.pause();
+ } else {
+ start();
+ }
+ updatePlayPause();
+ return true;
+ case KeyEvent.KEYCODE_MEDIA_PLAY:
+ start();
+ updatePlayPause();
+ return true;
+ case KeyEvent.KEYCODE_MEDIA_PAUSE:
+ if (mPlayer.isPlaying()) {
+ mPlayer.pause();
+ }
+ updatePlayPause();
+ return true;
+ case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
+ case KeyEvent.KEYCODE_MEDIA_NEXT:
+ case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
+ case KeyEvent.KEYCODE_MEDIA_REWIND:
+ return true;
+ case KeyEvent.KEYCODE_MEDIA_STOP:
+ case KeyEvent.KEYCODE_BACK:
+ stopPlayback();
+ finish();
+ return true;
+ }
+ return super.onKeyDown(keyCode, event);
+ }
+
+ /*
+ * Wrapper class to help with handing off the MediaPlayer to the next instance
+ * of the activity in case of orientation change, without losing any state.
+ */
+ private static class PreviewPlayer extends MediaPlayer implements OnPreparedListener {
+ AudioPreview mActivity;
+ boolean mIsPrepared = false;
+
+ public void setActivity(AudioPreview activity) {
+ mActivity = activity;
+ setOnPreparedListener(this);
+ setOnErrorListener(mActivity);
+ setOnCompletionListener(mActivity);
+ }
+
+ public void setDataSourceAndPrepare(Uri uri) throws IllegalArgumentException,
+ SecurityException,
+ IllegalStateException, IOException {
+ setDataSource(mActivity, uri);
+ prepareAsync();
+ }
+
+ /* (non-Javadoc)
+ * @see android.media.MediaPlayer.OnPreparedListener#onPrepared(android.media.MediaPlayer)
+ */
+ @Override
+ public void onPrepared(MediaPlayer mp) {
+ mIsPrepared = true;
+ mActivity.onPrepared(mp);
+ }
+
+ boolean isPrepared() {
+ return mIsPrepared;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/music/MediaPlaybackActivity.java b/src/com/android/music/MediaPlaybackActivity.java
index 099ef4c..6b83073 100644
--- a/src/com/android/music/MediaPlaybackActivity.java
+++ b/src/com/android/music/MediaPlaybackActivity.java
@@ -42,8 +42,15 @@
import android.view.View;
import android.view.ViewConfiguration;
import android.view.Window;
-import android.widget.*;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
+import android.widget.TextView;
+import android.widget.Toast;
+
import com.android.music.utils.LogHelper;
import com.android.music.utils.MediaIDHelper;
import com.android.music.utils.MusicProvider;
@@ -656,11 +663,11 @@
private long updateProgressBar() {
MediaController mediaController = getMediaController();
- if (mediaController == null) {
+ if (mediaController == null || mediaController.getMetadata() == null
+ || mediaController.getPlaybackState() == null) {
return 500;
}
- long duration =
- getMediaController().getMetadata().getLong(MediaMetadata.METADATA_KEY_DURATION);
+ long duration = mediaController.getMetadata().getLong(MediaMetadata.METADATA_KEY_DURATION);
long pos = mediaController.getPlaybackState().getPosition();
if ((pos >= 0) && (duration > 0)) {
mCurrentTime.setText(MusicUtils.makeTimeString(this, pos / 1000));
diff --git a/src/com/android/music/MusicPicker.java b/src/com/android/music/MusicPicker.java
new file mode 100644
index 0000000..ea32ec9
--- /dev/null
+++ b/src/com/android/music/MusicPicker.java
@@ -0,0 +1,688 @@
+/*
+ * 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 {
+ 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;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/com/android/music/TrackBrowserActivity.java b/src/com/android/music/TrackBrowserActivity.java
index 69ce726..7fb41b4 100644
--- a/src/com/android/music/TrackBrowserActivity.java
+++ b/src/com/android/music/TrackBrowserActivity.java
@@ -82,7 +82,7 @@
MusicUtils.updateNowPlaying(this);
} else if (intent != null) {
LogHelper.d(TAG, "Launch by intent");
- mParentItem = intent.getExtras().getParcelable(MusicUtils.TAG_PARENT_ITEM);
+ mParentItem = intent.getParcelableExtra(MusicUtils.TAG_PARENT_ITEM);
mWithTabs = intent.getBooleanExtra(MusicUtils.TAG_WITH_TABS, false);
}
if (mParentItem == null) {
